firebase-functions 3.21.1 → 3.23.0

package/lib/v2/params/types.js

@@ -21,90 +21,169 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JSONParam = exports.ListParam = exports.BooleanParam = exports.FloatParam = exports.IntParam = exports.StringParam = exports.Param = void 0;
-class Param {
+exports.ListParam = exports.BooleanParam = exports.FloatParam = exports.IntParam = exports.StringParam = exports.SecretParam = exports.Param = exports.CompareExpression = exports.TernaryExpression = exports.Expression = void 0;
+/*
+ * A CEL expression which can be evaluated during function deployment, and
+ * resolved to a value of the generic type parameter: i.e, you can pass
+ * an Expression<number> as the value of an option that normally accepts numbers.
+ */
+class Expression {
+    // Returns the Expression's runtime value, based on the CLI's resolution of params.
+    value() {
+        throw new Error('Not implemented');
+    }
+    // Returns the Expression's representation as a braced CEL expression.
+    toCEL() {
+        return `{{ ${this.toString()} }}`;
+    }
+    toJSON() {
+        return this.toString();
+    }
+}
+exports.Expression = Expression;
+function quoteIfString(literal) {
+    //TODO(vsfan@): CEL's string escape semantics are slightly different than Javascript's, what do we do here?
+    return typeof literal === 'string' ? `"${literal}"` : literal;
+}
+/**
+ * A CEL expression corresponding to a ternary operator, e.g {{ cond ? ifTrue : ifFalse }}
+ */
+class TernaryExpression extends Expression {
+    constructor(test, ifTrue, ifFalse) {
+        super();
+        this.test = test;
+        this.ifTrue = ifTrue;
+        this.ifFalse = ifFalse;
+        this.ifTrue = ifTrue;
+        this.ifFalse = ifFalse;
+    }
+    value() {
+        return !!this.test.value ? this.ifTrue : this.ifFalse;
+    }
+    toString() {
+        return `${this.test} ? ${quoteIfString(this.ifTrue)} : ${quoteIfString(this.ifFalse)}`;
+    }
+}
+exports.TernaryExpression = TernaryExpression;
+/**
+ * A CEL expression that evaluates to boolean true or false based on a comparison
+ * between the value of another expression and a literal of that same type.
+ */
+class CompareExpression extends Expression {
+    constructor(cmp, lhs, rhs) {
+        super();
+        this.cmp = cmp;
+        this.lhs = lhs;
+        this.rhs = rhs;
+    }
+    value() {
+        const left = this.lhs.value();
+        switch (this.cmp) {
+            case '==':
+                return left === this.rhs;
+            case '>':
+                return left > this.rhs;
+            case '>=':
+                return left >= this.rhs;
+            case '<':
+                return left < this.rhs;
+            case '<=':
+                return left <= this.rhs;
+            default:
+                throw new Error('Unknown comparator ' + this.cmp);
+        }
+    }
+    toString() {
+        return `${this.lhs} ${this.cmp} ${quoteIfString(this.rhs)}`;
+    }
+    then(ifTrue, ifFalse) {
+        return new TernaryExpression(this, ifTrue, ifFalse);
+    }
+}
+exports.CompareExpression = CompareExpression;
+class Param extends Expression {
     constructor(name, options = {}) {
+        super();
         this.name = name;
         this.options = options;
     }
-    get rawValue() {
-        return process.env[this.name];
+    value() {
+        throw new Error('Not implemented');
     }
-    get value() {
-        return this.rawValue || this.options.default || '';
+    cmp(cmp, rhs) {
+        return new CompareExpression(cmp, this, rhs);
     }
-    toString() {
-        return `{{params.${this.name}}}`;
+    equals(rhs) {
+        return this.cmp('==', rhs);
     }
-    toJSON() {
-        return this.toString();
+    toString() {
+        return `params.${this.name}`;
     }
     toSpec() {
-        var _a, _b;
         const out = {
             name: this.name,
             ...this.options,
-            valueType: this.constructor.valueType,
+            type: this.constructor.type,
         };
-        if (this.options.default && typeof this.options.default !== 'string') {
-            out.default = (_b = (_a = this.options.default) === null || _a === void 0 ? void 0 : _a.toString) === null || _b === void 0 ? void 0 : _b.call(_a);
-        }
         return out;
     }
 }
 exports.Param = Param;
-Param.valueType = 'string';
+Param.type = 'string';
+class SecretParam {
+    constructor(name) {
+        this.name = name;
+    }
+    value() {
+        return process.env[this.name] || '';
+    }
+    toSpec() {
+        return {
+            type: 'secret',
+            name: this.name,
+        };
+    }
+}
+exports.SecretParam = SecretParam;
+SecretParam.type = 'secret';
 class StringParam extends Param {
+    value() {
+        return process.env[this.name] || '';
+    }
 }
 exports.StringParam = StringParam;
 class IntParam extends Param {
-    get value() {
-        var _a;
-        const intVal = parseInt(this.rawValue || ((_a = this.options.default) === null || _a === void 0 ? void 0 : _a.toString()) || '0', 10);
-        if (Number.isNaN(intVal)) {
-            throw new Error(`unable to load param "${this.name}", value ${JSON.stringify(this.rawValue)} could not be parsed as integer`);
-        }
-        return intVal;
+    value() {
+        return parseInt(process.env[this.name] || '0', 10) || 0;
     }
 }
 exports.IntParam = IntParam;
-IntParam.valueType = 'int';
+IntParam.type = 'int';
 class FloatParam extends Param {
-    get value() {
-        var _a;
-        const floatVal = parseFloat(this.rawValue || ((_a = this.options.default) === null || _a === void 0 ? void 0 : _a.toString()) || '0');
-        if (Number.isNaN(floatVal)) {
-            throw new Error(`unable to load param "${this.name}", value ${JSON.stringify(this.rawValue)} could not be parsed as float`);
-        }
-        return floatVal;
+    value() {
+        return parseFloat(process.env[this.name] || '0') || 0;
     }
 }
 exports.FloatParam = FloatParam;
-FloatParam.valueType = 'float';
+FloatParam.type = 'float';
 class BooleanParam extends Param {
-    get value() {
-        var _a;
-        const lowerVal = (this.rawValue ||
-            ((_a = this.options.default) === null || _a === void 0 ? void 0 : _a.toString()) ||
-            'false').toLowerCase();
-        if (!['true', 'y', 'yes', '1', 'false', 'n', 'no', '0'].includes(lowerVal)) {
-            throw new Error(`unable to load param "${this.name}", value ${JSON.stringify(this.rawValue)} could not be parsed as boolean`);
-        }
-        return ['true', 'y', 'yes', '1'].includes(lowerVal);
+    value() {
+        return !!process.env[this.name];
+    }
+    then(ifTrue, ifFalse) {
+        return new TernaryExpression(this, ifTrue, ifFalse);
     }
 }
 exports.BooleanParam = BooleanParam;
-BooleanParam.valueType = 'boolean';
+BooleanParam.type = 'boolean';
 class ListParam extends Param {
-    get value() {
-        return typeof this.rawValue === 'string'
-            ? this.rawValue.split(/, ?/)
-            : this.options.default || [];
+    value() {
+        throw new Error('Not implemented');
     }
     toSpec() {
         const out = {
             name: this.name,
-            valueType: 'list',
+            type: 'list',
             ...this.options,
         };
         if (this.options.default && this.options.default.length > 0) {
@@ -114,23 +193,4 @@ class ListParam extends Param {
     }
 }
 exports.ListParam = ListParam;
-ListParam.valueType = 'list';
-class JSONParam extends Param {
-    get value() {
-        var _a;
-        if (this.rawValue) {
-            try {
-                return JSON.parse(this.rawValue);
-            }
-            catch (e) {
-                throw new Error(`unable to load param "${this.name}", value ${this.rawValue} could not be parsed as JSON: ${e.message}`);
-            }
-        }
-        else if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.hasOwnProperty('default')) {
-            return this.options.default;
-        }
-        return {};
-    }
-}
-exports.JSONParam = JSONParam;
-JSONParam.valueType = 'json';
+ListParam.type = 'list';

package/lib/v2/providers/alerts/alerts.d.ts

@@ -1,5 +1,6 @@
 import { CloudEvent, CloudFunction } from '../../core';
 import * as options from '../../options';
+import { Expression } from '../../params';
 /**
  * The CloudEvent data emitted by Firebase Alerts.
  * @typeParam T - the payload type that is expected for this alert.
@@ -28,7 +29,7 @@ export interface AlertEvent<T> extends CloudEvent<FirebaseAlertData<T>> {
     data: FirebaseAlertData<T>;
 }
 /** The underlying alert type of the Firebase Alerts provider. */
-export declare type AlertType = 'crashlytics.newFatalIssue' | 'crashlytics.newNonfatalIssue' | 'crashlytics.regression' | 'crashlytics.stabilityDigest' | 'crashlytics.velocity' | 'crashlytics.newAnrIssue' | 'billing.planUpdate' | 'billing.automatedPlanUpdate' | 'appDistribution.newTesterIosDevice' | string;
+export declare type AlertType = 'crashlytics.newFatalIssue' | 'crashlytics.newNonfatalIssue' | 'crashlytics.regression' | 'crashlytics.stabilityDigest' | 'crashlytics.velocity' | 'crashlytics.newAnrIssue' | 'billing.planUpdate' | 'billing.automatedPlanUpdate' | 'appDistribution.newTesterIosDevice' | 'appDistribution.inAppFeedback' | string;
 /**
  * Configuration for Firebase Alert functions.
  */
@@ -45,7 +46,7 @@ export interface FirebaseAlertOptions extends options.EventHandlerOptions {
      * Amount of memory to allocate to a function.
      * A value of null restores the defaults of 256MB.
      */
-    memory?: options.MemoryOption | null;
+    memory?: options.MemoryOption | Expression<number> | null;
     /**
      * Timeout for the function in sections, possible values are 0 to 540.
      * HTTPS functions can specify a higher timeout.
@@ -56,19 +57,19 @@ export interface FirebaseAlertOptions extends options.EventHandlerOptions {
      * maximum timeout of 36,00s (1 hour). Task queue functions have a maximum
      * timeout of 1,800s (30 minutes)
      */
-    timeoutSeconds?: number | null;
+    timeoutSeconds?: number | Expression<number> | null;
     /**
      * Min number of actual instances to be running at a given time.
      * Instances will be billed for memory allocation and 10% of CPU allocation
      * while idle.
      * A value of null restores the default min instances.
      */
-    minInstances?: number | null;
+    minInstances?: number | Expression<number> | null;
     /**
      * Max number of instances to be running in parallel.
      * A value of null restores the default max instances.
      */
-    maxInstances?: number | null;
+    maxInstances?: number | Expression<number> | null;
     /**
      * Number of requests a function can serve at once.
      * Can only be applied to functions running on Cloud Functions v2.
@@ -76,7 +77,7 @@ export interface FirebaseAlertOptions extends options.EventHandlerOptions {
      * Concurrency cannot be set to any value other than 1 if `cpu` is less than 1.
      * The maximum value for concurrency is 1,000.
      */
-    concurrency?: number | null;
+    concurrency?: number | Expression<number> | null;
     /**
      * Fractional number of CPUs to allocate to a function.
      * Defaults to 1 for functions with <= 2GB RAM and increases for larger memory sizes.

package/lib/v2/providers/alerts/appDistribution.d.ts

@@ -5,6 +5,7 @@
 import { CloudEvent, CloudFunction } from '../../core';
 import * as options from '../../options';
 import { FirebaseAlertData } from './alerts';
+import { Expression } from '../../params';
 /**
  * The internal payload object for adding a new tester device to app distribution.
  * Payload is wrapped inside a `FirebaseAlertData` object.
@@ -20,6 +21,30 @@ export interface NewTesterDevicePayload {
     /** The device ID */
     testerDeviceIdentifier: string;
 }
+/**
+ * The internal payload object for receiving in-app feedback from a tester.
+ * Payload is wrapped inside a `FirebaseAlertData` object.
+ */
+export interface InAppFeedbackPayload {
+    ['@type']: 'type.googleapis.com/google.events.firebase.firebasealerts.v1.AppDistroInAppFeedbackPayload';
+    /** Resource name. Format: `projects/{project_number}/apps/{app_id}/releases/{release_id}/feedbackReports/{feedback_id}` */
+    feedbackReport: string;
+    /** Deep link back to the Firebase console. */
+    feedbackConsoleUri: string;
+    /** Name of the tester */
+    testerName?: string;
+    /** Email of the tester */
+    testerEmail: string;
+    /**
+     * Version consisting of `versionName` and `versionCode` for Android and
+     * `CFBundleShortVersionString` and `CFBundleVersion` for iOS.
+     */
+    appVersion: string;
+    /** Text entered by the tester */
+    text: string;
+    /** URI to download screenshot. This URI is fast expiring. */
+    screenshotUri?: string;
+}
 /**
  * A custom CloudEvent for Firebase Alerts (with custom extension attributes).
  * @typeParam T - the data type for app distribution alerts that is wrapped in a `FirebaseAlertData` object.
@@ -44,7 +69,7 @@ export interface AppDistributionOptions extends options.EventHandlerOptions {
      * Amount of memory to allocate to a function.
      * A value of null restores the defaults of 256MB.
      */
-    memory?: options.MemoryOption | null;
+    memory?: options.MemoryOption | Expression<number> | null;
     /**
      * Timeout for the function in sections, possible values are 0 to 540.
      * HTTPS functions can specify a higher timeout.
@@ -55,19 +80,19 @@ export interface AppDistributionOptions extends options.EventHandlerOptions {
      * maximum timeout of 36,00s (1 hour). Task queue functions have a maximum
      * timeout of 1,800s (30 minutes)
      */
-    timeoutSeconds?: number | null;
+    timeoutSeconds?: number | Expression<number> | null;
     /**
      * Min number of actual instances to be running at a given time.
      * Instances will be billed for memory allocation and 10% of CPU allocation
      * while idle.
      * A value of null restores the default min instances.
      */
-    minInstances?: number | null;
+    minInstances?: number | Expression<number> | null;
     /**
      * Max number of instances to be running in parallel.
      * A value of null restores the default max instances.
      */
-    maxInstances?: number | null;
+    maxInstances?: number | Expression<number> | null;
     /**
      * Number of requests a function can serve at once.
      * Can only be applied to functions running on Cloud Functions v2.
@@ -75,7 +100,7 @@ export interface AppDistributionOptions extends options.EventHandlerOptions {
      * Concurrency cannot be set to any value other than 1 if `cpu` is less than 1.
      * The maximum value for concurrency is 1,000.
      */
-    concurrency?: number | null;
+    concurrency?: number | Expression<number> | null;
     /**
      * Fractional number of CPUs to allocate to a function.
      * Defaults to 1 for functions with <= 2GB RAM and increases for larger memory sizes.
@@ -133,3 +158,23 @@ export declare function onNewTesterIosDevicePublished(appId: string, handler: (e
  * @returns A function that you can export and deploy.
  */
 export declare function onNewTesterIosDevicePublished(opts: AppDistributionOptions, handler: (event: AppDistributionEvent<NewTesterDevicePayload>) => any | Promise<any>): CloudFunction<AppDistributionEvent<NewTesterDevicePayload>>;
+/**
+ * Declares a function that can handle receiving new in-app feedback from a tester.
+ * @param handler - Event handler which is run every time new feedback is received.
+ * @returns A function that you can export and deploy.
+ */
+export declare function onInAppFeedbackPublished(handler: (event: AppDistributionEvent<InAppFeedbackPayload>) => any | Promise<any>): CloudFunction<AppDistributionEvent<InAppFeedbackPayload>>;
+/**
+ * Declares a function that can handle receiving new in-app feedback from a tester.
+ * @param appId - A specific application the handler will trigger on.
+ * @param handler - Event handler which is run every time new feedback is received.
+ * @returns A function that you can export and deploy.
+ */
+export declare function onInAppFeedbackPublished(appId: string, handler: (event: AppDistributionEvent<InAppFeedbackPayload>) => any | Promise<any>): CloudFunction<AppDistributionEvent<InAppFeedbackPayload>>;
+/**
+ * Declares a function that can handle receiving new in-app feedback from a tester.
+ * @param opts - Options that can be set on the function.
+ * @param handler - Event handler which is run every time new feedback is received.
+ * @returns A function that you can export and deploy.
+ */
+export declare function onInAppFeedbackPublished(opts: AppDistributionOptions, handler: (event: AppDistributionEvent<InAppFeedbackPayload>) => any | Promise<any>): CloudFunction<AppDistributionEvent<InAppFeedbackPayload>>;

package/lib/v2/providers/alerts/appDistribution.js

@@ -21,10 +21,12 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOptsAndApp = exports.onNewTesterIosDevicePublished = exports.newTesterIosDeviceAlert = void 0;
+exports.getOptsAndApp = exports.onInAppFeedbackPublished = exports.onNewTesterIosDevicePublished = exports.inAppFeedbackAlert = exports.newTesterIosDeviceAlert = void 0;
 const alerts_1 = require("./alerts");
 /** @internal */
 exports.newTesterIosDeviceAlert = 'appDistribution.newTesterIosDevice';
+/** @internal */
+exports.inAppFeedbackAlert = 'appDistribution.inAppFeedback';
 /**
  * Declares a function that can handle adding a new tester iOS device.
  * @param appIdOrOptsOrHandler - A specific application, options, or an event-handling function.
@@ -45,6 +47,26 @@ function onNewTesterIosDevicePublished(appIdOrOptsOrHandler, handler) {
     return func;
 }
 exports.onNewTesterIosDevicePublished = onNewTesterIosDevicePublished;
+/**
+ * Declares a function that can handle receiving new in-app feedback from a tester.
+ * @param appIdOrOptsOrHandler - A specific application, options, or an event-handling function.
+ * @param handler - Event handler which is run every time new feedback is received.
+ * @returns A function that you can export and deploy.
+ */
+function onInAppFeedbackPublished(appIdOrOptsOrHandler, handler) {
+    if (typeof appIdOrOptsOrHandler === 'function') {
+        handler = appIdOrOptsOrHandler;
+        appIdOrOptsOrHandler = {};
+    }
+    const [opts, appId] = getOptsAndApp(appIdOrOptsOrHandler);
+    const func = (raw) => {
+        return handler(raw);
+    };
+    func.run = handler;
+    func.__endpoint = (0, alerts_1.getEndpointAnnotation)(opts, exports.inAppFeedbackAlert, appId);
+    return func;
+}
+exports.onInAppFeedbackPublished = onInAppFeedbackPublished;
 /**
  * Helper function to parse the function opts and appId.
  * @internal

package/lib/v2/providers/alerts/crashlytics.d.ts

@@ -5,6 +5,7 @@
 import { FirebaseAlertData } from '.';
 import { CloudEvent, CloudFunction } from '../../core';
 import * as options from '../../options';
+import { Expression } from '../../params';
 /** Generic Crashlytics issue interface */
 export interface Issue {
     /** The ID of the Crashlytics issue */
@@ -134,7 +135,7 @@ export interface CrashlyticsOptions extends options.EventHandlerOptions {
      * Amount of memory to allocate to a function.
      * A value of null restores the defaults of 256MB.
      */
-    memory?: options.MemoryOption | null;
+    memory?: options.MemoryOption | Expression<number> | null;
     /**
      * Timeout for the function in sections, possible values are 0 to 540.
      * HTTPS functions can specify a higher timeout.
@@ -145,19 +146,19 @@ export interface CrashlyticsOptions extends options.EventHandlerOptions {
      * maximum timeout of 36,00s (1 hour). Task queue functions have a maximum
      * timeout of 1,800s (30 minutes)
      */
-    timeoutSeconds?: number | null;
+    timeoutSeconds?: number | Expression<number> | null;
     /**
      * Min number of actual instances to be running at a given time.
      * Instances will be billed for memory allocation and 10% of CPU allocation
      * while idle.
      * A value of null restores the default min instances.
      */
-    minInstances?: number | null;
+    minInstances?: number | Expression<number> | null;
     /**
      * Max number of instances to be running in parallel.
      * A value of null restores the default max instances.
      */
-    maxInstances?: number | null;
+    maxInstances?: number | Expression<number> | null;
     /**
      * Number of requests a function can serve at once.
      * Can only be applied to functions running on Cloud Functions v2.
@@ -165,7 +166,7 @@ export interface CrashlyticsOptions extends options.EventHandlerOptions {
      * Concurrency cannot be set to any value other than 1 if `cpu` is less than 1.
      * The maximum value for concurrency is 1,000.
      */
-    concurrency?: number | null;
+    concurrency?: number | Expression<number> | null;
     /**
      * Fractional number of CPUs to allocate to a function.
      * Defaults to 1 for functions with <= 2GB RAM and increases for larger memory sizes.

package/lib/v2/providers/database.d.ts

@@ -0,0 +1,183 @@
+import { Change } from '../../common/change';
+import { DataSnapshot } from '../../common/providers/database';
+import { CloudEvent, CloudFunction } from '../core';
+import * as options from '../options';
+import { Expression } from '../params';
+export { DataSnapshot };
+/** @hidden */
+export interface RawRTDBCloudEventData {
+    ['@type']: 'type.googleapis.com/google.events.firebase.database.v1.ReferenceEventData';
+    data: any;
+    delta: any;
+}
+/** @hidden */
+export interface RawRTDBCloudEvent extends CloudEvent<RawRTDBCloudEventData> {
+    firebasedatabasehost: string;
+    instance: string;
+    ref: string;
+    location: string;
+}
+/** A CloudEvent that contains a DataSnapshot or a Change<DataSnapshot> */
+export interface DatabaseEvent<T> extends CloudEvent<T> {
+    /** The domain of the database instance */
+    firebaseDatabaseHost: string;
+    /** The instance ID portion of the fully qualified resource name */
+    instance: string;
+    /** The database reference path */
+    ref: string;
+    /** The location of the database */
+    location: string;
+    /**
+     * An object containing the values of the path patterns.
+     * Only named capture groups will be populated - {key}, {key=*}, {key=**}
+     */
+    params: Record<string, string>;
+}
+/** ReferenceOptions extend EventHandlerOptions with provided ref and optional instance  */
+export interface ReferenceOptions extends options.EventHandlerOptions {
+    /**
+     * Specify the handler to trigger on a database reference(s).
+     * This value can either be a single reference or a pattern.
+     * Examples: '/foo/bar', '/foo/{bar}'
+     */
+    ref: string;
+    /**
+     * Specify the handler to trigger on a database instance(s).
+     * If present, this value can either be a single instance or a pattern.
+     * Examples: 'my-instance-1', 'my-instance-*'
+     * Note: The capture syntax cannot be used for 'instance'.
+     */
+    instance?: string;
+    /**
+     * Region where functions should be deployed.
+     */
+    region?: options.SupportedRegion | string;
+    /**
+     * Amount of memory to allocate to a function.
+     * A value of null restores the defaults of 256MB.
+     */
+    memory?: options.MemoryOption | Expression<number> | null;
+    /**
+     * Timeout for the function in sections, possible values are 0 to 540.
+     * HTTPS functions can specify a higher timeout.
+     * A value of null restores the default of 60s
+     * The minimum timeout for a gen 2 function is 1s. The maximum timeout for a
+     * function depends on the type of function: Event handling functions have a
+     * maximum timeout of 540s (9 minutes). HTTPS and callable functions have a
+     * maximum timeout of 36,00s (1 hour). Task queue functions have a maximum
+     * timeout of 1,800s (30 minutes)
+     */
+    timeoutSeconds?: number | Expression<number> | null;
+    /**
+     * Min number of actual instances to be running at a given time.
+     * Instances will be billed for memory allocation and 10% of CPU allocation
+     * while idle.
+     * A value of null restores the default min instances.
+     */
+    minInstances?: number | Expression<number> | null;
+    /**
+     * Max number of instances to be running in parallel.
+     * A value of null restores the default max instances.
+     */
+    maxInstances?: number | Expression<number> | null;
+    /**
+     * Number of requests a function can serve at once.
+     * Can only be applied to functions running on Cloud Functions v2.
+     * A value of null restores the default concurrency (80 when CPU >= 1, 1 otherwise).
+     * Concurrency cannot be set to any value other than 1 if `cpu` is less than 1.
+     * The maximum value for concurrency is 1,000.
+     */
+    concurrency?: number | Expression<number> | null;
+    /**
+     * Fractional number of CPUs to allocate to a function.
+     * Defaults to 1 for functions with <= 2GB RAM and increases for larger memory sizes.
+     * This is different from the defaults when using the gcloud utility and is different from
+     * the fixed amount assigned in Google Cloud Functions generation 1.
+     * To revert to the CPU amounts used in gcloud or in Cloud Functions generation 1, set this
+     * to the value "gcf_gen1"
+     */
+    cpu?: number | 'gcf_gen1';
+    /**
+     * Connect cloud function to specified VPC connector.
+     * A value of null removes the VPC connector
+     */
+    vpcConnector?: string | null;
+    /**
+     * Egress settings for VPC connector.
+     * A value of null turns off VPC connector egress settings
+     */
+    vpcConnectorEgressSettings?: options.VpcEgressSetting | null;
+    /**
+     * Specific service account for the function to run as.
+     * A value of null restores the default service account.
+     */
+    serviceAccount?: string | null;
+    /**
+     * Ingress settings which control where this function can be called from.
+     * A value of null turns off ingress settings.
+     */
+    ingressSettings?: options.IngressSetting | null;
+    /**
+     * User labels to set on the function.
+     */
+    labels?: Record<string, string>;
+    secrets?: string[];
+    /** Whether failed executions should be delivered again. */
+    retry?: boolean | Expression<boolean> | null;
+}
+/**
+ * Event handler which triggers when data is created, updated, or deleted in Realtime Database.
+ *
+ * @param reference - The database reference path to trigger on.
+ * @param handler - Event handler which is run every time a Realtime Database create, update, or delete occurs.
+ */
+export declare function onValueWritten(reference: string, handler: (event: DatabaseEvent<Change<DataSnapshot>>) => any | Promise<any>): CloudFunction<DatabaseEvent<Change<DataSnapshot>>>;
+/**
+ * Event handler which triggers when data is created, updated, or deleted in Realtime Database.
+ *
+ * @param opts - Options that can be set on an individual event-handling function.
+ * @param handler - Event handler which is run every time a Realtime Database create, update, or delete occurs.
+ */
+export declare function onValueWritten(opts: ReferenceOptions, handler: (event: DatabaseEvent<Change<DataSnapshot>>) => any | Promise<any>): CloudFunction<DatabaseEvent<Change<DataSnapshot>>>;
+/**
+ * Event handler which triggers when data is created in Realtime Database.
+ *
+ * @param reference - The database reference path to trigger on.
+ * @param handler - Event handler which is run every time a Realtime Database create occurs.
+ */
+export declare function onValueCreated(reference: string, handler: (event: DatabaseEvent<DataSnapshot>) => any | Promise<any>): CloudFunction<DatabaseEvent<DataSnapshot>>;
+/**
+ * Event handler which triggers when data is created in Realtime Database.
+ *
+ * @param opts - Options that can be set on an individual event-handling function.
+ * @param handler - Event handler which is run every time a Realtime Database create occurs.
+ */
+export declare function onValueCreated(opts: ReferenceOptions, handler: (event: DatabaseEvent<DataSnapshot>) => any | Promise<any>): CloudFunction<DatabaseEvent<DataSnapshot>>;
+/**
+ * Event handler which triggers when data is updated in Realtime Database.
+ *
+ * @param reference - The database reference path to trigger on.
+ * @param handler - Event handler which is run every time a Realtime Database update occurs.
+ */
+export declare function onValueUpdated(reference: string, handler: (event: DatabaseEvent<Change<DataSnapshot>>) => any | Promise<any>): CloudFunction<DatabaseEvent<Change<DataSnapshot>>>;
+/**
+ * Event handler which triggers when data is updated in Realtime Database.
+ *
+ * @param opts - Options that can be set on an individual event-handling function.
+ * @param handler - Event handler which is run every time a Realtime Database update occurs.
+ */
+export declare function onValueUpdated(opts: ReferenceOptions, handler: (event: DatabaseEvent<Change<DataSnapshot>>) => any | Promise<any>): CloudFunction<DatabaseEvent<Change<DataSnapshot>>>;
+/**
+ * Event handler which triggers when data is deleted in Realtime Database.
+ *
+ * @param reference - The database reference path to trigger on.
+ * @param handler - Event handler which is run every time a Realtime Database deletion occurs.
+ */
+export declare function onValueDeleted(reference: string, handler: (event: DatabaseEvent<DataSnapshot>) => any | Promise<any>): CloudFunction<DatabaseEvent<DataSnapshot>>;
+/**
+ * Event handler which triggers when data is deleted in Realtime Database.
+ *
+ * @param opts - Options that can be set on an individual event-handling function.
+ * @param handler - Event handler which is run every time a Realtime Database deletion occurs.
+ */
+export declare function onValueDeleted(opts: ReferenceOptions, handler: (event: DatabaseEvent<DataSnapshot>) => any | Promise<any>): CloudFunction<DatabaseEvent<DataSnapshot>>;