From d5731f5f53f74ab720f994db2ad93f825ea563ec Mon Sep 17 00:00:00 2001 From: Varun Shetty Date: Fri, 28 Aug 2026 16:35:06 +0000 Subject: [PATCH 1/6] feat(v2): add v1 compat destructuring for auth triggers --- spec/v2/providers/identity.spec.ts | 155 +++++++++++++++++++++++++++++ src/v2/providers/identity.ts | 101 +++++++++++++++++-- 2 files changed, 249 insertions(+), 7 deletions(-) diff --git a/spec/v2/providers/identity.spec.ts b/spec/v2/providers/identity.spec.ts index 158a5ec13..4b9a5d44c 100644 --- a/spec/v2/providers/identity.spec.ts +++ b/spec/v2/providers/identity.spec.ts @@ -632,6 +632,93 @@ describe("identity", () => { func(mockEvent); expect(called).to.be.true; }); + + describe("v1-compatible getters", () => { + it("should provide v1-compatible getters on the event object", () => { + let capturedEvent: any; + const func = identity.onUserCreated((e) => { + capturedEvent = e; + }); + + const mockEvent = { + specversion: "1.0" as const, + source: "//identitytoolkit.googleapis.com/projects/my-project", + id: "event-id", + type: "google.firebase.auth.user.v2.created", + time: "2023-01-01T00:00:00Z", + data: { + value: { + uid: "user-uid-123", + email: "test@example.com", + }, + } as any, + }; + + func(mockEvent); + + expect(capturedEvent.context).to.deep.equal({ + eventId: "event-id", + timestamp: "2023-01-01T00:00:00Z", + eventType: "providers/firebase.auth/eventTypes/user.create", + resource: { + service: "firebaseauth.googleapis.com", + name: "projects/my-project", + }, + params: {}, + }); + + expect(capturedEvent.user.uid).to.equal("user-uid-123"); + expect(capturedEvent.user.email).to.equal("test@example.com"); + }); + + it("should support v1 destructuring assignment ({ user, context })", () => { + let destructuredUser: any; + let destructuredContext: any; + const func = identity.onUserCreated(({ user, context }) => { + destructuredUser = user; + destructuredContext = context; + }); + + const mockEvent = { + specversion: "1.0" as const, + source: "//identitytoolkit.googleapis.com/projects/my-project", + id: "event-id", + type: "google.firebase.auth.user.v2.created", + time: "2023-01-01T00:00:00Z", + data: { + value: { + uid: "destructured-uid", + email: "destructured@example.com", + }, + } as any, + }; + + func(mockEvent); + + expect(destructuredUser.uid).to.equal("destructured-uid"); + expect(destructuredContext.eventId).to.equal("event-id"); + }); + + it("preserves backward compatibility for user tests passing POJOs without v1 getters", async () => { + const func = identity.onUserCreated((event) => { + return event.data.uid; + }); + + const vanillaV2Event: identity.AuthEvent = { + specversion: "1.0", + source: "//identitytoolkit.googleapis.com/projects/my-project", + id: "vanilla-id", + type: "google.firebase.auth.user.v2.created", + time: "2023-01-01T00:00:00Z", + data: { + uid: "vanilla-uid", + } as any, + }; + + const result = await func.run(vanillaV2Event); + expect(result).to.equal("vanilla-uid"); + }); + }); }); describe("onUserDeleted", () => { @@ -747,6 +834,74 @@ describe("identity", () => { func(mockEvent); expect(called).to.be.true; }); + + describe("v1-compatible getters", () => { + it("should provide v1-compatible getters on the event object", () => { + let capturedEvent: any; + const func = identity.onUserDeleted((e) => { + capturedEvent = e; + }); + + const mockEvent = { + specversion: "1.0" as const, + source: "//identitytoolkit.googleapis.com/projects/my-project", + id: "event-id-del", + type: "google.firebase.auth.user.v2.deleted", + time: "2023-01-01T00:00:00Z", + data: { + oldValue: { + uid: "user-uid-del", + email: "del@example.com", + }, + } as any, + }; + + func(mockEvent); + + expect(capturedEvent.context).to.deep.equal({ + eventId: "event-id-del", + timestamp: "2023-01-01T00:00:00Z", + eventType: "providers/firebase.auth/eventTypes/user.delete", + resource: { + service: "firebaseauth.googleapis.com", + name: "projects/my-project", + }, + params: {}, + }); + + expect(capturedEvent.user.uid).to.equal("user-uid-del"); + expect(capturedEvent.user.email).to.equal("del@example.com"); + }); + + it("should support v1 destructuring assignment ({ user, context })", () => { + let destructuredUser: any; + let destructuredContext: any; + const func = identity.onUserDeleted(({ user, context }) => { + destructuredUser = user; + destructuredContext = context; + }); + + const mockEvent = { + specversion: "1.0" as const, + source: "//identitytoolkit.googleapis.com/projects/my-project", + id: "event-id-del", + type: "google.firebase.auth.user.v2.deleted", + time: "2023-01-01T00:00:00Z", + data: { + oldValue: { + uid: "destructured-del-uid", + }, + } as any, + }; + + func(mockEvent); + + expect(destructuredUser.uid).to.equal("destructured-del-uid"); + expect(destructuredContext.eventType).to.equal( + "providers/firebase.auth/eventTypes/user.delete" + ); + }); + }); }); describe("getOpts", () => { diff --git a/src/v2/providers/identity.ts b/src/v2/providers/identity.ts index f992b22de..77ea6ecf0 100644 --- a/src/v2/providers/identity.ts +++ b/src/v2/providers/identity.ts @@ -46,6 +46,7 @@ import * as options from "../options"; import { SupportedSecretParam } from "../../params/types"; import { withInit } from "../../common/onInit"; import { CloudEvent, CloudFunction } from "../core"; +import { addV1Compat, V1Compat } from "../compat"; import { UserRecord as AdminUserRecord } from "firebase-admin/auth"; import { userRecordConstructor } from "../../common/providers/identity"; @@ -495,11 +496,37 @@ function getAuthEvent(raw: CloudEvent): AuthEvent { return event; } +/** @internal */ +export function getV1AuthContext(event: AuthEvent) { + const service = "firebaseauth.googleapis.com"; + const sourcePrefix = `//identitytoolkit.googleapis.com/`; + let resourceName = event.source || ""; + if (resourceName.startsWith(sourcePrefix)) { + resourceName = resourceName.substring(sourcePrefix.length); + } else if (event.project) { + resourceName = `projects/${event.project}`; + } + return { + eventId: event.id, + timestamp: event.time, + eventType: + { + [USER_CREATED_EVENT]: "providers/firebase.auth/eventTypes/user.create", + [USER_DELETED_EVENT]: "providers/firebase.auth/eventTypes/user.delete", + }[event.type as string] || event.type, + resource: { + service, + name: resourceName, + }, + params: {}, + }; +} + /** @hidden */ function makeAuthTrigger( eventType: string, - optsOrHandler: AuthOptions | ((event: AuthEvent) => any | Promise), - handler?: (event: AuthEvent) => any | Promise + optsOrHandler: AuthOptions | ((event: any) => any | Promise), + handler?: (event: any) => any | Promise ): CloudFunction> { const { opts, handler: handlerFunc } = getOptsAndHandler(optsOrHandler, handler); @@ -511,7 +538,11 @@ function makeAuthTrigger( const func = ((raw: CloudEvent) => { const event = getAuthEvent(raw); - return wrappedHandler(event); + const compatEvent = addV1Compat(event, { + context: () => getV1AuthContext(event), + user: () => event.data, + }); + return wrappedHandler(compatEvent); }) as CloudFunction>; func.run = handlerFunc; @@ -548,6 +579,20 @@ function makeAuthTrigger( const USER_CREATED_EVENT = "google.firebase.auth.user.v2.created"; +/** + * Handles user creation events in Firebase Authentication. + * + * To filter for users not associated with a tenant, use the `IS_NOT_TENANT` constant in options. + * + * @beta + * @internal + * + * @param handler - Event handler which is run every time a new user is created. + * @returns A Cloud Function that you can export. + */ +export function onUserCreated( + handler: (event: AuthEvent & V1Compat<"user", User>) => any | Promise +): CloudFunction>; /** * Handles user creation events in Firebase Authentication. * @@ -562,6 +607,20 @@ const USER_CREATED_EVENT = "google.firebase.auth.user.v2.created"; export function onUserCreated( handler: (event: AuthEvent) => any | Promise ): CloudFunction>; +/** + * Handles user creation events in Firebase Authentication. + * + * @beta + * @internal + * + * @param opts - Object containing function options. + * @param handler - Event handler which is run every time a new user is created. + * @returns A Cloud Function that you can export. + */ +export function onUserCreated( + opts: AuthOptions, + handler: (event: AuthEvent & V1Compat<"user", User>) => any | Promise +): CloudFunction>; /** * Handles user creation events in Firebase Authentication. * @@ -577,14 +636,28 @@ export function onUserCreated( handler: (event: AuthEvent) => any | Promise ): CloudFunction>; export function onUserCreated( - optsOrHandler: AuthOptions | ((event: AuthEvent) => any | Promise), - handler?: (event: AuthEvent) => any | Promise + optsOrHandler: AuthOptions | ((event: any) => any | Promise), + handler?: (event: any) => any | Promise ): CloudFunction> { return makeAuthTrigger(USER_CREATED_EVENT, optsOrHandler, handler); } const USER_DELETED_EVENT = "google.firebase.auth.user.v2.deleted"; +/** + * Handles user deletion events in Firebase Authentication. + * + * To filter for users not associated with a tenant, use the `IS_NOT_TENANT` constant in options. + * + * @beta + * @internal + * + * @param handler - Event handler that is run every time a user is deleted. + * @returns A Cloud Function that you can export. + */ +export function onUserDeleted( + handler: (event: AuthEvent & V1Compat<"user", User>) => any | Promise +): CloudFunction>; /** * Handles user deletion events in Firebase Authentication. * @@ -599,6 +672,20 @@ const USER_DELETED_EVENT = "google.firebase.auth.user.v2.deleted"; export function onUserDeleted( handler: (event: AuthEvent) => any | Promise ): CloudFunction>; +/** + * Handles user deletion events in Firebase Authentication. + * + * @beta + * @internal + * + * @param opts - Object containing function options. + * @param handler - Event handler that is run every time a user is deleted. + * @returns A Cloud Function that you can export. + */ +export function onUserDeleted( + opts: AuthOptions, + handler: (event: AuthEvent & V1Compat<"user", User>) => any | Promise +): CloudFunction>; /** * Handles user deletion events in Firebase Authentication. * @@ -614,8 +701,8 @@ export function onUserDeleted( handler: (event: AuthEvent) => any | Promise ): CloudFunction>; export function onUserDeleted( - optsOrHandler: AuthOptions | ((event: AuthEvent) => any | Promise), - handler?: (event: AuthEvent) => any | Promise + optsOrHandler: AuthOptions | ((event: any) => any | Promise), + handler?: (event: any) => any | Promise ): CloudFunction> { return makeAuthTrigger(USER_DELETED_EVENT, optsOrHandler, handler); } From 169972ee477f10985e1fd3263143739b1562cbad Mon Sep 17 00:00:00 2001 From: Varun Shetty Date: Fri, 28 Aug 2026 17:35:38 +0000 Subject: [PATCH 2/6] refactor(v2): extract top-level constants for auth v1 compat --- src/v2/providers/identity.ts | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-) diff --git a/src/v2/providers/identity.ts b/src/v2/providers/identity.ts index 77ea6ecf0..18ed506b8 100644 --- a/src/v2/providers/identity.ts +++ b/src/v2/providers/identity.ts @@ -429,6 +429,10 @@ function getOptsAndHandler( // Matches both absolute paths (/projects/...) and relative paths (projects/...) const PROJECT_ID_REGEX = /(?:^|\/)projects\/([^\/]+)/; +const IDENTITY_TOOLKIT_SOURCE_PREFIX = "//identitytoolkit.googleapis.com/"; +const FIREBASE_AUTH_SERVICE = "firebaseauth.googleapis.com"; +const USER_CREATED_EVENT = "google.firebase.auth.user.v2.created"; +const USER_DELETED_EVENT = "google.firebase.auth.user.v2.deleted"; /** * Converts the v2 Eventarc (`AuthEventData`) protobuf wire protocol (`value`/`oldValue`, `createTime`, `photoUrl`) @@ -498,11 +502,9 @@ function getAuthEvent(raw: CloudEvent): AuthEvent { /** @internal */ export function getV1AuthContext(event: AuthEvent) { - const service = "firebaseauth.googleapis.com"; - const sourcePrefix = `//identitytoolkit.googleapis.com/`; let resourceName = event.source || ""; - if (resourceName.startsWith(sourcePrefix)) { - resourceName = resourceName.substring(sourcePrefix.length); + if (resourceName.startsWith(IDENTITY_TOOLKIT_SOURCE_PREFIX)) { + resourceName = resourceName.substring(IDENTITY_TOOLKIT_SOURCE_PREFIX.length); } else if (event.project) { resourceName = `projects/${event.project}`; } @@ -515,7 +517,7 @@ export function getV1AuthContext(event: AuthEvent) { [USER_DELETED_EVENT]: "providers/firebase.auth/eventTypes/user.delete", }[event.type as string] || event.type, resource: { - service, + service: FIREBASE_AUTH_SERVICE, name: resourceName, }, params: {}, @@ -577,8 +579,6 @@ function makeAuthTrigger( return func; } -const USER_CREATED_EVENT = "google.firebase.auth.user.v2.created"; - /** * Handles user creation events in Firebase Authentication. * @@ -642,8 +642,6 @@ export function onUserCreated( return makeAuthTrigger(USER_CREATED_EVENT, optsOrHandler, handler); } -const USER_DELETED_EVENT = "google.firebase.auth.user.v2.deleted"; - /** * Handles user deletion events in Firebase Authentication. * From 323cf1d38ab2eef6881cb661d6ef8f2d8f185e2b Mon Sep 17 00:00:00 2001 From: Varun Shetty Date: Fri, 28 Aug 2026 17:49:54 +0000 Subject: [PATCH 3/6] fix(v2): wrap func.run with addV1Compat for unit test destructuring --- spec/v2/providers/identity.spec.ts | 46 ++++++++++++++++++++++++++++++ src/v2/providers/identity.ts | 8 +++++- 2 files changed, 53 insertions(+), 1 deletion(-) diff --git a/spec/v2/providers/identity.spec.ts b/spec/v2/providers/identity.spec.ts index 4b9a5d44c..e0d7f24ba 100644 --- a/spec/v2/providers/identity.spec.ts +++ b/spec/v2/providers/identity.spec.ts @@ -718,6 +718,29 @@ describe("identity", () => { const result = await func.run(vanillaV2Event); expect(result).to.equal("vanilla-uid"); }); + + it("supports calling .run() on destructured handlers with vanilla POJO mock events", async () => { + const func = identity.onUserCreated(({ user, context }) => { + return { uid: user.uid, eventId: context.eventId }; + }); + + const vanillaV2Event: identity.AuthEvent = { + specversion: "1.0", + source: "//identitytoolkit.googleapis.com/projects/my-project", + id: "run-event-id", + type: "google.firebase.auth.user.v2.created", + time: "2023-01-01T00:00:00Z", + data: { + uid: "run-destructured-uid", + } as any, + }; + + const result = await func.run(vanillaV2Event); + expect(result).to.deep.equal({ + uid: "run-destructured-uid", + eventId: "run-event-id", + }); + }); }); }); @@ -901,6 +924,29 @@ describe("identity", () => { "providers/firebase.auth/eventTypes/user.delete" ); }); + + it("supports calling .run() on destructured handlers with vanilla POJO mock events", async () => { + const func = identity.onUserDeleted(({ user, context }) => { + return { uid: user.uid, eventType: context.eventType }; + }); + + const vanillaV2Event: identity.AuthEvent = { + specversion: "1.0", + source: "//identitytoolkit.googleapis.com/projects/my-project", + id: "run-del-event-id", + type: "google.firebase.auth.user.v2.deleted", + time: "2023-01-01T00:00:00Z", + data: { + uid: "run-destructured-del-uid", + } as any, + }; + + const result = await func.run(vanillaV2Event); + expect(result).to.deep.equal({ + uid: "run-destructured-del-uid", + eventType: "providers/firebase.auth/eventTypes/user.delete", + }); + }); }); }); diff --git a/src/v2/providers/identity.ts b/src/v2/providers/identity.ts index 18ed506b8..8a0eed6fc 100644 --- a/src/v2/providers/identity.ts +++ b/src/v2/providers/identity.ts @@ -547,7 +547,13 @@ function makeAuthTrigger( return wrappedHandler(compatEvent); }) as CloudFunction>; - func.run = handlerFunc; + func.run = ((event: AuthEvent) => { + const compatEvent = addV1Compat(event, { + context: () => getV1AuthContext(event), + user: () => event.data, + }); + return handlerFunc(compatEvent); + }) as any; const baseOptsEndpoint = options.optionsToEndpoint(options.getGlobalOptions()); const specificOptsEndpoint = options.optionsToEndpoint(opts); const endpoint: ManifestEndpoint = { From 22116b22b6838650085bd13842dda3103d54d6d9 Mon Sep 17 00:00:00 2001 From: Varun Shetty Date: Fri, 28 Aug 2026 18:12:13 +0000 Subject: [PATCH 4/6] fix(v2): add defensive check for nullish event in func.run --- spec/v2/providers/identity.spec.ts | 16 ++++++++++++++++ src/v2/providers/identity.ts | 10 ++++++---- 2 files changed, 22 insertions(+), 4 deletions(-) diff --git a/spec/v2/providers/identity.spec.ts b/spec/v2/providers/identity.spec.ts index e0d7f24ba..86af5d129 100644 --- a/spec/v2/providers/identity.spec.ts +++ b/spec/v2/providers/identity.spec.ts @@ -741,6 +741,22 @@ describe("identity", () => { eventId: "run-event-id", }); }); + + it("handles calling .run() with null or undefined gracefully", async () => { + let received: any; + const func = identity.onUserCreated((event) => { + received = event; + return "handled"; + }); + + const resultNull = await func.run(null as any); + expect(resultNull).to.equal("handled"); + expect(received).to.be.null; + + const resultUndef = await func.run(undefined as any); + expect(resultUndef).to.equal("handled"); + expect(received).to.be.undefined; + }); }); }); diff --git a/src/v2/providers/identity.ts b/src/v2/providers/identity.ts index 8a0eed6fc..503438fa4 100644 --- a/src/v2/providers/identity.ts +++ b/src/v2/providers/identity.ts @@ -548,10 +548,12 @@ function makeAuthTrigger( }) as CloudFunction>; func.run = ((event: AuthEvent) => { - const compatEvent = addV1Compat(event, { - context: () => getV1AuthContext(event), - user: () => event.data, - }); + const compatEvent = event + ? addV1Compat(event, { + context: () => getV1AuthContext(event), + user: () => event.data, + }) + : event; return handlerFunc(compatEvent); }) as any; const baseOptsEndpoint = options.optionsToEndpoint(options.getGlobalOptions()); From 5ff9f84fdec8b65ab7288d4dd3fc431eb2323bbc Mon Sep 17 00:00:00 2001 From: Varun Shetty Date: Fri, 28 Aug 2026 18:27:50 +0000 Subject: [PATCH 5/6] style(v2): resolve typescript-eslint unnecessary type assertions --- spec/v2/providers/identity.spec.ts | 4 ++-- src/v2/providers/identity.ts | 9 +++++---- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/spec/v2/providers/identity.spec.ts b/spec/v2/providers/identity.spec.ts index 86af5d129..d5d5dcb22 100644 --- a/spec/v2/providers/identity.spec.ts +++ b/spec/v2/providers/identity.spec.ts @@ -749,11 +749,11 @@ describe("identity", () => { return "handled"; }); - const resultNull = await func.run(null as any); + const resultNull = await func.run(null); expect(resultNull).to.equal("handled"); expect(received).to.be.null; - const resultUndef = await func.run(undefined as any); + const resultUndef = await func.run(undefined); expect(resultUndef).to.equal("handled"); expect(received).to.be.undefined; }); diff --git a/src/v2/providers/identity.ts b/src/v2/providers/identity.ts index 503438fa4..9134a7da1 100644 --- a/src/v2/providers/identity.ts +++ b/src/v2/providers/identity.ts @@ -512,10 +512,11 @@ export function getV1AuthContext(event: AuthEvent) { eventId: event.id, timestamp: event.time, eventType: - { - [USER_CREATED_EVENT]: "providers/firebase.auth/eventTypes/user.create", - [USER_DELETED_EVENT]: "providers/firebase.auth/eventTypes/user.delete", - }[event.type as string] || event.type, + event.type === USER_CREATED_EVENT + ? "providers/firebase.auth/eventTypes/user.create" + : event.type === USER_DELETED_EVENT + ? "providers/firebase.auth/eventTypes/user.delete" + : event.type, resource: { service: FIREBASE_AUTH_SERVICE, name: resourceName, From 1560e46caaff6f101ca869d1e5f2d39130088bd1 Mon Sep 17 00:00:00 2001 From: Varun Shetty Date: Mon, 31 Aug 2026 16:36:56 +0000 Subject: [PATCH 6/6] refactor(v2): strongly type auth triggers with AuthEventHandler --- spec/v2/providers/identity.spec.ts | 17 +++++++++++++ src/v2/providers/identity.ts | 40 +++++++++++++++++++----------- 2 files changed, 43 insertions(+), 14 deletions(-) diff --git a/spec/v2/providers/identity.spec.ts b/spec/v2/providers/identity.spec.ts index d5d5dcb22..8ca595372 100644 --- a/spec/v2/providers/identity.spec.ts +++ b/spec/v2/providers/identity.spec.ts @@ -742,6 +742,23 @@ describe("identity", () => { }); }); + it("supports calling .run() with an object that already has user and context", async () => { + const func = identity.onUserCreated(({ user, context }) => { + return { uid: user.uid, eventId: context.eventId }; + }); + + const directCompatObject = { + user: { uid: "direct-uid" } as any, + context: { eventId: "direct-event-id" } as any, + }; + + const result = await func.run(directCompatObject as any); + expect(result).to.deep.equal({ + uid: "direct-uid", + eventId: "direct-event-id", + }); + }); + it("handles calling .run() with null or undefined gracefully", async () => { let received: any; const func = identity.onUserCreated((event) => { diff --git a/src/v2/providers/identity.ts b/src/v2/providers/identity.ts index 9134a7da1..b06be65c1 100644 --- a/src/v2/providers/identity.ts +++ b/src/v2/providers/identity.ts @@ -416,10 +416,19 @@ export interface AuthOptions extends options.EventHandlerOptions { */ export const IS_NOT_TENANT = RESET_VALUE; +/** + * Event handler type for Authentication triggers that supports both standard `AuthEvent` + * and V1 compatibility destructuring (`{ user, context }`). + * @internal + */ +export type AuthEventHandler = ( + event: AuthEvent & V1Compat<"user", User> +) => any | Promise; + // Helper to handle overloaded function signature function getOptsAndHandler( - optsOrHandler: AuthOptions | ((event: AuthEvent) => any | Promise), - handler?: (event: AuthEvent) => any | Promise + optsOrHandler: AuthOptions | AuthEventHandler, + handler?: AuthEventHandler ) { if (typeof optsOrHandler === "function") { return { opts: {}, handler: optsOrHandler }; @@ -528,8 +537,8 @@ export function getV1AuthContext(event: AuthEvent) { /** @hidden */ function makeAuthTrigger( eventType: string, - optsOrHandler: AuthOptions | ((event: any) => any | Promise), - handler?: (event: any) => any | Promise + optsOrHandler: AuthOptions | AuthEventHandler, + handler?: AuthEventHandler ): CloudFunction> { const { opts, handler: handlerFunc } = getOptsAndHandler(optsOrHandler, handler); @@ -549,12 +558,15 @@ function makeAuthTrigger( }) as CloudFunction>; func.run = ((event: AuthEvent) => { - const compatEvent = event - ? addV1Compat(event, { - context: () => getV1AuthContext(event), - user: () => event.data, - }) - : event; + if (!event) { + return handlerFunc(event as Parameters[0]); + } + const existingUser = (event as any).user; + const existingContext = (event as any).context; + const compatEvent = addV1Compat(event, { + context: () => existingContext ?? getV1AuthContext(event), + user: () => event.data ?? existingUser, + }); return handlerFunc(compatEvent); }) as any; const baseOptsEndpoint = options.optionsToEndpoint(options.getGlobalOptions()); @@ -645,8 +657,8 @@ export function onUserCreated( handler: (event: AuthEvent) => any | Promise ): CloudFunction>; export function onUserCreated( - optsOrHandler: AuthOptions | ((event: any) => any | Promise), - handler?: (event: any) => any | Promise + optsOrHandler: AuthOptions | AuthEventHandler, + handler?: AuthEventHandler ): CloudFunction> { return makeAuthTrigger(USER_CREATED_EVENT, optsOrHandler, handler); } @@ -708,8 +720,8 @@ export function onUserDeleted( handler: (event: AuthEvent) => any | Promise ): CloudFunction>; export function onUserDeleted( - optsOrHandler: AuthOptions | ((event: any) => any | Promise), - handler?: (event: any) => any | Promise + optsOrHandler: AuthOptions | AuthEventHandler, + handler?: AuthEventHandler ): CloudFunction> { return makeAuthTrigger(USER_DELETED_EVENT, optsOrHandler, handler); }