firebase-functions 3.15.5 → 3.17.0

package/lib/v2/options.js

@@ -21,15 +21,19 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__getSpec = exports.optionsToTriggerAnnotations = exports.getGlobalOptions = exports.setGlobalOptions = exports.SUPPORTED_INGRESS_SETTINGS = exports.SUPPORTED_VPC_EGRESS_SETTINGS = exports.SUPPORTED_MEMORY_OPTIONS = exports.MAX_CONCURRENCY = exports.MAX_HTTPS_TIMEOUT_SECONDS = exports.MAX_EVENT_TIMEOUT_SECONDS = exports.MIN_TIMEOUT_SECONDS = exports.SUPPORTED_REGIONS = void 0;
+exports.__getSpec = exports.optionsToEndpoint = exports.optionsToTriggerAnnotations = exports.getGlobalOptions = exports.setGlobalOptions = exports.SUPPORTED_INGRESS_SETTINGS = exports.SUPPORTED_VPC_EGRESS_SETTINGS = exports.SUPPORTED_MEMORY_OPTIONS = exports.MAX_CONCURRENCY = exports.MAX_HTTPS_TIMEOUT_SECONDS = exports.MAX_EVENT_TIMEOUT_SECONDS = exports.MIN_TIMEOUT_SECONDS = exports.SUPPORTED_REGIONS = void 0;
 const encoding_1 = require("../common/encoding");
-const encoding_2 = require("../common/encoding");
 const logger = require("../logger");
 const params_1 = require("./params");
 /**
  * List of all regions supported by Cloud Functions v2
  */
-exports.SUPPORTED_REGIONS = ['us-west1'];
+exports.SUPPORTED_REGIONS = [
+    'us-west1',
+    'us-central1',
+    'europe-west4',
+    'asia-northeast1',
+];
 /**
  * Cloud Functions v2 min timeout value.
  */
@@ -107,24 +111,58 @@ exports.getGlobalOptions = getGlobalOptions;
  */
 function optionsToTriggerAnnotations(opts) {
     const annotation = {};
-    (0, encoding_2.copyIfPresent)(annotation, opts, 'concurrency', 'minInstances', 'maxInstances', 'ingressSettings', 'labels', 'vpcConnector', 'vpcConnectorEgressSettings');
-    (0, encoding_2.convertIfPresent)(annotation, opts, 'availableMemoryMb', 'memory', (mem) => {
+    (0, encoding_1.copyIfPresent)(annotation, opts, 'concurrency', 'minInstances', 'maxInstances', 'ingressSettings', 'labels', 'vpcConnector', 'vpcConnectorEgressSettings');
+    (0, encoding_1.convertIfPresent)(annotation, opts, 'availableMemoryMb', 'memory', (mem) => {
         return MemoryOptionToMB[mem];
     });
-    (0, encoding_2.convertIfPresent)(annotation, opts, 'regions', 'region', (region) => {
+    (0, encoding_1.convertIfPresent)(annotation, opts, 'regions', 'region', (region) => {
         if (typeof region === 'string') {
             return [region];
         }
         return region;
     });
-    (0, encoding_2.convertIfPresent)(annotation, opts, 'serviceAccountEmail', 'serviceAccount', encoding_1.serviceAccountFromShorthand);
-    (0, encoding_2.convertIfPresent)(annotation, opts, 'timeout', 'timeoutSeconds', encoding_1.durationFromSeconds);
-    (0, encoding_2.convertIfPresent)(annotation, opts, 'failurePolicy', 'retry', (retry) => {
+    (0, encoding_1.convertIfPresent)(annotation, opts, 'serviceAccountEmail', 'serviceAccount', encoding_1.serviceAccountFromShorthand);
+    (0, encoding_1.convertIfPresent)(annotation, opts, 'timeout', 'timeoutSeconds', encoding_1.durationFromSeconds);
+    (0, encoding_1.convertIfPresent)(annotation, opts, 'failurePolicy', 'retry', (retry) => {
         return retry ? { retry: true } : null;
     });
     return annotation;
 }
 exports.optionsToTriggerAnnotations = optionsToTriggerAnnotations;
+/**
+ * Apply GlobalOptions to endpoint manifest.
+ * @internal
+ */
+function optionsToEndpoint(opts) {
+    const endpoint = {};
+    (0, encoding_1.copyIfPresent)(endpoint, opts, 'concurrency', 'minInstances', 'maxInstances', 'ingressSettings', 'labels', 'timeoutSeconds');
+    (0, encoding_1.convertIfPresent)(endpoint, opts, 'serviceAccountEmail', 'serviceAccount');
+    if (opts.vpcConnector) {
+        const vpc = { connector: opts.vpcConnector };
+        (0, encoding_1.convertIfPresent)(vpc, opts, 'egressSettings', 'vpcConnectorEgressSettings');
+        endpoint.vpc = vpc;
+    }
+    (0, encoding_1.convertIfPresent)(endpoint, opts, 'availableMemoryMb', 'memory', (mem) => {
+        const memoryLookup = {
+            '128MB': 128,
+            '256MB': 256,
+            '512MB': 512,
+            '1GB': 1024,
+            '2GB': 2048,
+            '4GB': 4096,
+            '8GB': 8192,
+        };
+        return memoryLookup[mem];
+    });
+    (0, encoding_1.convertIfPresent)(endpoint, opts, 'region', 'region', (region) => {
+        if (typeof region === 'string') {
+            return [region];
+        }
+        return region;
+    });
+    return endpoint;
+}
+exports.optionsToEndpoint = optionsToEndpoint;
 /**
  * @hidden
  */

package/lib/v2/params/types.d.ts

@@ -1,12 +1,13 @@
 /** @hidden */
 declare type ParamValueType = 'string' | 'list' | 'boolean' | 'int' | 'float' | 'json';
 export interface ParamSpec<T = unknown> {
+    name: string;
     default?: T;
     label?: string;
     description?: string;
     valueType?: ParamValueType;
 }
-export declare type ParamOptions<T = unknown> = Omit<ParamSpec<T>, 'valueType'>;
+export declare type ParamOptions<T = unknown> = Omit<ParamSpec<T>, 'name' | 'valueType'>;
 export declare class Param<T = unknown> {
     readonly name: string;
     readonly options: ParamOptions<T>;

package/lib/v2/params/types.js

@@ -21,6 +21,7 @@ class Param {
     toSpec() {
         var _a, _b;
         const out = {
+            name: this.name,
             ...this.options,
             valueType: this.constructor.valueType,
         };
@@ -81,6 +82,7 @@ class ListParam extends Param {
     }
     toSpec() {
         const out = {
+            name: this.name,
             valueType: 'list',
             ...this.options,
         };

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

@@ -0,0 +1,36 @@
+import { CloudEvent, CloudFunction } from '../../core';
+import * as options from '../../options';
+/**
+ * The CloudEvent data emitted by Firebase Alerts.
+ */
+export interface FirebaseAlertData<T = any> {
+    createTime: string;
+    endTime: string;
+    payload: T;
+}
+interface WithAlertTypeAndApp {
+    alertType: string;
+    appId?: string;
+}
+/**
+ * A custom CloudEvent for Firebase Alerts (with custom extension attributes).
+ */
+export declare type AlertEvent<T> = CloudEvent<FirebaseAlertData<T>, WithAlertTypeAndApp>;
+/** 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;
+/**
+ * Configuration for Firebase Alert functions.
+ */
+export interface FirebaseAlertOptions extends options.EventHandlerOptions {
+    alertType: AlertType;
+    appId?: string;
+}
+/**
+ * Declares a function that can handle Firebase Alerts from CloudEvents.
+ * @param alertTypeOrOpts the alert type or Firebase Alert function configuration.
+ * @param handler a function that can handle the Firebase Alert inside a CloudEvent.
+ */
+export declare function onAlertPublished<T extends {
+    ['@type']: string;
+} = any>(alertTypeOrOpts: AlertType | FirebaseAlertOptions, handler: (event: AlertEvent<T>) => any | Promise<any>): CloudFunction<FirebaseAlertData<T>>;
+export {};

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOptsAndAlertTypeAndApp = exports.getEndpointAnnotation = exports.onAlertPublished = exports.eventType = void 0;
+const options = require("../../options");
+/** @internal */
+exports.eventType = 'google.firebase.firebasealerts.alerts.v1.published';
+/**
+ * Declares a function that can handle Firebase Alerts from CloudEvents.
+ * @param alertTypeOrOpts the alert type or Firebase Alert function configuration.
+ * @param handler a function that can handle the Firebase Alert inside a CloudEvent.
+ */
+function onAlertPublished(alertTypeOrOpts, handler) {
+    const [opts, alertType, appId] = getOptsAndAlertTypeAndApp(alertTypeOrOpts);
+    const func = (raw) => {
+        return handler(raw);
+    };
+    func.run = handler;
+    func.__endpoint = getEndpointAnnotation(opts, alertType, appId);
+    return func;
+}
+exports.onAlertPublished = onAlertPublished;
+/**
+ * @internal
+ * Helper function for getting the endpoint annotation used in alert handling functions.
+ */
+function getEndpointAnnotation(opts, alertType, appId) {
+    const baseOpts = options.optionsToEndpoint(options.getGlobalOptions());
+    const specificOpts = options.optionsToEndpoint(opts);
+    const endpoint = {
+        platform: 'gcfv2',
+        ...baseOpts,
+        ...specificOpts,
+        labels: {
+            ...baseOpts === null || baseOpts === void 0 ? void 0 : baseOpts.labels,
+            ...specificOpts === null || specificOpts === void 0 ? void 0 : specificOpts.labels,
+        },
+        eventTrigger: {
+            eventType: exports.eventType,
+            eventFilters: {
+                alertType,
+            },
+            retry: !!opts.retry,
+        },
+    };
+    if (appId) {
+        endpoint.eventTrigger.eventFilters.appId = appId;
+    }
+    return endpoint;
+}
+exports.getEndpointAnnotation = getEndpointAnnotation;
+/**
+ * @internal
+ * Helper function to parse the function opts, alert type, and appId.
+ */
+function getOptsAndAlertTypeAndApp(alertTypeOrOpts) {
+    let opts;
+    let alertType;
+    let appId;
+    if (typeof alertTypeOrOpts === 'string') {
+        alertType = alertTypeOrOpts;
+        opts = {};
+    }
+    else {
+        alertType = alertTypeOrOpts.alertType;
+        appId = alertTypeOrOpts.appId;
+        opts = { ...alertTypeOrOpts };
+        delete opts.alertType;
+        delete opts.appId;
+    }
+    return [opts, alertType, appId];
+}
+exports.getOptsAndAlertTypeAndApp = getOptsAndAlertTypeAndApp;

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

@@ -0,0 +1,35 @@
+import { FirebaseAlertData } from './alerts';
+import { CloudEvent, CloudFunction } from '../../core';
+import * as options from '../../options';
+/**
+ * The internal payload object for adding a new tester device to app distribution.
+ * Payload is wrapped inside a FirebaseAlertData object.
+ */
+export interface NewTesterDevicePayload {
+    ['@type']: 'com.google.firebase.firebasealerts.NewTesterDevicePayload';
+    testerName: string;
+    testerEmail: string;
+    testerDeviceModelName: string;
+    testerDeviceIdentifier: string;
+}
+interface WithAlertTypeAndApp {
+    alertType: string;
+    appId: string;
+}
+/**
+ * A custom CloudEvent for Firebase Alerts (with custom extension attributes).
+ */
+export declare type AppDistributionEvent<T> = CloudEvent<FirebaseAlertData<T>, WithAlertTypeAndApp>;
+/**
+ * Configuration for app distribution functions.
+ */
+export interface AppDistributionOptions extends options.EventHandlerOptions {
+    appId?: string;
+}
+/**
+ * Declares a function that can handle adding a new tester iOS device.
+ */
+export declare function onNewTesterIosDevicePublished(handler: (event: AppDistributionEvent<NewTesterDevicePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<NewTesterDevicePayload>>;
+export declare function onNewTesterIosDevicePublished(appId: string, handler: (event: AppDistributionEvent<NewTesterDevicePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<NewTesterDevicePayload>>;
+export declare function onNewTesterIosDevicePublished(opts: AppDistributionOptions, handler: (event: AppDistributionEvent<NewTesterDevicePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<NewTesterDevicePayload>>;
+export {};

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOptsAndApp = exports.onNewTesterIosDevicePublished = exports.newTesterIosDeviceAlert = void 0;
+const alerts_1 = require("./alerts");
+/** @internal */
+exports.newTesterIosDeviceAlert = 'appDistribution.newTesterIosDevice';
+function onNewTesterIosDevicePublished(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.newTesterIosDeviceAlert, appId);
+    return func;
+}
+exports.onNewTesterIosDevicePublished = onNewTesterIosDevicePublished;
+/**
+ * @internal
+ * Helper function to parse the function opts and appId.
+ */
+function getOptsAndApp(appIdOrOpts) {
+    let opts;
+    let appId;
+    if (typeof appIdOrOpts === 'string') {
+        opts = {};
+        appId = appIdOrOpts;
+    }
+    else {
+        appId = appIdOrOpts.appId;
+        opts = { ...appIdOrOpts };
+        delete opts.appId;
+    }
+    return [opts, appId];
+}
+exports.getOptsAndApp = getOptsAndApp;

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

@@ -0,0 +1,38 @@
+import { FirebaseAlertData } from '.';
+import { CloudEvent, CloudFunction } from '../../core';
+import * as options from '../../options';
+/**
+ * The internal payload object for billing plan updates.
+ * Payload is wrapped inside a FirebaseAlertData object.
+ */
+export interface PlanUpdatePayload {
+    ['@type']: 'com.google.firebase.firebasealerts.PlanUpdatePayload';
+    billingPlan: string;
+    principalEmail: string;
+}
+/**
+ * The internal payload object for billing plan automated updates.
+ * Payload is wrapped inside a FirebaseAlertData object.
+ */
+export interface PlanAutomatedUpdatePayload {
+    ['@type']: 'com.google.firebase.firebasealerts.PlanAutomatedUpdatePayload';
+    billingPlan: string;
+}
+interface WithAlertType {
+    alertType: string;
+}
+/**
+ * A custom CloudEvent for billing Firebase Alerts (with custom extension attributes).
+ */
+export declare type BillingEvent<T> = CloudEvent<FirebaseAlertData<T>, WithAlertType>;
+/**
+ * Declares a function that can handle a billing plan update event.
+ */
+export declare function onPlanUpdatePublished(handler: (event: BillingEvent<PlanUpdatePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<PlanUpdatePayload>>;
+export declare function onPlanUpdatePublished(opts: options.EventHandlerOptions, handler: (event: BillingEvent<PlanUpdatePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<PlanUpdatePayload>>;
+/**
+ * Declares a function that can handle an automated billing plan update event.
+ */
+export declare function onAutomatedPlanUpdatePublished(handler: (event: BillingEvent<PlanAutomatedUpdatePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<PlanAutomatedUpdatePayload>>;
+export declare function onAutomatedPlanUpdatePublished(opts: options.EventHandlerOptions, handler: (event: BillingEvent<PlanAutomatedUpdatePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<PlanAutomatedUpdatePayload>>;
+export {};

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onOperation = exports.onAutomatedPlanUpdatePublished = exports.onPlanUpdatePublished = exports.automatedPlanUpdateAlert = exports.planUpdateAlert = void 0;
+const _1 = require(".");
+/** @internal */
+exports.planUpdateAlert = 'billing.planUpdate';
+/** @internal */
+exports.automatedPlanUpdateAlert = 'billing.automatedPlanUpdate';
+function onPlanUpdatePublished(optsOrHandler, handler) {
+    return onOperation(exports.planUpdateAlert, optsOrHandler, handler);
+}
+exports.onPlanUpdatePublished = onPlanUpdatePublished;
+function onAutomatedPlanUpdatePublished(optsOrHandler, handler) {
+    return onOperation(exports.automatedPlanUpdateAlert, optsOrHandler, handler);
+}
+exports.onAutomatedPlanUpdatePublished = onAutomatedPlanUpdatePublished;
+/** @internal */
+function onOperation(alertType, optsOrHandler, handler) {
+    if (typeof optsOrHandler === 'function') {
+        handler = optsOrHandler;
+        optsOrHandler = {};
+    }
+    const func = (raw) => {
+        return handler(raw);
+    };
+    func.run = handler;
+    func.__endpoint = (0, _1.getEndpointAnnotation)(optsOrHandler, alertType);
+    return func;
+}
+exports.onOperation = onOperation;

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

@@ -0,0 +1,123 @@
+import { FirebaseAlertData } from '.';
+import { CloudEvent, CloudFunction } from '../../core';
+import * as options from '../../options';
+/** Generic crashlytics issue interface */
+interface Issue {
+    id: string;
+    title: string;
+    subtitle: string;
+    appVersion: string;
+}
+/**
+ * The internal payload object for a new fatal issue.
+ * Payload is wrapped inside a FirebaseAlertData object.
+ */
+export interface NewFatalIssuePayload {
+    ['@type']: 'com.google.firebase.firebasealerts.CrashlyticsNewFatalIssuePayload';
+    issue: Issue;
+}
+/**
+ * The internal payload object for a new non-fatal issue.
+ * Payload is wrapped inside a FirebaseAlertData object.
+ */
+export interface NewNonfatalIssuePayload {
+    ['@type']: 'com.google.firebase.firebasealerts.CrashlyticsNewNonfatalIssuePayload';
+    issue: Issue;
+}
+/**
+ * The internal payload object for a regression alert.
+ * Payload is wrapped inside a FirebaseAlertData object.
+ */
+export interface RegressionAlertPayload {
+    ['@type']: 'com.google.firebase.firebasealerts.CrashlyticsRegressionAlertPayload';
+    type: string;
+    issue: Issue;
+    resolveTime: string;
+}
+/** Generic crashlytics trending issue interface */
+interface TrendingIssueDetails {
+    type: string;
+    issue: Issue;
+    eventCount: number;
+    userCount: number;
+}
+/**
+ * The internal payload object for a stability digest.
+ * Payload is wrapped inside a FirebaseAlertData object.
+ */
+export interface StabilityDigestPayload {
+    ['@type']: 'com.google.firebase.firebasealerts.CrashlyticsStabilityDigestPayload';
+    digestDate: string;
+    trendingIssues: TrendingIssueDetails[];
+}
+/**
+ * The internal payload object for a velocity alert.
+ * Payload is wrapped inside a FirebaseAlertData object.
+ */
+export interface VelocityAlertPayload {
+    ['@type']: 'com.google.firebase.firebasealerts.VelocityAlertPayload';
+    issue: Issue;
+    createTime: string;
+    crashCount: number;
+    crashPercentage: number;
+    firstVersion: string;
+}
+/**
+ * The internal payload object for a new Application Not Responding issue.
+ * Payload is wrapped inside a FirebaseAlertData object.
+ */
+export interface NewAnrIssuePayload {
+    ['@type']: 'com.google.firebase.firebasealerts.NewAnrIssuePayload';
+    issue: Issue;
+}
+interface WithAlertTypeAndApp {
+    alertType: string;
+    appId: string;
+}
+/**
+ * A custom CloudEvent for Firebase Alerts (with custom extension attributes).
+ */
+export declare type CrashlyticsEvent<T> = CloudEvent<FirebaseAlertData<T>, WithAlertTypeAndApp>;
+/**
+ * Configuration for crashlytics functions.
+ */
+export interface CrashlyticsOptions extends options.EventHandlerOptions {
+    appId?: string;
+}
+/**
+ * Declares a function that can handle a new fatal issue published to crashlytics.
+ */
+export declare function onNewFatalIssuePublished(handler: (event: CrashlyticsEvent<NewFatalIssuePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<NewFatalIssuePayload>>;
+export declare function onNewFatalIssuePublished(appId: string, handler: (event: CrashlyticsEvent<NewFatalIssuePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<NewFatalIssuePayload>>;
+export declare function onNewFatalIssuePublished(opts: CrashlyticsOptions, handler: (event: CrashlyticsEvent<NewFatalIssuePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<NewFatalIssuePayload>>;
+/**
+ * Declares a function that can handle aa new non-fatal issue published to crashlytics.
+ */
+export declare function onNewNonfatalIssuePublished(handler: (event: CrashlyticsEvent<NewNonfatalIssuePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<NewNonfatalIssuePayload>>;
+export declare function onNewNonfatalIssuePublished(appId: string, handler: (event: CrashlyticsEvent<NewNonfatalIssuePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<NewNonfatalIssuePayload>>;
+export declare function onNewNonfatalIssuePublished(opts: CrashlyticsOptions, handler: (event: CrashlyticsEvent<NewNonfatalIssuePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<NewNonfatalIssuePayload>>;
+/**
+ * Declares a function that can handle a regression alert published to crashlytics.
+ */
+export declare function onRegressionAlertPublished(handler: (event: CrashlyticsEvent<RegressionAlertPayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<RegressionAlertPayload>>;
+export declare function onRegressionAlertPublished(appId: string, handler: (event: CrashlyticsEvent<RegressionAlertPayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<RegressionAlertPayload>>;
+export declare function onRegressionAlertPublished(opts: CrashlyticsOptions, handler: (event: CrashlyticsEvent<RegressionAlertPayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<RegressionAlertPayload>>;
+/**
+ * Declares a function that can handle a stability digest published to crashlytics.
+ */
+export declare function onStabilityDigestPublished(handler: (event: CrashlyticsEvent<StabilityDigestPayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<StabilityDigestPayload>>;
+export declare function onStabilityDigestPublished(appId: string, handler: (event: CrashlyticsEvent<StabilityDigestPayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<StabilityDigestPayload>>;
+export declare function onStabilityDigestPublished(opts: CrashlyticsOptions, handler: (event: CrashlyticsEvent<StabilityDigestPayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<StabilityDigestPayload>>;
+/**
+ * Declares a function that can handle a velocity alert published to crashlytics.
+ */
+export declare function onVelocityAlertPublished(handler: (event: CrashlyticsEvent<VelocityAlertPayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<VelocityAlertPayload>>;
+export declare function onVelocityAlertPublished(appId: string, handler: (event: CrashlyticsEvent<VelocityAlertPayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<VelocityAlertPayload>>;
+export declare function onVelocityAlertPublished(opts: CrashlyticsOptions, handler: (event: CrashlyticsEvent<VelocityAlertPayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<VelocityAlertPayload>>;
+/**
+ * Declares a function that can handle a new Application Not Responding issue published to crashlytics.
+ */
+export declare function onNewAnrIssuePublished(handler: (event: CrashlyticsEvent<NewAnrIssuePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<NewAnrIssuePayload>>;
+export declare function onNewAnrIssuePublished(appId: string, handler: (event: CrashlyticsEvent<NewAnrIssuePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<NewAnrIssuePayload>>;
+export declare function onNewAnrIssuePublished(opts: CrashlyticsOptions, handler: (event: CrashlyticsEvent<NewAnrIssuePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<NewAnrIssuePayload>>;
+export {};

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOptsAndApp = exports.onOperation = exports.onNewAnrIssuePublished = exports.onVelocityAlertPublished = exports.onStabilityDigestPublished = exports.onRegressionAlertPublished = exports.onNewNonfatalIssuePublished = exports.onNewFatalIssuePublished = exports.newAnrIssueAlert = exports.velocityAlert = exports.stabilityDigestAlert = exports.regressionAlert = exports.newNonfatalIssueAlert = exports.newFatalIssueAlert = void 0;
+const _1 = require(".");
+/** @internal */
+exports.newFatalIssueAlert = 'crashlytics.newFatalIssue';
+/** @internal */
+exports.newNonfatalIssueAlert = 'crashlytics.newNonfatalIssue';
+/** @internal */
+exports.regressionAlert = 'crashlytics.regression';
+/** @internal */
+exports.stabilityDigestAlert = 'crashlytics.stabilityDigest';
+/** @internal */
+exports.velocityAlert = 'crashlytics.velocity';
+/** @internal */
+exports.newAnrIssueAlert = 'crashlytics.newAnrIssue';
+function onNewFatalIssuePublished(appIdOrOptsOrHandler, handler) {
+    return onOperation(exports.newFatalIssueAlert, appIdOrOptsOrHandler, handler);
+}
+exports.onNewFatalIssuePublished = onNewFatalIssuePublished;
+function onNewNonfatalIssuePublished(appIdOrOptsOrHandler, handler) {
+    return onOperation(exports.newNonfatalIssueAlert, appIdOrOptsOrHandler, handler);
+}
+exports.onNewNonfatalIssuePublished = onNewNonfatalIssuePublished;
+function onRegressionAlertPublished(appIdOrOptsOrHandler, handler) {
+    return onOperation(exports.regressionAlert, appIdOrOptsOrHandler, handler);
+}
+exports.onRegressionAlertPublished = onRegressionAlertPublished;
+function onStabilityDigestPublished(appIdOrOptsOrHandler, handler) {
+    return onOperation(exports.stabilityDigestAlert, appIdOrOptsOrHandler, handler);
+}
+exports.onStabilityDigestPublished = onStabilityDigestPublished;
+function onVelocityAlertPublished(appIdOrOptsOrHandler, handler) {
+    return onOperation(exports.velocityAlert, appIdOrOptsOrHandler, handler);
+}
+exports.onVelocityAlertPublished = onVelocityAlertPublished;
+function onNewAnrIssuePublished(appIdOrOptsOrHandler, handler) {
+    return onOperation(exports.newAnrIssueAlert, appIdOrOptsOrHandler, handler);
+}
+exports.onNewAnrIssuePublished = onNewAnrIssuePublished;
+/** @internal */
+function onOperation(alertType, 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, _1.getEndpointAnnotation)(opts, alertType, appId);
+    return func;
+}
+exports.onOperation = onOperation;
+/**
+ * @internal
+ * Helper function to parse the function opts and appId.
+ */
+function getOptsAndApp(appIdOrOpts) {
+    let opts;
+    let appId;
+    if (typeof appIdOrOpts === 'string') {
+        opts = {};
+        appId = appIdOrOpts;
+    }
+    else {
+        appId = appIdOrOpts.appId;
+        opts = { ...appIdOrOpts };
+        delete opts.appId;
+    }
+    return [opts, appId];
+}
+exports.getOptsAndApp = getOptsAndApp;

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

@@ -0,0 +1,5 @@
+import * as appDistribution from './appDistribution';
+import * as billing from './billing';
+import * as crashlytics from './crashlytics';
+export { appDistribution, billing, crashlytics };
+export * from './alerts';

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

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crashlytics = exports.billing = exports.appDistribution = void 0;
+const appDistribution = require("./appDistribution");
+exports.appDistribution = appDistribution;
+const billing = require("./billing");
+exports.billing = billing;
+const crashlytics = require("./crashlytics");
+exports.crashlytics = crashlytics;
+__exportStar(require("./alerts"), exports);

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

@@ -1,18 +1,38 @@
 import * as express from 'express';
-import { CallableRequest, FunctionsErrorCode, HttpsError, Request } from '../../common/providers/https';
 import * as options from '../options';
-export { Request, CallableRequest, FunctionsErrorCode, HttpsError };
+import { CallableRequest, FunctionsErrorCode, HttpsError, Request, TaskRateLimits, TaskRequest, TaskRetryConfig } from '../../common/providers/https';
+import { ManifestEndpoint } from '../../runtime/manifest';
+export { Request, CallableRequest, FunctionsErrorCode, HttpsError, TaskRateLimits, TaskRequest, TaskRetryConfig as TaskRetryPolicy, };
 export interface HttpsOptions extends Omit<options.GlobalOptions, 'region'> {
     region?: options.SupportedRegion | string | Array<options.SupportedRegion | string>;
-    cors?: string | boolean;
+    cors?: string | boolean | RegExp | Array<string | RegExp>;
+}
+export interface TaskQueueOptions extends options.GlobalOptions {
+    retryConfig?: TaskRetryConfig;
+    rateLimits?: TaskRateLimits;
+    /**
+     * Who can enqueue tasks for this function.
+     * If left unspecified, only service accounts which have
+     * roles/cloudtasks.enqueuer and roles/cloudfunctions.invoker
+     * will have permissions.
+     */
+    invoker?: 'private' | string | string[];
 }
 export declare type HttpsFunction = ((req: Request, res: express.Response) => void | Promise<void>) & {
-    __trigger: unknown;
+    __trigger?: unknown;
+    __endpoint: ManifestEndpoint;
 };
 export interface CallableFunction<T, Return> extends HttpsFunction {
     run(data: CallableRequest<T>): Return;
 }
+export interface TaskQueueFunction<T = any> extends HttpsFunction {
+    run(data: TaskRequest<T>): void | Promise<void>;
+}
 export declare function onRequest(opts: HttpsOptions, handler: (request: Request, response: express.Response) => void | Promise<void>): HttpsFunction;
 export declare function onRequest(handler: (request: Request, response: express.Response) => void | Promise<void>): HttpsFunction;
 export declare function onCall<T = any, Return = any | Promise<any>>(opts: HttpsOptions, handler: (request: CallableRequest<T>) => Return): CallableFunction<T, Return>;
 export declare function onCall<T = any, Return = any | Promise<any>>(handler: (request: CallableRequest<T>) => Return): CallableFunction<T, Return>;
+/** Handle a request sent to a Cloud Tasks queue. */
+export declare function onTaskDispatched<Args = any>(handler: (request: TaskRequest<Args>) => void | Promise<void>): TaskQueueFunction<Args>;
+/** Handle a request sent to a Cloud Tasks queue. */
+export declare function onTaskDispatched<Args = any>(options: TaskQueueOptions, handler: (request: TaskRequest<Args>) => void | Promise<void>): TaskQueueFunction<Args>;