firebase-functions 3.19.0 → 3.21.0

package/lib/v2/index.js

@@ -21,18 +21,24 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setGlobalOptions = exports.alerts = exports.params = exports.logger = exports.storage = exports.pubsub = exports.https = void 0;
+exports.setGlobalOptions = exports.eventarc = exports.tasks = exports.params = exports.logger = exports.storage = exports.pubsub = exports.identity = exports.https = exports.alerts = void 0;
 const logger = require("../logger");
 exports.logger = logger;
 const params = require("./params");
 exports.params = params;
 const alerts = require("./providers/alerts");
 exports.alerts = alerts;
+const eventarc = require("./providers/eventarc");
+exports.eventarc = eventarc;
 const https = require("./providers/https");
 exports.https = https;
+const identity = require("./providers/identity");
+exports.identity = identity;
 const pubsub = require("./providers/pubsub");
 exports.pubsub = pubsub;
 const storage = require("./providers/storage");
 exports.storage = storage;
+const tasks = require("./providers/tasks");
+exports.tasks = tasks;
 var options_1 = require("./options");
 Object.defineProperty(exports, "setGlobalOptions", { enumerable: true, get: function () { return options_1.setGlobalOptions; } });

package/lib/v2/options.d.ts

@@ -26,7 +26,7 @@ export declare const MAX_CONCURRENCY = 1000;
 /**
  * List of available memory options supported by Cloud Functions.
  */
-export declare const SUPPORTED_MEMORY_OPTIONS: readonly ["128MB", "256MB", "512MB", "1GB", "2GB", "4GB", "8GB", "16GB", "32GB"];
+export declare const SUPPORTED_MEMORY_OPTIONS: readonly ["128MiB", "256MiB", "512MiB", "1GiB", "2GiB", "4GiB", "8GiB", "16GiB", "32GiB"];
 /**
  * A supported memory option.
  */
@@ -80,9 +80,19 @@ export interface GlobalOptions {
     /**
      * 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.
+     * 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.
      */
     concurrency?: 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
@@ -111,6 +121,7 @@ export interface GlobalOptions {
      * Invoker to set access control on https functions.
      */
     invoker?: 'public' | 'private' | string | string[];
+    secrets?: string[];
 }
 /**
  * Sets default options for all functions written using the v2 SDK.

package/lib/v2/options.js

@@ -57,26 +57,26 @@ exports.MAX_CONCURRENCY = 1000;
  * List of available memory options supported by Cloud Functions.
  */
 exports.SUPPORTED_MEMORY_OPTIONS = [
-    '128MB',
-    '256MB',
-    '512MB',
-    '1GB',
-    '2GB',
-    '4GB',
-    '8GB',
-    '16GB',
-    '32GB',
+    '128MiB',
+    '256MiB',
+    '512MiB',
+    '1GiB',
+    '2GiB',
+    '4GiB',
+    '8GiB',
+    '16GiB',
+    '32GiB',
 ];
 const MemoryOptionToMB = {
-    '128MB': 128,
-    '256MB': 256,
-    '512MB': 512,
-    '1GB': 1024,
-    '2GB': 2048,
-    '4GB': 4096,
-    '8GB': 8192,
-    '16GB': 16384,
-    '32GB': 32768,
+    '128MiB': 128,
+    '256MiB': 256,
+    '512MiB': 512,
+    '1GiB': 1024,
+    '2GiB': 2048,
+    '4GiB': 4096,
+    '8GiB': 8192,
+    '16GiB': 16384,
+    '32GiB': 32768,
 };
 /**
  * List of available options for VpcConnectorEgressSettings.
@@ -120,7 +120,7 @@ exports.getGlobalOptions = getGlobalOptions;
  */
 function optionsToTriggerAnnotations(opts) {
     const annotation = {};
-    (0, encoding_1.copyIfPresent)(annotation, opts, 'concurrency', 'minInstances', 'maxInstances', 'ingressSettings', 'labels', 'vpcConnector', 'vpcConnectorEgressSettings');
+    (0, encoding_1.copyIfPresent)(annotation, opts, 'concurrency', 'minInstances', 'maxInstances', 'ingressSettings', 'labels', 'vpcConnector', 'vpcConnectorEgressSettings', 'secrets');
     (0, encoding_1.convertIfPresent)(annotation, opts, 'availableMemoryMb', 'memory', (mem) => {
         return MemoryOptionToMB[mem];
     });
@@ -144,7 +144,7 @@ exports.optionsToTriggerAnnotations = optionsToTriggerAnnotations;
  */
 function optionsToEndpoint(opts) {
     const endpoint = {};
-    (0, encoding_1.copyIfPresent)(endpoint, opts, 'concurrency', 'minInstances', 'maxInstances', 'ingressSettings', 'labels', 'timeoutSeconds');
+    (0, encoding_1.copyIfPresent)(endpoint, opts, 'concurrency', 'minInstances', 'maxInstances', 'ingressSettings', 'labels', 'timeoutSeconds', 'cpu');
     (0, encoding_1.convertIfPresent)(endpoint, opts, 'serviceAccountEmail', 'serviceAccount');
     if (opts.vpcConnector) {
         const vpc = { connector: opts.vpcConnector };
@@ -152,16 +152,7 @@ function optionsToEndpoint(opts) {
         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];
+        return MemoryOptionToMB[mem];
     });
     (0, encoding_1.convertIfPresent)(endpoint, opts, 'region', 'region', (region) => {
         if (typeof region === 'string') {
@@ -169,6 +160,7 @@ function optionsToEndpoint(opts) {
         }
         return region;
     });
+    (0, encoding_1.convertIfPresent)(endpoint, opts, 'secretEnvironmentVariables', 'secrets', (secrets) => secrets.map((secret) => ({ key: secret })));
     return endpoint;
 }
 exports.optionsToEndpoint = optionsToEndpoint;

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

@@ -4,18 +4,27 @@ import * as options from '../../options';
  * The CloudEvent data emitted by Firebase Alerts.
  */
 export interface FirebaseAlertData<T = any> {
+    /** Time that the event has created. */
     createTime: string;
+    /** Time that the event has ended. Optional, only present for ongoing alerts. */
     endTime: string;
+    /** Payload of the event, which includes the details of the specific alert. */
     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>;
+export interface AlertEvent<T> extends CloudEvent<FirebaseAlertData<T>> {
+    /** The type of the alerts that got triggered. */
+    alertType: string;
+    /**
+     * The Firebase App ID that’s associated with the alert. This is optional,
+     * and only present when the alert is targeting at a specific Firebase App.
+     */
+    appId?: string;
+    /** Data for an AlertEvent is a FirebaseAlertData with a given payload. */
+    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;
 /**
@@ -32,5 +41,4 @@ export interface FirebaseAlertOptions extends options.EventHandlerOptions {
  */
 export declare function onAlertPublished<T extends {
     ['@type']: string;
-} = any>(alertTypeOrOpts: AlertType | FirebaseAlertOptions, handler: (event: AlertEvent<T>) => any | Promise<any>): CloudFunction<FirebaseAlertData<T>>;
-export {};
+} = any>(alertTypeOrOpts: AlertType | FirebaseAlertOptions, handler: (event: AlertEvent<T>) => any | Promise<any>): CloudFunction<AlertEvent<T>>;

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

@@ -36,20 +36,14 @@ function getEndpointAnnotation(opts, alertType, appId) {
         },
         eventTrigger: {
             eventType: exports.eventType,
-            eventFilters: [
-                {
-                    attribute: 'alerttype',
-                    value: alertType,
-                },
-            ],
+            eventFilters: {
+                alerttype: alertType,
+            },
             retry: !!opts.retry,
         },
     };
     if (appId) {
-        endpoint.eventTrigger.eventFilters.push({
-            attribute: 'appid',
-            value: appId,
-        });
+        endpoint.eventTrigger.eventFilters.appid = appId;
     }
     return endpoint;
 }

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

@@ -1,25 +1,26 @@
-import { FirebaseAlertData } from './alerts';
 import { CloudEvent, CloudFunction } from '../../core';
 import * as options from '../../options';
+import { FirebaseAlertData } from './alerts';
 /**
  * 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';
+    ['@type']: 'type.googleapis.com/google.events.firebase.firebasealerts.v1.AppDistroNewTesterIosDevicePayload';
     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>;
+export interface AppDistributionEvent<T> extends CloudEvent<FirebaseAlertData<T>> {
+    /** The type of the alerts that got triggered. */
+    alertType: string;
+    /** The Firebase App ID that’s associated with the alert. */
+    appId: string;
+}
 /**
  * Configuration for app distribution functions.
  */
@@ -29,7 +30,6 @@ export interface AppDistributionOptions extends options.EventHandlerOptions {
 /**
  * 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 {};
+export declare function onNewTesterIosDevicePublished(handler: (event: AppDistributionEvent<NewTesterDevicePayload>) => any | Promise<any>): CloudFunction<AppDistributionEvent<NewTesterDevicePayload>>;
+export declare function onNewTesterIosDevicePublished(appId: string, handler: (event: AppDistributionEvent<NewTesterDevicePayload>) => any | Promise<any>): CloudFunction<AppDistributionEvent<NewTesterDevicePayload>>;
+export declare function onNewTesterIosDevicePublished(opts: AppDistributionOptions, handler: (event: AppDistributionEvent<NewTesterDevicePayload>) => any | Promise<any>): CloudFunction<AppDistributionEvent<NewTesterDevicePayload>>;

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

@@ -6,33 +6,39 @@ import * as options from '../../options';
  * Payload is wrapped inside a FirebaseAlertData object.
  */
 export interface PlanUpdatePayload {
-    ['@type']: 'com.google.firebase.firebasealerts.PlanUpdatePayload';
+    ['@type']: 'type.googleapis.com/google.events.firebase.firebasealerts.v1.BillingPlanUpdatePayload';
+    /** A Firebase billing plan. */
     billingPlan: string;
+    /** The email address of the person that triggered billing plan change */
     principalEmail: string;
+    /** The type of the notification, e.g. upgrade, downgrade */
+    notificationType: 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';
+    ['@type']: 'type.googleapis.com/google.events.firebase.firebasealerts.v1.BillingPlanAutomatedUpdatePayload';
+    /** A Firebase billing plan. */
     billingPlan: string;
-}
-interface WithAlertType {
-    alertType: string;
+    /** The type of the notification, e.g. upgrade, downgrade */
+    notificationType: string;
 }
 /**
  * A custom CloudEvent for billing Firebase Alerts (with custom extension attributes).
  */
-export declare type BillingEvent<T> = CloudEvent<FirebaseAlertData<T>, WithAlertType>;
+export interface BillingEvent<T> extends CloudEvent<FirebaseAlertData<T>> {
+    /** The type of the alerts that got triggered. */
+    alertType: string;
+}
 /**
  * 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>>;
+export declare function onPlanUpdatePublished(handler: (event: BillingEvent<PlanUpdatePayload>) => any | Promise<any>): CloudFunction<BillingEvent<PlanUpdatePayload>>;
+export declare function onPlanUpdatePublished(opts: options.EventHandlerOptions, handler: (event: BillingEvent<PlanUpdatePayload>) => any | Promise<any>): CloudFunction<BillingEvent<PlanUpdatePayload>>;
 /**
  * Declares a function that can handle an automated billing plan update event.
  */
-export declare function onPlanAutomatedUpdatePublished(handler: (event: BillingEvent<PlanAutomatedUpdatePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<PlanAutomatedUpdatePayload>>;
-export declare function onPlanAutomatedUpdatePublished(opts: options.EventHandlerOptions, handler: (event: BillingEvent<PlanAutomatedUpdatePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<PlanAutomatedUpdatePayload>>;
-export {};
+export declare function onPlanAutomatedUpdatePublished(handler: (event: BillingEvent<PlanAutomatedUpdatePayload>) => any | Promise<any>): CloudFunction<BillingEvent<PlanAutomatedUpdatePayload>>;
+export declare function onPlanAutomatedUpdatePublished(opts: options.EventHandlerOptions, handler: (event: BillingEvent<PlanAutomatedUpdatePayload>) => any | Promise<any>): CloudFunction<BillingEvent<PlanAutomatedUpdatePayload>>;

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

@@ -13,7 +13,8 @@ interface Issue {
  * Payload is wrapped inside a FirebaseAlertData object.
  */
 export interface NewFatalIssuePayload {
-    ['@type']: 'com.google.firebase.firebasealerts.CrashlyticsNewFatalIssuePayload';
+    ['@type']: 'type.googleapis.com/google.events.firebase.firebasealerts.v1.CrashlyticsNewFatalIssuePayload';
+    /** Basic information of the Crashlytics issue */
     issue: Issue;
 }
 /**
@@ -21,7 +22,8 @@ export interface NewFatalIssuePayload {
  * Payload is wrapped inside a FirebaseAlertData object.
  */
 export interface NewNonfatalIssuePayload {
-    ['@type']: 'com.google.firebase.firebasealerts.CrashlyticsNewNonfatalIssuePayload';
+    ['@type']: 'type.googleapis.com/google.events.firebase.firebasealerts.v1.CrashlyticsNewNonfatalIssuePayload';
+    /** Basic information of the Crashlytics issue */
     issue: Issue;
 }
 /**
@@ -29,16 +31,26 @@ export interface NewNonfatalIssuePayload {
  * Payload is wrapped inside a FirebaseAlertData object.
  */
 export interface RegressionAlertPayload {
-    ['@type']: 'com.google.firebase.firebasealerts.CrashlyticsRegressionAlertPayload';
+    ['@type']: 'type.googleapis.com/google.events.firebase.firebasealerts.v1.CrashlyticsRegressionAlertPayload';
+    /** The type of the Crashlytics issue, e.g. new fatal, new nonfatal, ANR */
     type: string;
+    /** Basic information of the Crashlytics issue */
     issue: Issue;
+    /**
+     * The time that the Crashlytics issues was most recently resolved before it
+     * began to reoccur.
+     */
     resolveTime: string;
 }
 /** Generic crashlytics trending issue interface */
 interface TrendingIssueDetails {
+    /** The type of the Crashlytics issue, e.g. new fatal, new nonfatal, ANR */
     type: string;
+    /** Basic information of the Crashlytics issue */
     issue: Issue;
+    /** The number of crashes that occurred with the issue */
     eventCount: number;
+    /** The number of distinct users that were affected by the issue */
     userCount: number;
 }
 /**
@@ -46,8 +58,13 @@ interface TrendingIssueDetails {
  * Payload is wrapped inside a FirebaseAlertData object.
  */
 export interface StabilityDigestPayload {
-    ['@type']: 'com.google.firebase.firebasealerts.CrashlyticsStabilityDigestPayload';
+    ['@type']: 'type.googleapis.com/google.events.firebase.firebasealerts.v1.CrashlyticsStabilityDigestPayload';
+    /**
+     * The date that the digest gets created. Issues in the digest should have the
+     * same date as the digest date
+     */
     digestDate: string;
+    /** A stability digest containing several trending Crashlytics issues */
     trendingIssues: TrendingIssueDetails[];
 }
 /**
@@ -55,11 +72,25 @@ export interface StabilityDigestPayload {
  * Payload is wrapped inside a FirebaseAlertData object.
  */
 export interface VelocityAlertPayload {
-    ['@type']: 'com.google.firebase.firebasealerts.VelocityAlertPayload';
+    ['@type']: 'type.googleapis.com/google.events.firebase.firebasealerts.v1.CrashlyticsVelocityAlertPayload';
+    /** Basic information of the Crashlytics issue */
     issue: Issue;
+    /** The time that the Crashlytics issue gets created */
     createTime: string;
+    /**
+     * The number of user sessions for the given app version that had this
+     * specific crash issue in the time period used to trigger the velocity alert.
+     */
     crashCount: number;
+    /**
+     * The percentage of user sessions for the given app version that had this
+     * specific crash issue in the time period used to trigger the velocity alert.
+     */
     crashPercentage: number;
+    /**
+     * The first app version where this issue was seen, and not necessarily the
+     * version that has triggered the alert.
+     */
     firstVersion: string;
 }
 /**
@@ -67,17 +98,19 @@ export interface VelocityAlertPayload {
  * Payload is wrapped inside a FirebaseAlertData object.
  */
 export interface NewAnrIssuePayload {
-    ['@type']: 'com.google.firebase.firebasealerts.NewAnrIssuePayload';
+    ['@type']: 'type.googleapis.com/google.events.firebase.firebasealerts.v1.CrashlyticsNewAnrIssuePayload';
+    /** Basic information of the Crashlytics issue */
     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>;
+export interface CrashlyticsEvent<T> extends CloudEvent<FirebaseAlertData<T>> {
+    /** The type of the alerts that got triggered. */
+    alertType: string;
+    /** The Firebase App ID that’s associated with the alert. */
+    appId: string;
+}
 /**
  * Configuration for crashlytics functions.
  */
@@ -87,37 +120,37 @@ export interface CrashlyticsOptions extends options.EventHandlerOptions {
 /**
  * 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>>;
+export declare function onNewFatalIssuePublished(handler: (event: CrashlyticsEvent<NewFatalIssuePayload>) => any | Promise<any>): CloudFunction<CrashlyticsEvent<NewFatalIssuePayload>>;
+export declare function onNewFatalIssuePublished(appId: string, handler: (event: CrashlyticsEvent<NewFatalIssuePayload>) => any | Promise<any>): CloudFunction<CrashlyticsEvent<NewFatalIssuePayload>>;
+export declare function onNewFatalIssuePublished(opts: CrashlyticsOptions, handler: (event: CrashlyticsEvent<NewFatalIssuePayload>) => any | Promise<any>): CloudFunction<CrashlyticsEvent<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>>;
+export declare function onNewNonfatalIssuePublished(handler: (event: CrashlyticsEvent<NewNonfatalIssuePayload>) => any | Promise<any>): CloudFunction<CrashlyticsEvent<NewNonfatalIssuePayload>>;
+export declare function onNewNonfatalIssuePublished(appId: string, handler: (event: CrashlyticsEvent<NewNonfatalIssuePayload>) => any | Promise<any>): CloudFunction<CrashlyticsEvent<NewNonfatalIssuePayload>>;
+export declare function onNewNonfatalIssuePublished(opts: CrashlyticsOptions, handler: (event: CrashlyticsEvent<NewNonfatalIssuePayload>) => any | Promise<any>): CloudFunction<CrashlyticsEvent<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>>;
+export declare function onRegressionAlertPublished(handler: (event: CrashlyticsEvent<RegressionAlertPayload>) => any | Promise<any>): CloudFunction<CrashlyticsEvent<RegressionAlertPayload>>;
+export declare function onRegressionAlertPublished(appId: string, handler: (event: CrashlyticsEvent<RegressionAlertPayload>) => any | Promise<any>): CloudFunction<CrashlyticsEvent<RegressionAlertPayload>>;
+export declare function onRegressionAlertPublished(opts: CrashlyticsOptions, handler: (event: CrashlyticsEvent<RegressionAlertPayload>) => any | Promise<any>): CloudFunction<CrashlyticsEvent<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>>;
+export declare function onStabilityDigestPublished(handler: (event: CrashlyticsEvent<StabilityDigestPayload>) => any | Promise<any>): CloudFunction<CrashlyticsEvent<StabilityDigestPayload>>;
+export declare function onStabilityDigestPublished(appId: string, handler: (event: CrashlyticsEvent<StabilityDigestPayload>) => any | Promise<any>): CloudFunction<CrashlyticsEvent<StabilityDigestPayload>>;
+export declare function onStabilityDigestPublished(opts: CrashlyticsOptions, handler: (event: CrashlyticsEvent<StabilityDigestPayload>) => any | Promise<any>): CloudFunction<CrashlyticsEvent<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>>;
+export declare function onVelocityAlertPublished(handler: (event: CrashlyticsEvent<VelocityAlertPayload>) => any | Promise<any>): CloudFunction<CrashlyticsEvent<VelocityAlertPayload>>;
+export declare function onVelocityAlertPublished(appId: string, handler: (event: CrashlyticsEvent<VelocityAlertPayload>) => any | Promise<any>): CloudFunction<CrashlyticsEvent<VelocityAlertPayload>>;
+export declare function onVelocityAlertPublished(opts: CrashlyticsOptions, handler: (event: CrashlyticsEvent<VelocityAlertPayload>) => any | Promise<any>): CloudFunction<CrashlyticsEvent<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 declare function onNewAnrIssuePublished(handler: (event: CrashlyticsEvent<NewAnrIssuePayload>) => any | Promise<any>): CloudFunction<CrashlyticsEvent<NewAnrIssuePayload>>;
+export declare function onNewAnrIssuePublished(appId: string, handler: (event: CrashlyticsEvent<NewAnrIssuePayload>) => any | Promise<any>): CloudFunction<CrashlyticsEvent<NewAnrIssuePayload>>;
+export declare function onNewAnrIssuePublished(opts: CrashlyticsOptions, handler: (event: CrashlyticsEvent<NewAnrIssuePayload>) => any | Promise<any>): CloudFunction<CrashlyticsEvent<NewAnrIssuePayload>>;
 export {};

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

@@ -0,0 +1,32 @@
+import { CloudEvent, CloudFunction } from '../core';
+import * as options from '../options';
+/** Options that can be set on an Eventarc trigger. */
+export interface EventarcTriggerOptions extends options.EventHandlerOptions {
+    /**
+     * Type of the event.
+     */
+    eventType: string;
+    /**
+     * ID of the channel. Can be either:
+     *   * fully qualified channel resource name:
+     *     `projects/{project}/locations/{location}/channels/{channel-id}`
+     *   * partial resource name with location and channel ID, in which case
+     *     the runtime project ID of the function will be used:
+     *     `locations/{location}/channels/{channel-id}`
+     *   * partial channel ID, in which case the runtime project ID of the
+     *     function and `us-central1` as location will be used:
+     *     `{channel-id}`
+     *
+     * If not specified, the default Firebase channel will be used:
+     * `projects/{project}/locations/us-central1/channels/firebase`
+     */
+    channel?: string;
+    /**
+     * Eventarc event exact match filter.
+     */
+    filters?: Record<string, string>;
+}
+export declare type CloudEventHandler = (event: CloudEvent<any>) => any | Promise<any>;
+/** Handle an Eventarc event published on the default channel. */
+export declare function onCustomEventPublished<T = any>(eventType: string, handler: CloudEventHandler): CloudFunction<CloudEvent<T>>;
+export declare function onCustomEventPublished<T = any>(opts: EventarcTriggerOptions, handler: CloudEventHandler): CloudFunction<CloudEvent<T>>;

package/lib/v2/providers/eventarc.js

@@ -0,0 +1,65 @@
+"use strict";
+// The MIT License (MIT)
+//
+// Copyright (c) 2022 Firebase
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onCustomEventPublished = void 0;
+const encoding_1 = require("../../common/encoding");
+const options = require("../options");
+function onCustomEventPublished(eventTypeOrOpts, handler) {
+    var _a;
+    let opts;
+    if (typeof eventTypeOrOpts === 'string') {
+        opts = {
+            eventType: eventTypeOrOpts,
+        };
+    }
+    else if (typeof eventTypeOrOpts === 'object') {
+        opts = eventTypeOrOpts;
+    }
+    const func = (raw) => {
+        return handler(raw);
+    };
+    func.run = handler;
+    const channel = (_a = opts.channel) !== null && _a !== void 0 ? _a : 'locations/us-central1/channels/firebase';
+    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: opts.eventType,
+            eventFilters: {},
+            retry: false,
+            channel,
+        },
+    };
+    (0, encoding_1.convertIfPresent)(endpoint.eventTrigger, opts, 'eventFilters', 'filters');
+    (0, encoding_1.copyIfPresent)(endpoint.eventTrigger, opts, 'retry');
+    func.__endpoint = endpoint;
+    return func;
+}
+exports.onCustomEventPublished = onCustomEventPublished;

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

@@ -1,23 +1,15 @@
 import * as express from 'express';
-import * as options from '../options';
-import { CallableRequest, FunctionsErrorCode, HttpsError, Request, TaskRateLimits, TaskRequest, TaskRetryConfig } from '../../common/providers/https';
+import { CallableRequest, FunctionsErrorCode, HttpsError, Request } 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>;
+import { GlobalOptions, SupportedRegion } from '../options';
+export { Request, CallableRequest, FunctionsErrorCode, HttpsError };
+/**
+ * Options that can be set on an individual HTTPS Cloud Function.
+ */
+export interface HttpsOptions extends Omit<GlobalOptions, 'region'> {
+    region?: SupportedRegion | string | Array<SupportedRegion | string>;
     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;
     __endpoint: ManifestEndpoint;
@@ -25,14 +17,7 @@ export declare type HttpsFunction = ((req: Request, res: express.Response) => vo
 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>;