firebase-functions 6.5.0 → 7.0.0-rc.0

package/lib/esm/v2/providers/database.mjs

@@ -0,0 +1,197 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { initV2Endpoint } from "../../runtime/manifest.mjs";
+import { getApp } from "../../common/app.mjs";
+import { withInit } from "../../common/onInit.mjs";
+import { normalizePath } from "../../common/utilities/path.mjs";
+import { DataSnapshot } from "../../common/providers/database.mjs";
+import { applyChange } from "../../common/utilities/utils.mjs";
+import { wrapTraceContext } from "../trace.mjs";
+import { getGlobalOptions, optionsToEndpoint } from "../options.mjs";
+import { PathPattern } from "../../common/utilities/path-pattern.mjs";
+
+//#region src/v2/providers/database.ts
+var database_exports = /* @__PURE__ */ __export({
+	DataSnapshot: () => DataSnapshot,
+	createdEventType: () => createdEventType,
+	deletedEventType: () => deletedEventType,
+	getOpts: () => getOpts,
+	makeEndpoint: () => makeEndpoint,
+	makeParams: () => makeParams,
+	onChangedOperation: () => onChangedOperation,
+	onOperation: () => onOperation,
+	onValueCreated: () => onValueCreated,
+	onValueDeleted: () => onValueDeleted,
+	onValueUpdated: () => onValueUpdated,
+	onValueWritten: () => onValueWritten,
+	updatedEventType: () => updatedEventType,
+	writtenEventType: () => writtenEventType
+});
+/** @internal */
+const writtenEventType = "google.firebase.database.ref.v1.written";
+/** @internal */
+const createdEventType = "google.firebase.database.ref.v1.created";
+/** @internal */
+const updatedEventType = "google.firebase.database.ref.v1.updated";
+/** @internal */
+const deletedEventType = "google.firebase.database.ref.v1.deleted";
+/**
+* Event handler which triggers when data is created, updated, or deleted in Realtime Database.
+*
+* @param referenceOrOpts - Options or a string reference.
+* @param handler - Event handler which is run every time a Realtime Database create, update, or delete occurs.
+*/
+function onValueWritten(referenceOrOpts, handler) {
+	return onChangedOperation(writtenEventType, referenceOrOpts, handler);
+}
+/**
+* Event handler which triggers when data is created in Realtime Database.
+*
+* @param referenceOrOpts - Options or a string reference.
+* @param handler - Event handler which is run every time a Realtime Database create occurs.
+*/
+function onValueCreated(referenceOrOpts, handler) {
+	return onOperation(createdEventType, referenceOrOpts, handler);
+}
+/**
+* Event handler which triggers when data is updated in Realtime Database.
+*
+* @param referenceOrOpts - Options or a string reference.
+* @param handler - Event handler which is run every time a Realtime Database update occurs.
+*/
+function onValueUpdated(referenceOrOpts, handler) {
+	return onChangedOperation(updatedEventType, referenceOrOpts, handler);
+}
+/**
+* Event handler which triggers when data is deleted in Realtime Database.
+*
+* @param referenceOrOpts - Options or a string reference.
+* @param handler - Event handler which is run every time a Realtime Database deletion occurs.
+*/
+function onValueDeleted(referenceOrOpts, handler) {
+	return onOperation(deletedEventType, referenceOrOpts, handler);
+}
+/** @internal */
+function getOpts(referenceOrOpts) {
+	let path;
+	let instance;
+	let opts;
+	if (typeof referenceOrOpts === "string") {
+		path = normalizePath(referenceOrOpts);
+		instance = "*";
+		opts = {};
+	} else {
+		path = normalizePath(referenceOrOpts.ref);
+		instance = referenceOrOpts.instance || "*";
+		opts = { ...referenceOrOpts };
+		delete opts.ref;
+		delete opts.instance;
+	}
+	return {
+		path,
+		instance,
+		opts
+	};
+}
+/** @internal */
+function makeParams(event, path, instance) {
+	return {
+		...path.extractMatches(event.ref),
+		...instance.extractMatches(event.instance)
+	};
+}
+/** @hidden */
+function makeDatabaseEvent(event, data, instance, params) {
+	const snapshot = new DataSnapshot(data, event.ref, getApp(), instance);
+	const databaseEvent = {
+		...event,
+		firebaseDatabaseHost: event.firebasedatabasehost,
+		data: snapshot,
+		params
+	};
+	delete databaseEvent.firebasedatabasehost;
+	return databaseEvent;
+}
+/** @hidden */
+function makeChangedDatabaseEvent(event, instance, params) {
+	const before = new DataSnapshot(event.data.data, event.ref, getApp(), instance);
+	const after = new DataSnapshot(applyChange(event.data.data, event.data.delta), event.ref, getApp(), instance);
+	const databaseEvent = {
+		...event,
+		firebaseDatabaseHost: event.firebasedatabasehost,
+		data: {
+			before,
+			after
+		},
+		params
+	};
+	delete databaseEvent.firebasedatabasehost;
+	return databaseEvent;
+}
+/** @internal */
+function makeEndpoint(eventType, opts, path, instance) {
+	const baseOpts = optionsToEndpoint(getGlobalOptions());
+	const specificOpts = optionsToEndpoint(opts);
+	const eventFilters = {};
+	const eventFilterPathPatterns = { ref: path.getValue() };
+	if (instance.hasWildcards()) {
+		eventFilterPathPatterns.instance = instance.getValue();
+	} else {
+		eventFilters.instance = instance.getValue();
+	}
+	return {
+		...initV2Endpoint(getGlobalOptions(), opts),
+		platform: "gcfv2",
+		...baseOpts,
+		...specificOpts,
+		labels: {
+			...baseOpts?.labels,
+			...specificOpts?.labels
+		},
+		eventTrigger: {
+			eventType,
+			eventFilters,
+			eventFilterPathPatterns,
+			retry: opts.retry ?? false
+		}
+	};
+}
+/** @internal */
+function onChangedOperation(eventType, referenceOrOpts, handler) {
+	const { path, instance, opts } = getOpts(referenceOrOpts);
+	const pathPattern = new PathPattern(path);
+	const instancePattern = new PathPattern(instance);
+	const func = (raw) => {
+		const event = raw;
+		const instanceUrl = getInstance(event);
+		const params = makeParams(event, pathPattern, instancePattern);
+		const databaseEvent = makeChangedDatabaseEvent(event, instanceUrl, params);
+		return wrapTraceContext(withInit(handler))(databaseEvent);
+	};
+	func.run = handler;
+	func.__endpoint = makeEndpoint(eventType, opts, pathPattern, instancePattern);
+	return func;
+}
+/** @internal */
+function onOperation(eventType, referenceOrOpts, handler) {
+	const { path, instance, opts } = getOpts(referenceOrOpts);
+	const pathPattern = new PathPattern(path);
+	const instancePattern = new PathPattern(instance);
+	const func = (raw) => {
+		const event = raw;
+		const instanceUrl = getInstance(event);
+		const params = makeParams(event, pathPattern, instancePattern);
+		const data = eventType === deletedEventType ? event.data.data : event.data.delta;
+		const databaseEvent = makeDatabaseEvent(event, data, instanceUrl, params);
+		return wrapTraceContext(withInit(handler))(databaseEvent);
+	};
+	func.run = handler;
+	func.__endpoint = makeEndpoint(eventType, opts, pathPattern, instancePattern);
+	return func;
+}
+function getInstance(event) {
+	const emuHost = process.env.FIREBASE_DATABASE_EMULATOR_HOST;
+	return emuHost ? `http://${emuHost}/?ns=${event.instance}` : `https://${event.instance}.${event.firebasedatabasehost}`;
+}
+
+//#endregion
+export { DataSnapshot, createdEventType, database_exports, deletedEventType, getOpts, makeEndpoint, makeParams, onChangedOperation, onOperation, onValueCreated, onValueDeleted, onValueUpdated, onValueWritten, updatedEventType, writtenEventType };

package/lib/esm/v2/providers/dataconnect.mjs

@@ -0,0 +1,130 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { initV2Endpoint } from "../../runtime/manifest.mjs";
+import { withInit } from "../../common/onInit.mjs";
+import { normalizePath } from "../../common/utilities/path.mjs";
+import { wrapTraceContext } from "../trace.mjs";
+import { getGlobalOptions, optionsToEndpoint } from "../options.mjs";
+import { PathPattern } from "../../common/utilities/path-pattern.mjs";
+
+//#region src/v2/providers/dataconnect.ts
+var dataconnect_exports = /* @__PURE__ */ __export({
+	mutationExecutedEventType: () => mutationExecutedEventType,
+	onMutationExecuted: () => onMutationExecuted
+});
+/** @internal */
+const mutationExecutedEventType = "google.firebase.dataconnect.connector.v1.mutationExecuted";
+/**
+* Event handler that triggers when a mutation is executed in Firebase Data Connect.
+*
+* @param mutationOrOpts - Options or string mutation path.
+* @param handler - Event handler which is run every time a mutation is executed.
+*/
+function onMutationExecuted(mutationOrOpts, handler) {
+	return onOperation(mutationExecutedEventType, mutationOrOpts, handler);
+}
+function getOpts(mutationOrOpts) {
+	const operationRegex = new RegExp("services/([^/]+)/connectors/([^/]*)/operations/([^/]+)");
+	let service;
+	let connector;
+	let operation;
+	let opts;
+	if (typeof mutationOrOpts === "string") {
+		const path = normalizePath(mutationOrOpts);
+		const match = path.match(operationRegex);
+		if (!match) {
+			throw new Error(`Invalid operation path: ${path}`);
+		}
+		service = match[1];
+		connector = match[2];
+		operation = match[3];
+		opts = {};
+	} else {
+		service = mutationOrOpts.service;
+		connector = mutationOrOpts.connector;
+		operation = mutationOrOpts.operation;
+		opts = { ...mutationOrOpts };
+		delete opts.service;
+		delete opts.connector;
+		delete opts.operation;
+	}
+	return {
+		service,
+		connector,
+		operation,
+		opts
+	};
+}
+function makeEndpoint(eventType, opts, service, connector, operation) {
+	const baseOpts = optionsToEndpoint(getGlobalOptions());
+	const specificOpts = optionsToEndpoint(opts);
+	const eventFilters = {};
+	const eventFilterPathPatterns = {};
+	if (service) {
+		if (service.hasWildcards()) {
+			eventFilterPathPatterns.service = service.getValue();
+		} else {
+			eventFilters.service = service.getValue();
+		}
+	}
+	if (connector) {
+		if (connector.hasWildcards()) {
+			eventFilterPathPatterns.connector = connector.getValue();
+		} else {
+			eventFilters.connector = connector.getValue();
+		}
+	}
+	if (operation) {
+		if (operation.hasWildcards()) {
+			eventFilterPathPatterns.operation = operation.getValue();
+		} else {
+			eventFilters.operation = operation.getValue();
+		}
+	}
+	return {
+		...initV2Endpoint(getGlobalOptions(), opts),
+		platform: "gcfv2",
+		...baseOpts,
+		...specificOpts,
+		labels: {
+			...baseOpts?.labels,
+			...specificOpts?.labels
+		},
+		eventTrigger: {
+			eventType,
+			eventFilters,
+			eventFilterPathPatterns,
+			retry: opts.retry ?? false
+		}
+	};
+}
+function makeParams(event, service, connector, operation) {
+	return {
+		...service?.extractMatches(event.service),
+		...connector?.extractMatches(event.connector),
+		...operation?.extractMatches(event.operation)
+	};
+}
+function onOperation(eventType, mutationOrOpts, handler) {
+	const { service, connector, operation, opts } = getOpts(mutationOrOpts);
+	const servicePattern = service ? new PathPattern(service) : undefined;
+	const connectorPattern = connector ? new PathPattern(connector) : undefined;
+	const operationPattern = operation ? new PathPattern(operation) : undefined;
+	const func = (raw) => {
+		const event = raw;
+		const params = makeParams(event, servicePattern, connectorPattern, operationPattern);
+		const { authtype, authid, service: service$1, connector: connector$1, operation: operation$1,...rest } = event;
+		const dataConnectEvent = {
+			...rest,
+			authType: authtype,
+			authId: authid,
+			params
+		};
+		return wrapTraceContext(withInit(handler))(dataConnectEvent);
+	};
+	func.run = handler;
+	func.__endpoint = makeEndpoint(eventType, opts, servicePattern, connectorPattern, operationPattern);
+	return func;
+}
+
+//#endregion
+export { dataconnect_exports, mutationExecutedEventType, onMutationExecuted };

package/lib/esm/v2/providers/eventarc.mjs

@@ -0,0 +1,51 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { initV2Endpoint } from "../../runtime/manifest.mjs";
+import { convertIfPresent, copyIfPresent } from "../../common/encoding.mjs";
+import { withInit } from "../../common/onInit.mjs";
+import { wrapTraceContext } from "../trace.mjs";
+import { getGlobalOptions, optionsToEndpoint } from "../options.mjs";
+
+//#region src/v2/providers/eventarc.ts
+var eventarc_exports = /* @__PURE__ */ __export({ onCustomEventPublished: () => onCustomEventPublished });
+function onCustomEventPublished(eventTypeOrOpts, handler) {
+	let opts;
+	if (typeof eventTypeOrOpts === "string") {
+		opts = { eventType: eventTypeOrOpts };
+	} else if (typeof eventTypeOrOpts === "object") {
+		opts = eventTypeOrOpts;
+	}
+	const func = (raw) => {
+		return wrapTraceContext(withInit(handler))(raw);
+	};
+	func.run = handler;
+	const channel = opts.channel ?? "locations/us-central1/channels/firebase";
+	const baseOpts = optionsToEndpoint(getGlobalOptions());
+	const specificOpts = optionsToEndpoint(opts);
+	const endpoint = {
+		...initV2Endpoint(getGlobalOptions(), opts),
+		platform: "gcfv2",
+		...baseOpts,
+		...specificOpts,
+		labels: {
+			...baseOpts?.labels,
+			...specificOpts?.labels
+		},
+		eventTrigger: {
+			eventType: opts.eventType,
+			eventFilters: {},
+			retry: opts.retry ?? false,
+			channel
+		}
+	};
+	convertIfPresent(endpoint.eventTrigger, opts, "eventFilters", "filters");
+	copyIfPresent(endpoint.eventTrigger, opts, "retry");
+	func.__endpoint = endpoint;
+	func.__requiredAPIs = [{
+		api: "eventarcpublishing.googleapis.com",
+		reason: "Needed for custom event functions"
+	}];
+	return func;
+}
+
+//#endregion
+export { eventarc_exports, onCustomEventPublished };

package/lib/esm/v2/providers/firestore.mjs

@@ -0,0 +1,294 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { error } from "../../logger/index.mjs";
+import { initV2Endpoint } from "../../runtime/manifest.mjs";
+import { Change } from "../../common/change.mjs";
+import { withInit } from "../../common/onInit.mjs";
+import { normalizePath } from "../../common/utilities/path.mjs";
+import { createBeforeSnapshotFromJson, createBeforeSnapshotFromProtobuf, createSnapshotFromJson, createSnapshotFromProtobuf } from "../../common/providers/firestore.mjs";
+import { wrapTraceContext } from "../trace.mjs";
+import "../core.mjs";
+import { getGlobalOptions, optionsToEndpoint } from "../options.mjs";
+import { PathPattern } from "../../common/utilities/path-pattern.mjs";
+
+//#region src/v2/providers/firestore.ts
+var firestore_exports = /* @__PURE__ */ __export({
+	Change: () => Change,
+	createBeforeSnapshot: () => createBeforeSnapshot,
+	createSnapshot: () => createSnapshot,
+	createdEventType: () => createdEventType,
+	createdEventWithAuthContextType: () => createdEventWithAuthContextType,
+	deletedEventType: () => deletedEventType,
+	deletedEventWithAuthContextType: () => deletedEventWithAuthContextType,
+	getOpts: () => getOpts,
+	makeChangedFirestoreEvent: () => makeChangedFirestoreEvent,
+	makeEndpoint: () => makeEndpoint,
+	makeFirestoreEvent: () => makeFirestoreEvent,
+	makeParams: () => makeParams,
+	onChangedOperation: () => onChangedOperation,
+	onDocumentCreated: () => onDocumentCreated,
+	onDocumentCreatedWithAuthContext: () => onDocumentCreatedWithAuthContext,
+	onDocumentDeleted: () => onDocumentDeleted,
+	onDocumentDeletedWithAuthContext: () => onDocumentDeletedWithAuthContext,
+	onDocumentUpdated: () => onDocumentUpdated,
+	onDocumentUpdatedWithAuthContext: () => onDocumentUpdatedWithAuthContext,
+	onDocumentWritten: () => onDocumentWritten,
+	onDocumentWrittenWithAuthContext: () => onDocumentWrittenWithAuthContext,
+	onOperation: () => onOperation,
+	updatedEventType: () => updatedEventType,
+	updatedEventWithAuthContextType: () => updatedEventWithAuthContextType,
+	writtenEventType: () => writtenEventType,
+	writtenEventWithAuthContextType: () => writtenEventWithAuthContextType
+});
+/** @internal */
+const writtenEventType = "google.cloud.firestore.document.v1.written";
+/** @internal */
+const createdEventType = "google.cloud.firestore.document.v1.created";
+/** @internal */
+const updatedEventType = "google.cloud.firestore.document.v1.updated";
+/** @internal */
+const deletedEventType = "google.cloud.firestore.document.v1.deleted";
+/** @internal */
+const writtenEventWithAuthContextType = "google.cloud.firestore.document.v1.written.withAuthContext";
+/** @internal */
+const createdEventWithAuthContextType = "google.cloud.firestore.document.v1.created.withAuthContext";
+/** @internal */
+const updatedEventWithAuthContextType = "google.cloud.firestore.document.v1.updated.withAuthContext";
+/** @internal */
+const deletedEventWithAuthContextType = "google.cloud.firestore.document.v1.deleted.withAuthContext";
+/**
+* Event handler that triggers when a document is created, updated, or deleted in Firestore.
+*
+* @param documentOrOpts - Options or a string document path.
+* @param handler - Event handler which is run every time a Firestore create, update, or delete occurs.
+*/
+function onDocumentWritten(documentOrOpts, handler) {
+	return onChangedOperation(writtenEventType, documentOrOpts, handler);
+}
+/**
+* Event handler that triggers when a document is created, updated, or deleted in Firestore.
+* This trigger also provides the authentication context of the principal who triggered the event.
+*
+* @param opts - Options or a string document path.
+* @param handler - Event handler which is run every time a Firestore create, update, or delete occurs.
+*/
+function onDocumentWrittenWithAuthContext(documentOrOpts, handler) {
+	return onChangedOperation(writtenEventWithAuthContextType, documentOrOpts, handler);
+}
+/**
+* Event handler that triggers when a document is created in Firestore.
+*
+* @param documentOrOpts - Options or a string document path.
+* @param handler - Event handler which is run every time a Firestore create occurs.
+*/
+function onDocumentCreated(documentOrOpts, handler) {
+	return onOperation(createdEventType, documentOrOpts, handler);
+}
+/**
+* Event handler that triggers when a document is created in Firestore.
+*
+* @param documentOrOpts - Options or a string document path.
+* @param handler - Event handler which is run every time a Firestore create occurs.
+*/
+function onDocumentCreatedWithAuthContext(documentOrOpts, handler) {
+	return onOperation(createdEventWithAuthContextType, documentOrOpts, handler);
+}
+/**
+* Event handler that triggers when a document is updated in Firestore.
+*
+* @param documentOrOpts - Options or a string document path.
+* @param handler - Event handler which is run every time a Firestore update occurs.
+*/
+function onDocumentUpdated(documentOrOpts, handler) {
+	return onChangedOperation(updatedEventType, documentOrOpts, handler);
+}
+/**
+* Event handler that triggers when a document is updated in Firestore.
+*
+* @param documentOrOpts - Options or a string document path.
+* @param handler - Event handler which is run every time a Firestore update occurs.
+*/
+function onDocumentUpdatedWithAuthContext(documentOrOpts, handler) {
+	return onChangedOperation(updatedEventWithAuthContextType, documentOrOpts, handler);
+}
+/**
+* Event handler that triggers when a document is deleted in Firestore.
+*
+* @param documentOrOpts - Options or a string document path.
+* @param handler - Event handler which is run every time a Firestore delete occurs.
+*/
+function onDocumentDeleted(documentOrOpts, handler) {
+	return onOperation(deletedEventType, documentOrOpts, handler);
+}
+/**
+* Event handler that triggers when a document is deleted in Firestore.
+*
+* @param documentOrOpts - Options or a string document path.
+* @param handler - Event handler which is run every time a Firestore delete occurs.
+*/
+function onDocumentDeletedWithAuthContext(documentOrOpts, handler) {
+	return onOperation(deletedEventWithAuthContextType, documentOrOpts, handler);
+}
+/** @internal */
+function getOpts(documentOrOpts) {
+	let document;
+	let database;
+	let namespace;
+	let opts;
+	if (typeof documentOrOpts === "string") {
+		document = normalizePath(documentOrOpts);
+		database = "(default)";
+		namespace = "(default)";
+		opts = {};
+	} else {
+		document = typeof documentOrOpts.document === "string" ? normalizePath(documentOrOpts.document) : documentOrOpts.document;
+		database = documentOrOpts.database || "(default)";
+		namespace = documentOrOpts.namespace || "(default)";
+		opts = { ...documentOrOpts };
+		delete opts.document;
+		delete opts.database;
+		delete opts.namespace;
+	}
+	return {
+		document,
+		database,
+		namespace,
+		opts
+	};
+}
+/** @hidden */
+function getPath(event) {
+	return `projects/${event.project}/databases/${event.database}/documents/${event.document}`;
+}
+/** @internal */
+function createSnapshot(event) {
+	if (event.datacontenttype?.includes("application/protobuf") || Buffer.isBuffer(event.data)) {
+		return createSnapshotFromProtobuf(event.data, getPath(event), event.database);
+	} else if (event.datacontenttype?.includes("application/json")) {
+		return createSnapshotFromJson(event.data, event.source, event.data.value?.createTime, event.data.value?.updateTime, event.database);
+	} else {
+		error(`Cannot determine payload type, datacontenttype is ${event.datacontenttype}, failing out.`);
+		throw Error("Error: Cannot parse event payload.");
+	}
+}
+/** @internal */
+function createBeforeSnapshot(event) {
+	if (event.datacontenttype?.includes("application/protobuf") || Buffer.isBuffer(event.data)) {
+		return createBeforeSnapshotFromProtobuf(event.data, getPath(event), event.database);
+	} else if (event.datacontenttype?.includes("application/json")) {
+		return createBeforeSnapshotFromJson(event.data, event.source, event.data.oldValue?.createTime, event.data.oldValue?.updateTime, event.database);
+	} else {
+		error(`Cannot determine payload type, datacontenttype is ${event.datacontenttype}, failing out.`);
+		throw Error("Error: Cannot parse event payload.");
+	}
+}
+/** @internal */
+function makeParams(document, documentPattern) {
+	return { ...documentPattern.extractMatches(document) };
+}
+/** @internal */
+function makeFirestoreEvent(eventType, event, params) {
+	const data = event.data ? eventType === createdEventType || eventType === createdEventWithAuthContextType ? createSnapshot(event) : createBeforeSnapshot(event) : undefined;
+	const firestoreEvent = {
+		...event,
+		params,
+		data
+	};
+	delete firestoreEvent.datacontenttype;
+	delete firestoreEvent.dataschema;
+	if ("authtype" in event) {
+		const eventWithAuth = {
+			...firestoreEvent,
+			authType: event.authtype,
+			authId: event.authid
+		};
+		delete eventWithAuth.authtype;
+		delete eventWithAuth.authid;
+		return eventWithAuth;
+	}
+	return firestoreEvent;
+}
+/** @internal */
+function makeChangedFirestoreEvent(event, params) {
+	const data = event.data ? Change.fromObjects(createBeforeSnapshot(event), createSnapshot(event)) : undefined;
+	const firestoreEvent = {
+		...event,
+		params,
+		data
+	};
+	delete firestoreEvent.datacontenttype;
+	delete firestoreEvent.dataschema;
+	if ("authtype" in event) {
+		const eventWithAuth = {
+			...firestoreEvent,
+			authType: event.authtype,
+			authId: event.authid
+		};
+		delete eventWithAuth.authtype;
+		delete eventWithAuth.authid;
+		return eventWithAuth;
+	}
+	return firestoreEvent;
+}
+/** @internal */
+function makeEndpoint(eventType, opts, document, database, namespace) {
+	const baseOpts = optionsToEndpoint(getGlobalOptions());
+	const specificOpts = optionsToEndpoint(opts);
+	const eventFilters = {
+		database,
+		namespace
+	};
+	const eventFilterPathPatterns = {};
+	const maybePattern = typeof document === "string" ? new PathPattern(document).hasWildcards() : true;
+	if (maybePattern) {
+		eventFilterPathPatterns.document = document;
+	} else {
+		eventFilters.document = document;
+	}
+	return {
+		...initV2Endpoint(getGlobalOptions(), opts),
+		platform: "gcfv2",
+		...baseOpts,
+		...specificOpts,
+		labels: {
+			...baseOpts?.labels,
+			...specificOpts?.labels
+		},
+		eventTrigger: {
+			eventType,
+			eventFilters,
+			eventFilterPathPatterns,
+			retry: opts.retry ?? false
+		}
+	};
+}
+/** @internal */
+function onOperation(eventType, documentOrOpts, handler) {
+	const { document, database, namespace, opts } = getOpts(documentOrOpts);
+	const func = (raw) => {
+		const event = raw;
+		const documentPattern = new PathPattern(typeof document === "string" ? document : document.value());
+		const params = makeParams(event.document, documentPattern);
+		const firestoreEvent = makeFirestoreEvent(eventType, event, params);
+		return wrapTraceContext(withInit(handler))(firestoreEvent);
+	};
+	func.run = handler;
+	func.__endpoint = makeEndpoint(eventType, opts, document, database, namespace);
+	return func;
+}
+/** @internal */
+function onChangedOperation(eventType, documentOrOpts, handler) {
+	const { document, database, namespace, opts } = getOpts(documentOrOpts);
+	const func = (raw) => {
+		const event = raw;
+		const documentPattern = new PathPattern(typeof document === "string" ? document : document.value());
+		const params = makeParams(event.document, documentPattern);
+		const firestoreEvent = makeChangedFirestoreEvent(event, params);
+		return wrapTraceContext(withInit(handler))(firestoreEvent);
+	};
+	func.run = handler;
+	func.__endpoint = makeEndpoint(eventType, opts, document, database, namespace);
+	return func;
+}
+
+//#endregion
+export { Change, createBeforeSnapshot, createSnapshot, createdEventType, createdEventWithAuthContextType, deletedEventType, deletedEventWithAuthContextType, firestore_exports, getOpts, makeChangedFirestoreEvent, makeEndpoint, makeFirestoreEvent, makeParams, onChangedOperation, onDocumentCreated, onDocumentCreatedWithAuthContext, onDocumentDeleted, onDocumentDeletedWithAuthContext, onDocumentUpdated, onDocumentUpdatedWithAuthContext, onDocumentWritten, onDocumentWrittenWithAuthContext, onOperation, updatedEventType, updatedEventWithAuthContextType, writtenEventType, writtenEventWithAuthContextType };