firebase-functions 6.6.0 → 7.0.0-rc.1

package/lib/esm/v1/cloud-functions.mjs

@@ -0,0 +1,206 @@
+import { warn } from "../logger/index.mjs";
+import { SecretParam } from "../params/types.mjs";
+import { RESET_VALUE, ResetValue } from "../common/options.mjs";
+import { initV1Endpoint, initV1ScheduleTrigger } from "../runtime/manifest.mjs";
+import { Change } from "../common/change.mjs";
+import { convertIfPresent, copyIfPresent, durationFromSeconds, serviceAccountFromShorthand } from "../common/encoding.mjs";
+import { withInit } from "../common/onInit.mjs";
+import { DEFAULT_FAILURE_POLICY } from "./function-configuration.mjs";
+
+//#region src/v1/cloud-functions.ts
+/** @internal */
+const WILDCARD_REGEX = new RegExp("{[^/{}]*}", "g");
+/** @internal */
+function makeCloudFunction({ contextOnlyHandler, dataConstructor = (raw) => raw.data, eventType, handler, labels = {}, legacyEventType, options = {}, provider, service, triggerResource }) {
+	handler = withInit(handler ?? contextOnlyHandler);
+	const cloudFunction = (data, context) => {
+		if (legacyEventType && context.eventType === legacyEventType) {
+			context.eventType = provider + "." + eventType;
+			context.resource = {
+				service,
+				name: context.resource
+			};
+		}
+		const event = {
+			data,
+			context
+		};
+		if (provider === "google.firebase.database") {
+			context.authType = _detectAuthType(event);
+			if (context.authType !== "ADMIN") {
+				context.auth = _makeAuth(event, context.authType);
+			} else {
+				delete context.auth;
+			}
+		}
+		if (triggerResource() == null) {
+			Object.defineProperty(context, "params", { get: () => {
+				throw new Error("context.params is not available when using the handler namespace.");
+			} });
+		} else {
+			context.params = context.params || _makeParams(context, triggerResource);
+		}
+		let promise;
+		if (labels && labels["deployment-scheduled"]) {
+			promise = contextOnlyHandler(context);
+		} else {
+			const dataOrChange = dataConstructor(event);
+			promise = handler(dataOrChange, context);
+		}
+		if (typeof promise === "undefined") {
+			warn("Function returned undefined, expected Promise or value");
+		}
+		return Promise.resolve(promise);
+	};
+	Object.defineProperty(cloudFunction, "__trigger", { get: () => {
+		if (triggerResource() == null) {
+			return {};
+		}
+		const trigger = {
+			...optionsToTrigger(options),
+			eventTrigger: {
+				resource: triggerResource(),
+				eventType: legacyEventType || provider + "." + eventType,
+				service
+			}
+		};
+		if (!!labels && Object.keys(labels).length) {
+			trigger.labels = {
+				...trigger.labels,
+				...labels
+			};
+		}
+		return trigger;
+	} });
+	Object.defineProperty(cloudFunction, "__endpoint", { get: () => {
+		if (triggerResource() == null) {
+			return undefined;
+		}
+		const endpoint = {
+			platform: "gcfv1",
+			...initV1Endpoint(options),
+			...optionsToEndpoint(options)
+		};
+		if (options.schedule) {
+			endpoint.scheduleTrigger = initV1ScheduleTrigger(options.schedule.schedule, options);
+			copyIfPresent(endpoint.scheduleTrigger, options.schedule, "timeZone");
+			copyIfPresent(endpoint.scheduleTrigger.retryConfig, options.schedule.retryConfig, "retryCount", "maxDoublings", "maxBackoffDuration", "maxRetryDuration", "minBackoffDuration");
+		} else {
+			endpoint.eventTrigger = {
+				eventType: legacyEventType || provider + "." + eventType,
+				eventFilters: { resource: triggerResource() },
+				retry: !!options.failurePolicy
+			};
+		}
+		endpoint.labels = { ...endpoint.labels };
+		return endpoint;
+	} });
+	if (options.schedule) {
+		cloudFunction.__requiredAPIs = [{
+			api: "cloudscheduler.googleapis.com",
+			reason: "Needed for scheduled functions."
+		}];
+	}
+	cloudFunction.run = handler || contextOnlyHandler;
+	return cloudFunction;
+}
+function _makeParams(context, triggerResourceGetter) {
+	if (context.params) {
+		return context.params;
+	}
+	if (!context.resource) {
+		return {};
+	}
+	const triggerResource = triggerResourceGetter();
+	const wildcards = triggerResource.match(WILDCARD_REGEX);
+	const params = {};
+	const eventResourceParts = context?.resource?.name?.split?.("/");
+	if (wildcards && eventResourceParts) {
+		const triggerResourceParts = triggerResource.split("/");
+		for (const wildcard of wildcards) {
+			const wildcardNoBraces = wildcard.slice(1, -1);
+			const position = triggerResourceParts.indexOf(wildcard);
+			params[wildcardNoBraces] = eventResourceParts[position];
+		}
+	}
+	return params;
+}
+function _makeAuth(event, authType) {
+	if (authType === "UNAUTHENTICATED") {
+		return null;
+	}
+	return {
+		uid: event.context?.auth?.variable?.uid,
+		token: event.context?.auth?.variable?.token
+	};
+}
+function _detectAuthType(event) {
+	if (event.context?.auth?.admin) {
+		return "ADMIN";
+	}
+	if (event.context?.auth?.variable) {
+		return "USER";
+	}
+	return "UNAUTHENTICATED";
+}
+/** @hidden */
+function optionsToTrigger(options) {
+	const trigger = {};
+	copyIfPresent(trigger, options, "regions", "schedule", "minInstances", "maxInstances", "ingressSettings", "vpcConnectorEgressSettings", "vpcConnector", "labels", "secrets");
+	convertIfPresent(trigger, options, "failurePolicy", "failurePolicy", (policy) => {
+		if (policy === false) {
+			return undefined;
+		} else if (policy === true) {
+			return DEFAULT_FAILURE_POLICY;
+		} else {
+			return policy;
+		}
+	});
+	convertIfPresent(trigger, options, "timeout", "timeoutSeconds", durationFromSeconds);
+	convertIfPresent(trigger, options, "availableMemoryMb", "memory", (mem) => {
+		const memoryLookup = {
+			"128MB": 128,
+			"256MB": 256,
+			"512MB": 512,
+			"1GB": 1024,
+			"2GB": 2048,
+			"4GB": 4096,
+			"8GB": 8192
+		};
+		return memoryLookup[mem];
+	});
+	convertIfPresent(trigger, options, "serviceAccountEmail", "serviceAccount", serviceAccountFromShorthand);
+	return trigger;
+}
+function optionsToEndpoint(options) {
+	const endpoint = {};
+	copyIfPresent(endpoint, options, "omit", "minInstances", "maxInstances", "ingressSettings", "labels", "timeoutSeconds");
+	convertIfPresent(endpoint, options, "region", "regions");
+	convertIfPresent(endpoint, options, "serviceAccountEmail", "serviceAccount", (sa) => sa);
+	convertIfPresent(endpoint, options, "secretEnvironmentVariables", "secrets", (secrets) => secrets.map((secret) => ({ key: secret instanceof SecretParam ? secret.name : secret })));
+	if (options?.vpcConnector !== undefined) {
+		if (options.vpcConnector === null || options.vpcConnector instanceof ResetValue) {
+			endpoint.vpc = RESET_VALUE;
+		} else {
+			const vpc = { connector: options.vpcConnector };
+			convertIfPresent(vpc, options, "egressSettings", "vpcConnectorEgressSettings");
+			endpoint.vpc = vpc;
+		}
+	}
+	convertIfPresent(endpoint, options, "availableMemoryMb", "memory", (mem) => {
+		const memoryLookup = {
+			"128MB": 128,
+			"256MB": 256,
+			"512MB": 512,
+			"1GB": 1024,
+			"2GB": 2048,
+			"4GB": 4096,
+			"8GB": 8192
+		};
+		return typeof mem === "object" ? mem : memoryLookup[mem];
+	});
+	return endpoint;
+}
+
+//#endregion
+export { Change, makeCloudFunction, optionsToEndpoint, optionsToTrigger };

package/lib/esm/v1/config.mjs

@@ -0,0 +1,14 @@
+import { firebaseConfig } from "../common/config.mjs";
+
+//#region src/v1/config.ts
+/**
+* @deprecated `functions.config()` has been removed in firebase-functions v7.
+* Migrate to environment parameters using the `params` module immediately.
+* Migration guide: https://firebase.google.com/docs/functions/config-env#migrate-config
+*/
+const config = (() => {
+	throw new Error("functions.config() has been removed in firebase-functions v7. " + "Migrate to environment parameters using the params module. " + "Migration guide: https://firebase.google.com/docs/functions/config-env#migrate-config");
+});
+
+//#endregion
+export { config, firebaseConfig };

package/lib/esm/v1/function-builder.mjs

@@ -0,0 +1,252 @@
+import { Expression, SecretParam } from "../params/types.mjs";
+import { ResetValue } from "../common/options.mjs";
+import { INGRESS_SETTINGS_OPTIONS, MAX_NUMBER_USER_LABELS, MAX_TIMEOUT_SECONDS, VALID_MEMORY_OPTIONS, VPC_EGRESS_SETTINGS_OPTIONS } from "./function-configuration.mjs";
+import { _eventWithOptions } from "./providers/analytics.mjs";
+import { _userWithOptions } from "./providers/auth.mjs";
+import { _instanceWithOptions, _refWithOptions } from "./providers/database.mjs";
+import { _databaseWithOptions, _documentWithOptions, _namespaceWithOptions } from "./providers/firestore.mjs";
+import { _onCallWithOptions, _onRequestWithOptions } from "./providers/https.mjs";
+import { _scheduleWithOptions, _topicWithOptions } from "./providers/pubsub.mjs";
+import { _onUpdateWithOptions } from "./providers/remoteConfig.mjs";
+import { _bucketWithOptions, _objectWithOptions } from "./providers/storage.mjs";
+import { TaskQueueBuilder } from "./providers/tasks.mjs";
+import { _testMatrixWithOpts } from "./providers/testLab.mjs";
+
+//#region src/v1/function-builder.ts
+/**
+* Assert that the runtime options passed in are valid.
+* @param runtimeOptions object containing memory and timeout information.
+* @throws { Error } Memory and TimeoutSeconds values must be valid.
+*/
+function assertRuntimeOptionsValid(runtimeOptions) {
+	const mem = runtimeOptions.memory;
+	if (mem && typeof mem !== "object" && !VALID_MEMORY_OPTIONS.includes(mem)) {
+		throw new Error(`The only valid memory allocation values are: ${VALID_MEMORY_OPTIONS.join(", ")}`);
+	}
+	if (typeof runtimeOptions.timeoutSeconds === "number" && (runtimeOptions.timeoutSeconds > MAX_TIMEOUT_SECONDS || runtimeOptions.timeoutSeconds < 0)) {
+		throw new Error(`TimeoutSeconds must be between 0 and ${MAX_TIMEOUT_SECONDS}`);
+	}
+	if (runtimeOptions.ingressSettings && !(runtimeOptions.ingressSettings instanceof ResetValue) && !INGRESS_SETTINGS_OPTIONS.includes(runtimeOptions.ingressSettings)) {
+		throw new Error(`The only valid ingressSettings values are: ${INGRESS_SETTINGS_OPTIONS.join(",")}`);
+	}
+	if (runtimeOptions.vpcConnectorEgressSettings && !(runtimeOptions.vpcConnectorEgressSettings instanceof ResetValue) && !VPC_EGRESS_SETTINGS_OPTIONS.includes(runtimeOptions.vpcConnectorEgressSettings)) {
+		throw new Error(`The only valid vpcConnectorEgressSettings values are: ${VPC_EGRESS_SETTINGS_OPTIONS.join(",")}`);
+	}
+	validateFailurePolicy(runtimeOptions.failurePolicy);
+	const serviceAccount = runtimeOptions.serviceAccount;
+	if (serviceAccount && !(serviceAccount === "default" || serviceAccount instanceof ResetValue || serviceAccount instanceof Expression || serviceAccount.includes("@"))) {
+		throw new Error(`serviceAccount must be set to 'default', a string expression, a service account email, or '{serviceAccountName}@'`);
+	}
+	if (runtimeOptions.labels) {
+		if (Object.keys(runtimeOptions.labels).length > MAX_NUMBER_USER_LABELS) {
+			throw new Error(`A function must not have more than ${MAX_NUMBER_USER_LABELS} user-defined labels.`);
+		}
+		const reservedKeys = Object.keys(runtimeOptions.labels).filter((key) => key.startsWith("deployment") || key.startsWith("firebase"));
+		if (reservedKeys.length) {
+			throw new Error(`Invalid labels: ${reservedKeys.join(", ")}. Labels may not start with reserved names 'deployment' or 'firebase'`);
+		}
+		const invalidLengthKeys = Object.keys(runtimeOptions.labels).filter((key) => key.length < 1 || key.length > 63);
+		if (invalidLengthKeys.length > 0) {
+			throw new Error(`Invalid labels: ${invalidLengthKeys.join(", ")}. Label keys must be between 1 and 63 characters in length.`);
+		}
+		const invalidLengthValues = Object.values(runtimeOptions.labels).filter((value) => value.length > 63);
+		if (invalidLengthValues.length > 0) {
+			throw new Error(`Invalid labels: ${invalidLengthValues.join(", ")}. Label values must be less than 64 charcters.`);
+		}
+		const validKeyPattern = /^[\p{Ll}\p{Lo}][\p{Ll}\p{Lo}\p{N}_-]{0,62}$/u;
+		const invalidKeys = Object.keys(runtimeOptions.labels).filter((key) => !validKeyPattern.test(key));
+		if (invalidKeys.length > 0) {
+			throw new Error(`Invalid labels: ${invalidKeys.join(", ")}. Label keys can only contain lowercase letters, international characters, numbers, _ or -, and must start with a letter.`);
+		}
+		const validValuePattern = /^[\p{Ll}\p{Lo}\p{N}_-]{0,63}$/u;
+		const invalidValues = Object.values(runtimeOptions.labels).filter((value) => !validValuePattern.test(value));
+		if (invalidValues.length > 0) {
+			throw new Error(`Invalid labels: ${invalidValues.join(", ")}. Label values can only contain lowercase letters, international characters, numbers, _ or -.`);
+		}
+	}
+	if (typeof runtimeOptions.invoker === "string" && runtimeOptions.invoker.length === 0) {
+		throw new Error("Invalid service account for function invoker, must be a non-empty string");
+	}
+	if (runtimeOptions.invoker !== undefined && Array.isArray(runtimeOptions.invoker)) {
+		if (runtimeOptions.invoker.length === 0) {
+			throw new Error("Invalid invoker array, must contain at least 1 service account entry");
+		}
+		for (const serviceAccount$1 of runtimeOptions.invoker) {
+			if (serviceAccount$1.length === 0) {
+				throw new Error("Invalid invoker array, a service account must be a non-empty string");
+			}
+			if (serviceAccount$1 === "public") {
+				throw new Error("Invalid invoker array, a service account cannot be set to the 'public' identifier");
+			}
+			if (serviceAccount$1 === "private") {
+				throw new Error("Invalid invoker array, a service account cannot be set to the 'private' identifier");
+			}
+		}
+	}
+	if (runtimeOptions.secrets !== undefined) {
+		const invalidSecrets = runtimeOptions.secrets.filter((s) => !/^[A-Za-z\d\-_]+$/.test(s instanceof SecretParam ? s.name : s));
+		if (invalidSecrets.length > 0) {
+			throw new Error(`Invalid secrets: ${invalidSecrets.join(",")}. ` + "Secret must be configured using the resource id (e.g. API_KEY)");
+		}
+	}
+	if ("allowInvalidAppCheckToken" in runtimeOptions) {
+		throw new Error("runWith option \"allowInvalidAppCheckToken\" has been inverted and " + "renamed \"enforceAppCheck\"");
+	}
+	return true;
+}
+function validateFailurePolicy(policy) {
+	if (typeof policy === "boolean" || typeof policy === "undefined") {
+		return;
+	}
+	if (typeof policy !== "object") {
+		throw new Error(`failurePolicy must be a boolean or an object.`);
+	}
+	const retry = policy.retry;
+	if (typeof retry !== "object" || Object.keys(retry).length) {
+		throw new Error("failurePolicy.retry must be an empty object.");
+	}
+}
+/**
+* Assert regions specified are valid.
+* @param regions list of regions.
+* @throws { Error } Regions must be in list of supported regions.
+*/
+function assertRegionsAreValid(regions) {
+	if (!regions.length) {
+		throw new Error("You must specify at least one region");
+	}
+	return true;
+}
+/**
+* Configure the regions that the function is deployed to.
+* @param regions One of more region strings.
+* @example
+* functions.region('us-east1')
+* @example
+* functions.region('us-east1', 'us-central1')
+*/
+function region(...regions) {
+	if (assertRegionsAreValid(regions)) {
+		return new FunctionBuilder({ regions });
+	}
+}
+/**
+* Configure runtime options for the function.
+* @param runtimeOptions Object with optional fields:
+* 1. `memory`: amount of memory to allocate to the function, possible values
+*    are: '128MB', '256MB', '512MB', '1GB', '2GB', '4GB', and '8GB'.
+* 2. `timeoutSeconds`: timeout for the function in seconds, possible values are
+*    0 to 540.
+* 3. `failurePolicy`: failure policy of the function, with boolean `true` being
+*    equivalent to providing an empty retry object.
+* 4. `vpcConnector`: id of a VPC connector in same project and region.
+* 5. `vpcConnectorEgressSettings`: when a vpcConnector is set, control which
+*    egress traffic is sent through the vpcConnector.
+* 6. `serviceAccount`: Specific service account for the function.
+* 7. `ingressSettings`: ingress settings for the function, which control where a HTTPS
+*    function can be called from.
+*
+* Value must not be null.
+*/
+function runWith(runtimeOptions) {
+	if (assertRuntimeOptionsValid(runtimeOptions)) {
+		return new FunctionBuilder(runtimeOptions);
+	}
+}
+var FunctionBuilder = class {
+	constructor(options) {
+		this.options = options;
+	}
+	/**
+	* Configure the regions that the function is deployed to.
+	* @param regions One or more region strings.
+	* @example
+	* functions.region('us-east1')
+	* @example
+	* functions.region('us-east1', 'us-central1')
+	*/
+	region(...regions) {
+		if (assertRegionsAreValid(regions)) {
+			this.options.regions = regions;
+			return this;
+		}
+	}
+	/**
+	* Configure runtime options for the function.
+	* @param runtimeOptions Object with optional fields:
+	* 1. `memory`: amount of memory to allocate to the function, possible values
+	*    are: '128MB', '256MB', '512MB', '1GB', '2GB', '4GB', and '8GB'.
+	* 2. `timeoutSeconds`: timeout for the function in seconds, possible values are
+	*    0 to 540.
+	* 3. `failurePolicy`: failure policy of the function, with boolean `true` being
+	*    equivalent to providing an empty retry object.
+	* 4. `vpcConnector`: id of a VPC connector in the same project and region
+	* 5. `vpcConnectorEgressSettings`: when a `vpcConnector` is set, control which
+	*    egress traffic is sent through the `vpcConnector`.
+	*
+	* Value must not be null.
+	*/
+	runWith(runtimeOptions) {
+		if (assertRuntimeOptionsValid(runtimeOptions)) {
+			this.options = {
+				...this.options,
+				...runtimeOptions
+			};
+			return this;
+		}
+	}
+	get https() {
+		if (this.options.failurePolicy !== undefined) {
+			console.warn("RuntimeOptions.failurePolicy is not supported in https functions.");
+		}
+		return {
+			onRequest: (handler) => _onRequestWithOptions(handler, this.options),
+			onCall: (handler) => _onCallWithOptions(handler, this.options)
+		};
+	}
+	get tasks() {
+		return { taskQueue: (options) => {
+			return new TaskQueueBuilder(options, this.options);
+		} };
+	}
+	get database() {
+		return {
+			instance: (instance) => _instanceWithOptions(instance, this.options),
+			ref: (path) => _refWithOptions(path, this.options)
+		};
+	}
+	get firestore() {
+		return {
+			document: (path) => _documentWithOptions(path, this.options),
+			namespace: (namespace) => _namespaceWithOptions(namespace, this.options),
+			database: (database) => _databaseWithOptions(database, this.options)
+		};
+	}
+	get analytics() {
+		return { event: (analyticsEventType) => _eventWithOptions(analyticsEventType, this.options) };
+	}
+	get remoteConfig() {
+		return { onUpdate: (handler) => _onUpdateWithOptions(handler, this.options) };
+	}
+	get storage() {
+		return {
+			bucket: (bucket) => _bucketWithOptions(this.options, bucket),
+			object: () => _objectWithOptions(this.options)
+		};
+	}
+	get pubsub() {
+		return {
+			topic: (topic) => _topicWithOptions(topic, this.options),
+			schedule: (schedule) => _scheduleWithOptions(schedule, this.options)
+		};
+	}
+	get auth() {
+		return { user: (userOptions) => _userWithOptions(this.options, userOptions) };
+	}
+	get testLab() {
+		return { testMatrix: () => _testMatrixWithOpts(this.options) };
+	}
+};
+
+//#endregion
+export { FunctionBuilder, region, runWith };

package/lib/esm/v1/function-configuration.mjs

@@ -0,0 +1,72 @@
+import { RESET_VALUE } from "../common/options.mjs";
+
+//#region src/v1/function-configuration.ts
+/**
+* List of all regions supported by Cloud Functions.
+*/
+const SUPPORTED_REGIONS = [
+	"us-central1",
+	"us-east1",
+	"us-east4",
+	"us-west2",
+	"us-west3",
+	"us-west4",
+	"europe-central2",
+	"europe-west1",
+	"europe-west2",
+	"europe-west3",
+	"europe-west6",
+	"asia-east1",
+	"asia-east2",
+	"asia-northeast1",
+	"asia-northeast2",
+	"asia-northeast3",
+	"asia-south1",
+	"asia-southeast1",
+	"asia-southeast2",
+	"northamerica-northeast1",
+	"southamerica-east1",
+	"australia-southeast1"
+];
+/**
+* Cloud Functions min timeout value.
+*/
+const MIN_TIMEOUT_SECONDS = 0;
+/**
+* Cloud Functions max timeout value.
+*/
+const MAX_TIMEOUT_SECONDS = 540;
+/**
+* List of available memory options supported by Cloud Functions.
+*/
+const VALID_MEMORY_OPTIONS = [
+	"128MB",
+	"256MB",
+	"512MB",
+	"1GB",
+	"2GB",
+	"4GB",
+	"8GB"
+];
+/**
+* List of available options for VpcConnectorEgressSettings.
+*/
+const VPC_EGRESS_SETTINGS_OPTIONS = [
+	"VPC_CONNECTOR_EGRESS_SETTINGS_UNSPECIFIED",
+	"PRIVATE_RANGES_ONLY",
+	"ALL_TRAFFIC"
+];
+/**
+* List of available options for IngressSettings.
+*/
+const INGRESS_SETTINGS_OPTIONS = [
+	"INGRESS_SETTINGS_UNSPECIFIED",
+	"ALLOW_ALL",
+	"ALLOW_INTERNAL_ONLY",
+	"ALLOW_INTERNAL_AND_GCLB"
+];
+const DEFAULT_FAILURE_POLICY = { retry: {} };
+const MAX_NUMBER_USER_LABELS = 58;
+
+//#endregion
+export { DEFAULT_FAILURE_POLICY, INGRESS_SETTINGS_OPTIONS, MAX_NUMBER_USER_LABELS, MAX_TIMEOUT_SECONDS, MIN_TIMEOUT_SECONDS, RESET_VALUE, SUPPORTED_REGIONS, VALID_MEMORY_OPTIONS, VPC_EGRESS_SETTINGS_OPTIONS };

package/lib/esm/v1/index.mjs

@@ -0,0 +1,27 @@
+import { logger_exports } from "../logger/index.mjs";
+import { params_exports } from "../params/index.mjs";
+import { RESET_VALUE } from "../common/options.mjs";
+import { firebaseConfig } from "../common/config.mjs";
+import { setApp } from "../common/app.mjs";
+import { Change } from "../common/change.mjs";
+import { onInit } from "../common/onInit.mjs";
+import { DEFAULT_FAILURE_POLICY, INGRESS_SETTINGS_OPTIONS, MAX_NUMBER_USER_LABELS, MAX_TIMEOUT_SECONDS, MIN_TIMEOUT_SECONDS, SUPPORTED_REGIONS, VALID_MEMORY_OPTIONS, VPC_EGRESS_SETTINGS_OPTIONS } from "./function-configuration.mjs";
+import { makeCloudFunction, optionsToEndpoint, optionsToTrigger } from "./cloud-functions.mjs";
+import { config } from "./config.mjs";
+import { analytics_exports } from "./providers/analytics.mjs";
+import { auth_exports } from "./providers/auth.mjs";
+import { database_exports } from "./providers/database.mjs";
+import { firestore_exports } from "./providers/firestore.mjs";
+import { https_exports } from "./providers/https.mjs";
+import { pubsub_exports } from "./providers/pubsub.mjs";
+import { remoteConfig_exports } from "./providers/remoteConfig.mjs";
+import { storage_exports } from "./providers/storage.mjs";
+import { tasks_exports } from "./providers/tasks.mjs";
+import { testLab_exports } from "./providers/testLab.mjs";
+import { FunctionBuilder, region, runWith } from "./function-builder.mjs";
+
+//#region src/v1/index.ts
+const app = { setEmulatedAdminApp: setApp };
+
+//#endregion
+export { Change, DEFAULT_FAILURE_POLICY, FunctionBuilder, INGRESS_SETTINGS_OPTIONS, MAX_NUMBER_USER_LABELS, MAX_TIMEOUT_SECONDS, MIN_TIMEOUT_SECONDS, RESET_VALUE, SUPPORTED_REGIONS, VALID_MEMORY_OPTIONS, VPC_EGRESS_SETTINGS_OPTIONS, analytics_exports as analytics, app, auth_exports as auth, config, database_exports as database, firebaseConfig, firestore_exports as firestore, https_exports as https, logger_exports as logger, makeCloudFunction, onInit, optionsToEndpoint, optionsToTrigger, params_exports as params, pubsub_exports as pubsub, region, remoteConfig_exports as remoteConfig, runWith, storage_exports as storage, tasks_exports as tasks, testLab_exports as testLab };