firebase-functions 3.24.1 → 4.0.0-rc.0

package/lib/{providers → v1/providers}/analytics.js

@@ -22,38 +22,37 @@
 // SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExportBundleInfo = exports.UserPropertyValue = exports.UserDimensions = exports.AnalyticsEvent = exports.AnalyticsEventBuilder = exports._eventWithOptions = exports.event = exports.service = exports.provider = void 0;
-const _ = require("lodash");
 const cloud_functions_1 = require("../cloud-functions");
-/** @hidden */
-exports.provider = 'google.analytics';
-/** @hidden */
-exports.service = 'app-measurement.com';
+/** @internal */
+exports.provider = "google.analytics";
+/** @internal */
+exports.service = "app-measurement.com";
 /**
  * Registers a function to handle analytics events.
  *
  * @param analyticsEventType Name of the analytics event type to which
  *   this Cloud Function is scoped.
  *
- * @return Analytics event builder interface.
+ * @returns Analytics event builder interface.
  */
 function event(analyticsEventType) {
     return _eventWithOptions(analyticsEventType, {});
 }
 exports.event = event;
-/** @hidden */
+/** @internal */
 function _eventWithOptions(analyticsEventType, options) {
     return new AnalyticsEventBuilder(() => {
         if (!process.env.GCLOUD_PROJECT) {
-            throw new Error('process.env.GCLOUD_PROJECT is not set.');
+            throw new Error("process.env.GCLOUD_PROJECT is not set.");
         }
-        return ('projects/' + process.env.GCLOUD_PROJECT + '/events/' + analyticsEventType);
+        return "projects/" + process.env.GCLOUD_PROJECT + "/events/" + analyticsEventType;
     }, options);
 }
 exports._eventWithOptions = _eventWithOptions;
 /**
  * The Firebase Analytics event builder interface.
  *
- * Access via [`functions.analytics.event()`](functions.analytics#.event).
+ * Access via `functions.analytics.event()`.
  */
 class AnalyticsEventBuilder {
     /** @hidden */
@@ -67,7 +66,7 @@ class AnalyticsEventBuilder {
      * @param handler Event handler that fires every time a Firebase Analytics event
      *   occurs.
      *
-     * @return A function that you can export and deploy.
+     * @returns A function that you can export and deploy.
      */
     onLog(handler) {
         const dataConstructor = (raw) => {
@@ -76,7 +75,7 @@ class AnalyticsEventBuilder {
         return (0, cloud_functions_1.makeCloudFunction)({
             handler,
             provider: exports.provider,
-            eventType: 'event.log',
+            eventType: "event.log",
             service: exports.service,
             legacyEventType: `providers/google.firebase.analytics/eventTypes/event.log`,
             triggerResource: this.triggerResource,
@@ -94,14 +93,14 @@ class AnalyticsEvent {
         if (wireFormat.eventDim && wireFormat.eventDim.length > 0) {
             // If there's an eventDim, there'll always be exactly one.
             const eventDim = wireFormat.eventDim[0];
-            copyField(eventDim, this, 'name');
-            copyField(eventDim, this, 'params', (p) => _.mapValues(p, unwrapValue));
-            copyFieldTo(eventDim, this, 'valueInUsd', 'valueInUSD');
-            copyFieldTo(eventDim, this, 'date', 'reportingDate');
-            copyTimestampToString(eventDim, this, 'timestampMicros', 'logTime');
-            copyTimestampToString(eventDim, this, 'previousTimestampMicros', 'previousLogTime');
+            copyField(eventDim, this, "name");
+            copyField(eventDim, this, "params", (p) => mapKeys(p, unwrapValue));
+            copyFieldTo(eventDim, this, "valueInUsd", "valueInUSD");
+            copyFieldTo(eventDim, this, "date", "reportingDate");
+            copyTimestampToString(eventDim, this, "timestampMicros", "logTime");
+            copyTimestampToString(eventDim, this, "previousTimestampMicros", "previousLogTime");
         }
-        copyFieldTo(wireFormat, this, 'userDim', 'user', (dim) => new UserDimensions(dim));
+        copyFieldTo(wireFormat, this, "userDim", "user", (dim) => new UserDimensions(dim));
     }
 }
 exports.AnalyticsEvent = AnalyticsEvent;
@@ -112,21 +111,19 @@ class UserDimensions {
     /** @hidden */
     constructor(wireFormat) {
         // These are interfaces or primitives, no transformation needed.
-        copyFields(wireFormat, this, [
-            'userId',
-            'deviceInfo',
-            'geoInfo',
-            'appInfo',
-        ]);
+        copyFields(wireFormat, this, ["userId", "deviceInfo", "geoInfo", "appInfo"]);
         // The following fields do need transformations of some sort.
-        copyTimestampToString(wireFormat, this, 'firstOpenTimestampMicros', 'firstOpenTime');
+        copyTimestampToString(wireFormat, this, "firstOpenTimestampMicros", "firstOpenTime");
         this.userProperties = {}; // With no entries in the wire format, present an empty (as opposed to absent) map.
-        copyField(wireFormat, this, 'userProperties', (r) => _.mapValues(r, (p) => new UserPropertyValue(p)));
-        copyField(wireFormat, this, 'bundleInfo', (r) => new ExportBundleInfo(r));
+        copyField(wireFormat, this, "userProperties", (r) => {
+            const entries = Object.entries(r).map(([k, v]) => [k, new UserPropertyValue(v)]);
+            return Object.fromEntries(entries);
+        });
+        copyField(wireFormat, this, "bundleInfo", (r) => new ExportBundleInfo(r));
         // BUG(36000368) Remove when no longer necessary
         /* tslint:disable:no-string-literal */
-        if (!this.userId && this.userProperties['user_id']) {
-            this.userId = this.userProperties['user_id'].value;
+        if (!this.userId && this.userProperties["user_id"]) {
+            this.userId = this.userProperties["user_id"].value;
         }
         /* tslint:enable:no-string-literal */
     }
@@ -136,8 +133,8 @@ exports.UserDimensions = UserDimensions;
 class UserPropertyValue {
     /** @hidden */
     constructor(wireFormat) {
-        copyField(wireFormat, this, 'value', unwrapValueAsString);
-        copyTimestampToString(wireFormat, this, 'setTimestampUsec', 'setTime');
+        copyField(wireFormat, this, "value", unwrapValueAsString);
+        copyTimestampToString(wireFormat, this, "setTimestampUsec", "setTime");
     }
 }
 exports.UserPropertyValue = UserPropertyValue;
@@ -145,19 +142,24 @@ exports.UserPropertyValue = UserPropertyValue;
 class ExportBundleInfo {
     /** @hidden */
     constructor(wireFormat) {
-        copyField(wireFormat, this, 'bundleSequenceId');
-        copyTimestampToMillis(wireFormat, this, 'serverTimestampOffsetMicros', 'serverTimestampOffset');
+        copyField(wireFormat, this, "bundleSequenceId");
+        copyTimestampToMillis(wireFormat, this, "serverTimestampOffsetMicros", "serverTimestampOffset");
     }
 }
 exports.ExportBundleInfo = ExportBundleInfo;
 /** @hidden */
-function copyFieldTo(from, to, fromField, toField, transform = _.identity) {
-    if (from[fromField] !== undefined) {
+function copyFieldTo(from, to, fromField, toField, transform) {
+    if (typeof from[fromField] === "undefined") {
+        return;
+    }
+    if (transform) {
         to[toField] = transform(from[fromField]);
+        return;
     }
+    to[toField] = from[fromField];
 }
 /** @hidden */
-function copyField(from, to, field, transform = _.identity) {
+function copyField(from, to, field, transform = (from) => from) {
     copyFieldTo(from, to, field, field, transform);
 }
 /** @hidden */
@@ -166,6 +168,10 @@ function copyFields(from, to, fields) {
         copyField(from, to, field);
     }
 }
+function mapKeys(obj, transform) {
+    const entries = Object.entries(obj).map(([k, v]) => [k, transform(v)]);
+    return Object.fromEntries(entries);
+}
 // The incoming payload will have fields like:
 // {
 //   'myInt': {
@@ -197,8 +203,8 @@ function copyFields(from, to, fields) {
 // 'unwrapValue' method just below.
 /** @hidden */
 function unwrapValueAsString(wrapped) {
-    const key = _.keys(wrapped)[0];
-    return _.toString(wrapped[key]);
+    const key = Object.keys(wrapped)[0];
+    return wrapped[key].toString();
 }
 // Ditto as the method above, but returning the values in the idiomatic JavaScript type (string for strings,
 // number for numbers):
@@ -214,12 +220,12 @@ function unwrapValueAsString(wrapped) {
 // JavaScript's 'number' type, since we prefer using idiomatic types. Note that this may lead to loss
 // in precision for int64 fields, so use with care.
 /** @hidden */
-const xValueNumberFields = ['intValue', 'floatValue', 'doubleValue'];
+const xValueNumberFields = ["intValue", "floatValue", "doubleValue"];
 /** @hidden */
 function unwrapValue(wrapped) {
-    const key = _.keys(wrapped)[0];
+    const key = Object.keys(wrapped)[0];
     const value = unwrapValueAsString(wrapped);
-    return _.includes(xValueNumberFields, key) ? _.toNumber(value) : value;
+    return xValueNumberFields.includes(key) ? Number(value) : value;
 }
 // The JSON payload delivers timestamp fields as strings of timestamps denoted in microseconds.
 // The JavaScript convention is to use numbers denoted in milliseconds. This method
@@ -227,7 +233,7 @@ function unwrapValue(wrapped) {
 /** @hidden */
 function copyTimestampToMillis(from, to, fromName, toName) {
     if (from[fromName] !== undefined) {
-        to[toName] = _.round(from[fromName] / 1000);
+        to[toName] = Math.round(from[fromName] / 1000);
     }
 }
 // The JSON payload delivers timestamp fields as strings of timestamps denoted in microseconds.

package/lib/{providers → v1/providers}/auth.d.ts

@@ -1,15 +1,9 @@
-import { BlockingFunction, CloudFunction, EventContext } from '../cloud-functions';
-import { AuthEventContext, AuthUserRecord, BeforeCreateResponse, BeforeSignInResponse, HttpsError, UserInfo, UserRecord, userRecordConstructor, UserRecordMetadata } from '../common/providers/identity';
-import { DeploymentOptions } from '../function-configuration';
+import { AuthEventContext, AuthUserRecord, BeforeCreateResponse, BeforeSignInResponse, HttpsError, UserInfo, UserRecord, userRecordConstructor, UserRecordMetadata } from "../../common/providers/identity";
+import { BlockingFunction, CloudFunction, EventContext } from "../cloud-functions";
 export { UserRecord, UserInfo, UserRecordMetadata, userRecordConstructor };
 export { HttpsError };
-/** @hidden */
-export declare const provider = "google.firebase.auth";
-/** @hidden */
-export declare const service = "firebaseauth.googleapis.com";
 /**
- * Resource level options
- * @public
+ * Options for Auth blocking function.
  */
 export interface UserOptions {
     /** Options to set configuration at the resource level for blocking functions. */
@@ -23,16 +17,16 @@ export interface UserOptions {
     };
 }
 /**
- * Handles events related to Firebase authentication users.
+ * Handles events related to Firebase Auth users events.
+ *
  * @param userOptions - Resource level options
- * @returns UserBuilder - Builder used to create Cloud Functions for Firebase Auth user lifecycle events
+ * @returns UserBuilder - Builder used to create functions for Firebase Auth user lifecycle events
+ *
  * @public
  */
 export declare function user(userOptions?: UserOptions): UserBuilder;
-/** @hidden */
-export declare function _userWithOptions(options: DeploymentOptions, userOptions: UserOptions): UserBuilder;
 /**
- * Builder used to create Cloud Functions for Firebase Auth user lifecycle events.
+ * Builder used to create functions for Firebase Auth user lifecycle events.
  * @public
  */
 export declare class UserBuilder {
@@ -40,22 +34,38 @@ export declare class UserBuilder {
     private options;
     private userOptions?;
     private static dataConstructor;
-    /** @hidden */
-    constructor(triggerResource: () => string, options: DeploymentOptions, userOptions?: UserOptions);
     /**
      * Responds to the creation of a Firebase Auth user.
+     *
+     * @param handler Event handler that responds to the creation of a Firebase Auth user.
+     *
      * @public
      */
     onCreate(handler: (user: UserRecord, context: EventContext) => PromiseLike<any> | any): CloudFunction<UserRecord>;
     /**
      * Responds to the deletion of a Firebase Auth user.
+     *
+     * @param handler Event handler that responds to the deletion of a Firebase Auth user.
+     *
      * @public
      */
     onDelete(handler: (user: UserRecord, context: EventContext) => PromiseLike<any> | any): CloudFunction<UserRecord>;
+    /**
+     * Blocks request to create a Firebase Auth user.
+     *
+     * @param handler Event handler that blocks creation of a Firebase Auth user.
+     *
+     * @public
+     */
     beforeCreate(handler: (user: AuthUserRecord, context: AuthEventContext) => BeforeCreateResponse | void | Promise<BeforeCreateResponse> | Promise<void>): BlockingFunction;
+    /**
+     * Blocks request to sign-in a Firebase Auth user.
+     *
+     * @param handler Event handler that blocks sign-in of a Firebase Auth user.
+     *
+     * @public
+     */
     beforeSignIn(handler: (user: AuthUserRecord, context: AuthEventContext) => BeforeSignInResponse | void | Promise<BeforeSignInResponse> | Promise<void>): BlockingFunction;
-    /** @hidden */
     private onOperation;
-    /** @hidden */
     private beforeOperation;
 }

package/lib/{providers → v1/providers}/auth.js

@@ -22,41 +22,44 @@
 // SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserBuilder = exports._userWithOptions = exports.user = exports.service = exports.provider = exports.HttpsError = exports.userRecordConstructor = exports.UserRecordMetadata = void 0;
-const cloud_functions_1 = require("../cloud-functions");
-const identity_1 = require("../common/providers/identity");
+const identity_1 = require("../../common/providers/identity");
 Object.defineProperty(exports, "HttpsError", { enumerable: true, get: function () { return identity_1.HttpsError; } });
 Object.defineProperty(exports, "userRecordConstructor", { enumerable: true, get: function () { return identity_1.userRecordConstructor; } });
 Object.defineProperty(exports, "UserRecordMetadata", { enumerable: true, get: function () { return identity_1.UserRecordMetadata; } });
-/** @hidden */
-exports.provider = 'google.firebase.auth';
-/** @hidden */
-exports.service = 'firebaseauth.googleapis.com';
+const cloud_functions_1 = require("../cloud-functions");
+const manifest_1 = require("../../runtime/manifest");
+/** @internal */
+exports.provider = "google.firebase.auth";
+/** @internal */
+exports.service = "firebaseauth.googleapis.com";
 /**
- * Handles events related to Firebase authentication users.
+ * Handles events related to Firebase Auth users events.
+ *
  * @param userOptions - Resource level options
- * @returns UserBuilder - Builder used to create Cloud Functions for Firebase Auth user lifecycle events
+ * @returns UserBuilder - Builder used to create functions for Firebase Auth user lifecycle events
+ *
  * @public
  */
 function user(userOptions) {
     return _userWithOptions({}, userOptions || {});
 }
 exports.user = user;
-/** @hidden */
+/** @internal */
 function _userWithOptions(options, userOptions) {
     return new UserBuilder(() => {
         if (!process.env.GCLOUD_PROJECT) {
-            throw new Error('process.env.GCLOUD_PROJECT is not set.');
+            throw new Error("process.env.GCLOUD_PROJECT is not set.");
         }
-        return 'projects/' + process.env.GCLOUD_PROJECT;
+        return "projects/" + process.env.GCLOUD_PROJECT;
     }, options, userOptions);
 }
 exports._userWithOptions = _userWithOptions;
 /**
- * Builder used to create Cloud Functions for Firebase Auth user lifecycle events.
+ * Builder used to create functions for Firebase Auth user lifecycle events.
  * @public
  */
 class UserBuilder {
-    /** @hidden */
+    /* @internal */
     constructor(triggerResource, options, userOptions) {
         this.triggerResource = triggerResource;
         this.options = options;
@@ -67,25 +70,44 @@ class UserBuilder {
     }
     /**
      * Responds to the creation of a Firebase Auth user.
+     *
+     * @param handler Event handler that responds to the creation of a Firebase Auth user.
+     *
      * @public
      */
     onCreate(handler) {
-        return this.onOperation(handler, 'user.create');
+        return this.onOperation(handler, "user.create");
     }
     /**
      * Responds to the deletion of a Firebase Auth user.
+     *
+     * @param handler Event handler that responds to the deletion of a Firebase Auth user.
+     *
      * @public
      */
     onDelete(handler) {
-        return this.onOperation(handler, 'user.delete');
+        return this.onOperation(handler, "user.delete");
     }
+    /**
+     * Blocks request to create a Firebase Auth user.
+     *
+     * @param handler Event handler that blocks creation of a Firebase Auth user.
+     *
+     * @public
+     */
     beforeCreate(handler) {
-        return this.beforeOperation(handler, 'beforeCreate');
+        return this.beforeOperation(handler, "beforeCreate");
     }
+    /**
+     * Blocks request to sign-in a Firebase Auth user.
+     *
+     * @param handler Event handler that blocks sign-in of a Firebase Auth user.
+     *
+     * @public
+     */
     beforeSignIn(handler) {
-        return this.beforeOperation(handler, 'beforeSignIn');
+        return this.beforeOperation(handler, "beforeSignIn");
     }
-    /** @hidden */
     onOperation(handler, eventType) {
         return (0, cloud_functions_1.makeCloudFunction)({
             handler,
@@ -93,12 +115,12 @@ class UserBuilder {
             eventType,
             service: exports.service,
             triggerResource: this.triggerResource,
+            // eslint-disable-next-line @typescript-eslint/unbound-method
             dataConstructor: UserBuilder.dataConstructor,
             legacyEventType: `providers/firebase.auth/eventTypes/${eventType}`,
             options: this.options,
         });
     }
-    /** @hidden */
     beforeOperation(handler, eventType) {
         var _a, _b, _c, _d, _e, _f;
         const accessToken = ((_b = (_a = this.userOptions) === null || _a === void 0 ? void 0 : _a.blockingOptions) === null || _b === void 0 ? void 0 : _b.accessToken) || false;
@@ -109,21 +131,10 @@ class UserBuilder {
         const wrappedHandler = (user, context) => handler(user, context);
         const func = (0, identity_1.wrapHandler)(eventType, wrappedHandler);
         const legacyEventType = `providers/cloud.auth/eventTypes/user.${eventType}`;
-        func.__trigger = {
-            labels: {},
-            ...(0, cloud_functions_1.optionsToTrigger)(this.options),
-            blockingTrigger: {
-                eventType: legacyEventType,
-                options: {
-                    accessToken,
-                    idToken,
-                    refreshToken,
-                },
-            },
-        };
         func.__endpoint = {
-            platform: 'gcfv1',
+            platform: "gcfv1",
             labels: {},
+            ...(0, manifest_1.initV1Endpoint)(this.options),
             ...(0, cloud_functions_1.optionsToEndpoint)(this.options),
             blockingTrigger: {
                 eventType: legacyEventType,
@@ -136,8 +147,8 @@ class UserBuilder {
         };
         func.__requiredAPIs = [
             {
-                api: 'identitytoolkit.googleapis.com',
-                reason: 'Needed for auth blocking functions',
+                api: "identitytoolkit.googleapis.com",
+                reason: "Needed for auth blocking functions",
             },
         ];
         func.run = handler;

package/lib/{providers → v1/providers}/database.d.ts

@@ -1,17 +1,14 @@
-import { apps } from '../apps';
-import { CloudFunction, EventContext } from '../cloud-functions';
-import { Change } from '../common/change';
-import { DataSnapshot } from '../common/providers/database';
-import { DeploymentOptions } from '../function-configuration';
+import { Change } from "../../common/change";
+import { ParamsOf } from "../../common/params";
+import { DataSnapshot } from "../../common/providers/database";
+import { CloudFunction, EventContext } from "../cloud-functions";
+import { DeploymentOptions } from "../function-configuration";
 export { DataSnapshot };
-/** @hidden */
-export declare const provider = "google.firebase.database";
-/** @hidden */
-export declare const service = "firebaseio.com";
 /**
  * Registers a function that triggers on events from a specific
  * Firebase Realtime Database instance.
  *
+ * @remarks
  * Use this method together with `ref` to specify the instance on which to
  * watch for database events. For example: `firebase.database.instance('my-app-db-2').ref('/foo/bar')`
  *
@@ -20,13 +17,14 @@ export declare const service = "firebaseio.com";
  *
  * @param instance The instance name of the database instance
  *   to watch for write events.
- * @return Firebase Realtime Database instance builder interface.
+ * @returns Firebase Realtime Database instance builder interface.
  */
 export declare function instance(instance: string): InstanceBuilder;
 /**
  * Registers a function that triggers on Firebase Realtime Database write
  * events.
  *
+ * @remarks
  * This method behaves very similarly to the method of the same name in the
  * client and Admin Firebase SDKs. Any change to the Database that affects the
  * data at or below the provided `path` will fire an event in Cloud Functions.
@@ -34,6 +32,7 @@ export declare function instance(instance: string): InstanceBuilder;
  * There are three important differences between listening to a Realtime
  * Database event in Cloud Functions and using the Realtime Database in the
  * client and Admin SDKs:
+ *
  * 1. Cloud Functions allows wildcards in the `path` name. Any `path` component
  *    in curly brackets (`{}`) is a wildcard that matches all strings. The value
  *    that matched a certain invocation of a Cloud Function is returned as part
@@ -42,18 +41,18 @@ export declare function instance(instance: string): InstanceBuilder;
  *    `/messages/message1` or `/messages/message2`, resulting in
  *    `event.params.messageId` being set to `"message1"` or `"message2"`,
  *    respectively.
+ *
  * 2. Cloud Functions do not fire an event for data that already existed before
  *    the Cloud Function was deployed.
+ *
  * 3. Cloud Function events have access to more information, including a
  *    snapshot of the previous event data and information about the user who
  *    triggered the Cloud Function.
  *
  * @param path The path within the Database to watch for write events.
- * @return Firebase Realtime Database builder interface.
+ * @returns Firebase Realtime Database builder interface.
  */
-export declare function ref(path: string): RefBuilder;
-/** @hidden */
-export declare function _instanceWithOptions(instance: string, options: DeploymentOptions): InstanceBuilder;
+export declare function ref<Ref extends string>(path: Ref): RefBuilder<Ref>;
 /**
  * The Firebase Realtime Database instance builder interface.
  *
@@ -62,73 +61,57 @@ export declare function _instanceWithOptions(instance: string, options: Deployme
 export declare class InstanceBuilder {
     private instance;
     private options;
-    /** @hidden */
     constructor(instance: string, options: DeploymentOptions);
     /**
-     * @return Firebase Realtime Database reference builder interface.
+     * @returns Firebase Realtime Database reference builder interface.
      */
-    ref(path: string): RefBuilder;
+    ref<Ref extends string>(path: Ref): RefBuilder<Ref>;
 }
-/** @hidden */
-export declare function _refWithOptions(path: string, options: DeploymentOptions): RefBuilder;
 /**
  * The Firebase Realtime Database reference builder interface.
  *
  * Access via [`functions.database.ref()`](functions.database#.ref).
  */
-export declare class RefBuilder {
-    private apps;
+export declare class RefBuilder<Ref extends string> {
     private triggerResource;
     private options;
-    /** @hidden */
-    constructor(apps: apps.Apps, triggerResource: () => string, options: DeploymentOptions);
+    constructor(triggerResource: () => string, options: DeploymentOptions);
     /**
      * Event handler that fires every time a Firebase Realtime Database write
      * of any kind (creation, update, or delete) occurs.
      *
      * @param handler Event handler that runs every time a Firebase Realtime Database
      *   write occurs.
-     * @return A Cloud Function that you can export and deploy.
+     * @returns A function that you can export and deploy.
      */
-    onWrite(handler: (change: Change<DataSnapshot>, context: EventContext) => PromiseLike<any> | any): CloudFunction<Change<DataSnapshot>>;
+    onWrite(handler: (change: Change<DataSnapshot>, context: EventContext<ParamsOf<Ref>>) => PromiseLike<any> | any): CloudFunction<Change<DataSnapshot>>;
     /**
      * Event handler that fires every time data is updated in
      * Firebase Realtime Database.
      *
      * @param handler Event handler which is run every time a Firebase Realtime Database
      *   write occurs.
-     * @return A Cloud
-     *   Function which you can export and deploy.
+     * @returns A function which you can export and deploy.
      */
-    onUpdate(handler: (change: Change<DataSnapshot>, context: EventContext) => PromiseLike<any> | any): CloudFunction<Change<DataSnapshot>>;
+    onUpdate(handler: (change: Change<DataSnapshot>, context: EventContext<ParamsOf<Ref>>) => PromiseLike<any> | any): CloudFunction<Change<DataSnapshot>>;
     /**
      * Event handler that fires every time new data is created in
      * Firebase Realtime Database.
      *
      * @param handler Event handler that runs every time new data is created in
      *   Firebase Realtime Database.
-     * @return A Cloud Function that you can export and deploy.
+     * @returns A function that you can export and deploy.
      */
-    onCreate(handler: (snapshot: DataSnapshot, context: EventContext) => PromiseLike<any> | any): CloudFunction<DataSnapshot>;
+    onCreate(handler: (snapshot: DataSnapshot, context: EventContext<ParamsOf<Ref>>) => PromiseLike<any> | any): CloudFunction<DataSnapshot>;
     /**
      * Event handler that fires every time data is deleted from
      * Firebase Realtime Database.
      *
      * @param handler Event handler that runs every time data is deleted from
      *   Firebase Realtime Database.
-     * @return A Cloud Function that you can export and deploy.
+     * @returns A function that you can export and deploy.
      */
-    onDelete(handler: (snapshot: DataSnapshot, context: EventContext) => PromiseLike<any> | any): CloudFunction<DataSnapshot>;
+    onDelete(handler: (snapshot: DataSnapshot, context: EventContext<ParamsOf<Ref>>) => PromiseLike<any> | any): CloudFunction<DataSnapshot>;
     private onOperation;
     private changeConstructor;
 }
-/**
- * Utility function to extract database reference from resource string
- *
- * @param optional database domain override for the original of the source database.
- *    It defaults to `firebaseio.com`.
- *    Multi-region RTDB will be served from different domains.
- *    Since region is not part of the resource name, it is provided through context.
- */
-/** @hidden */
-export declare function extractInstanceAndPath(resource: string, domain?: string): string[];