@keystrokehq/snowflake 0.0.1

package/dist/triggers.mjs

@@ -0,0 +1,1363 @@
+import { c as snowflakeGcsPubSubWebhookCredentialSet, l as snowflakeS3SnsWebhookCredentialSet, n as snowflake, s as snowflakeAzureEventGridWebhookCredentialSet } from "./integration-Dptv8L0L.mjs";
+import { createSnowflakeClient } from "./client.mjs";
+import { azureEventGridEventSchema, gcsPubSubPushSchema, grantChangedEventSchema, pipeLoadEventSchema, scheduledDeltaEventSchema, scheduledSqlEventSchema, shareChangedEventSchema, snowflakeDiffSnapshotEntrySchema, snowflakeObjectLifecycleEventSchema, snsNotificationSchema, statementCompletedEventSchema, statusPageComponentChangeEventSchema, statusPageIncidentEventSchema, streamAppendOnlyEventSchema, streamHasDataEventSchema, taskRunEventSchema, warehouseCreditsEventSchema, warehouseQueueEventSchema } from "./events.mjs";
+import { executeSql } from "./sql.mjs";
+import { a as quoteLiteral, i as quoteIdentifier, t as buildFqn } from "./sql-safety-CywdR3EP.mjs";
+import { BindingBuilder } from "./rows.mjs";
+import { getStatusSummary, getUnresolvedIncidents } from "./status-page.mjs";
+import { EVENT_GRID_VALIDATION_EVENT_TYPE, SnowflakeWebhookVerificationError, extractGcsObjectPayload, extractS3Records, parseAzureBlobLocation, parsePubSubPush, verifyEventGridRequest, verifyPubSubPushAuthorization, verifySnsMessage } from "./verification.mjs";
+import { z } from "zod";
+import { createPollingTriggerBindingFactory, createWebhookTriggerBindingFactory } from "@keystrokehq/integration-authoring";
+
+//#region src/triggers.ts
+function defineSnowflakePollingTrigger(definition) {
+	return definition;
+}
+function splitBindingOptions(input) {
+	return {
+		schedule: input?.schedule,
+		bindOptions: {
+			...input?.name ? { name: input.name } : {},
+			...input?.description ? { description: input.description } : {},
+			...input?.filter ? { filter: input.filter } : {},
+			...input?.transform ? { transform: input.transform } : {}
+		}
+	};
+}
+function resolveSchedule(override, fallback) {
+	if (override === void 0) return fallback;
+	return override;
+}
+function createSnowflakePollingBindingFactory(definition, params, schedule) {
+	return createPollingTriggerBindingFactory({
+		defaultName: definition.defaultName,
+		defaultDescription: definition.defaultDescription,
+		schedule: resolveSchedule(schedule, definition.defaultSchedule),
+		credentialSets: [snowflake],
+		response: definition.responseSchema,
+		poll: (ctx) => {
+			const snowflakeCtx = ctx;
+			return definition.poll(params, snowflakeCtx.credentials.snowflake, snowflakeCtx);
+		},
+		idempotencyKey: (response) => definition.idempotencyKey(response),
+		definitionFilter: (response) => definition.hasPayload(response)
+	});
+}
+function bindSnowflakePollingTrigger(definition, params, input) {
+	const { schedule, bindOptions } = splitBindingOptions(input);
+	return createSnowflakePollingBindingFactory(definition, params, schedule)(bindOptions);
+}
+function isoNow() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+function readStringField(row, ...keys) {
+	for (const key of keys) {
+		const value = row[key];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+}
+function readNumberField(row, ...keys) {
+	for (const key of keys) {
+		const value = row[key];
+		if (typeof value === "number" && Number.isFinite(value)) return value;
+		if (typeof value === "string" && value.length > 0) {
+			const parsed = Number(value);
+			if (Number.isFinite(parsed)) return parsed;
+		}
+	}
+}
+function hashStatement(statement) {
+	let hash = 0;
+	for (let i = 0; i < statement.length; i += 1) hash = (hash << 5) - hash + statement.charCodeAt(i) | 0;
+	return `sha-${(hash >>> 0).toString(16)}-${statement.length}`;
+}
+const streamHasNewRowsDefinition = defineSnowflakePollingTrigger({
+	responseSchema: streamHasDataEventSchema,
+	defaultName: "Snowflake Stream Has New Rows",
+	defaultDescription: "Fires when SYSTEM$STREAM_HAS_DATA returns TRUE for a Snowflake stream (fires at most once per schedule tick).",
+	defaultSchedule: "1m",
+	poll: async (params, credentials) => {
+		const client = createSnowflakeClient(credentials);
+		const fqn = buildFqn(params.database, params.schema, params.streamName);
+		const row = (await executeSql(client, {
+			statement: `SELECT SYSTEM$STREAM_HAS_DATA(${quoteLiteral(fqn)}) AS HAS_DATA`,
+			warehouse: params.warehouse,
+			role: params.role
+		})).rows[0] ?? {};
+		const raw = row.HAS_DATA ?? row.has_data;
+		let hasData;
+		if (typeof raw === "boolean") hasData = raw;
+		else if (typeof raw === "string") hasData = raw.toLowerCase() === "true";
+		else hasData = Boolean(raw);
+		return {
+			streamName: fqn,
+			hasData,
+			checkedAt: isoNow()
+		};
+	},
+	idempotencyKey: (response) => `${response.streamName}:${response.checkedAt}`,
+	hasPayload: (response) => response.hasData
+});
+function streamHasNewRows(input) {
+	return bindSnowflakePollingTrigger(streamHasNewRowsDefinition, input, input);
+}
+const streamAppendOnlyDefinition = defineSnowflakePollingTrigger({
+	responseSchema: streamAppendOnlyEventSchema,
+	defaultName: "Snowflake Stream Append-Only",
+	defaultDescription: "Emits new inserted rows from a Snowflake stream on each poll. Consumers must progress the stream via downstream DML in a transaction.",
+	defaultSchedule: "1m",
+	poll: async (params, credentials) => {
+		const client = createSnowflakeClient(credentials);
+		const fqn = buildFqn(params.database, params.schema, params.streamName);
+		const limit = params.limit ?? 1e3;
+		const result = await executeSql(client, {
+			statement: `SELECT * FROM ${fqn} WHERE ${`METADATA$ACTION = 'INSERT'${params.where ? ` AND (${params.where})` : ""}`} LIMIT ${Number(limit)}`,
+			warehouse: params.warehouse,
+			role: params.role
+		});
+		const rows = result.rows;
+		return {
+			streamName: fqn,
+			rows: [...rows],
+			columns: [...result.columns],
+			rowCount: rows.length,
+			fetchedAt: isoNow()
+		};
+	},
+	idempotencyKey: (response) => `${response.streamName}:${response.fetchedAt}:${response.rowCount}`,
+	hasPayload: (response) => response.rowCount > 0
+});
+function streamAppendOnly(input) {
+	return bindSnowflakePollingTrigger(streamAppendOnlyDefinition, input, input);
+}
+const scheduledSqlDefinition = defineSnowflakePollingTrigger({
+	responseSchema: scheduledSqlEventSchema,
+	defaultName: "Snowflake Scheduled SQL",
+	defaultDescription: "Runs a caller-supplied SQL statement on each schedule tick and emits the full result set.",
+	defaultSchedule: "5m",
+	poll: async (params, credentials) => {
+		const client = createSnowflakeClient(credentials);
+		let bindings;
+		if (params.bindings && params.bindings.length > 0) {
+			const builder = new BindingBuilder();
+			for (const value of params.bindings) builder.add(value);
+			bindings = { ...builder.toRecord() };
+		}
+		const result = await executeSql(client, {
+			statement: params.statement,
+			warehouse: params.warehouse,
+			role: params.role,
+			database: params.database,
+			schema: params.schema,
+			...bindings ? { bindings } : {}
+		});
+		const rows = result.rows;
+		return {
+			statementDigest: hashStatement(params.statement),
+			rows: [...rows],
+			columns: [...result.columns],
+			rowCount: rows.length,
+			fetchedAt: isoNow()
+		};
+	},
+	idempotencyKey: (response) => `${response.statementDigest}:${response.fetchedAt}`,
+	hasPayload: (response) => response.rowCount > 0
+});
+function scheduledSql(input) {
+	return bindSnowflakePollingTrigger(input.emitOnEmpty ? {
+		...scheduledSqlDefinition,
+		hasPayload: () => true
+	} : scheduledSqlDefinition, input, input);
+}
+function stringifyCursor(value) {
+	if (value === null || value === void 0) return null;
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return String(value);
+	if (value instanceof Date) return value.toISOString();
+	return String(value);
+}
+const scheduledDeltaDefinition = defineSnowflakePollingTrigger({
+	responseSchema: scheduledDeltaEventSchema,
+	defaultName: "Snowflake Scheduled Delta",
+	defaultDescription: "Emits new rows from a Snowflake table where a cursor column exceeds the last observed high-water mark.",
+	defaultSchedule: "1m",
+	poll: async (params, credentials, ctx) => {
+		const client = createSnowflakeClient(credentials);
+		const fqn = buildFqn(params.database, params.schema, params.table);
+		const cursor = quoteIdentifier(params.cursorColumn);
+		const limit = params.limit ?? 1e3;
+		const selectList = params.columns && params.columns.length > 0 ? params.columns.map((c) => quoteIdentifier(c)).join(", ") : "*";
+		const priorHighWater = ctx.lastResponse?.highWaterValue ?? (params.initialHighWater !== void 0 ? String(params.initialHighWater) : null);
+		const clauses = [];
+		let bindings;
+		if (priorHighWater !== null) {
+			clauses.push(`${cursor} > ?`);
+			bindings = { "1": {
+				type: "TEXT",
+				value: priorHighWater
+			} };
+		}
+		if (params.where) clauses.push(`(${params.where})`);
+		const result = await executeSql(client, {
+			statement: `SELECT ${selectList} FROM ${fqn}${clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : ""} ORDER BY ${cursor} ASC LIMIT ${Number(limit)}`,
+			warehouse: params.warehouse,
+			role: params.role,
+			...bindings ? { bindings } : {}
+		});
+		const rows = result.rows;
+		const latest = rows[rows.length - 1]?.[params.cursorColumn] ?? rows[rows.length - 1]?.[params.cursorColumn.toUpperCase()];
+		const nextHighWater = rows.length > 0 ? stringifyCursor(latest) : priorHighWater;
+		return {
+			table: fqn,
+			cursorColumn: params.cursorColumn,
+			highWaterValue: nextHighWater,
+			rows: [...rows],
+			columns: [...result.columns],
+			rowCount: rows.length,
+			fetchedAt: isoNow()
+		};
+	},
+	idempotencyKey: (response) => `${response.table}:${response.cursorColumn}:${response.highWaterValue ?? "initial"}`,
+	hasPayload: (response) => response.rowCount > 0
+});
+function scheduledDelta(input) {
+	return bindSnowflakePollingTrigger(scheduledDeltaDefinition, input, input);
+}
+const DEFAULT_TASK_STATES = [
+	"SUCCEEDED",
+	"FAILED",
+	"FAILED_AND_AUTO_SUSPENDED",
+	"CANCELLED"
+];
+const taskRunCompletedDefinition = defineSnowflakePollingTrigger({
+	responseSchema: z.object({
+		events: z.array(taskRunEventSchema),
+		highWaterValue: z.string().nullable(),
+		fetchedAt: z.string()
+	}).catchall(z.unknown()),
+	defaultName: "Snowflake Task Run Completed",
+	defaultDescription: "Emits terminal task runs polled from INFORMATION_SCHEMA.TASK_HISTORY (SUCCEEDED / FAILED / CANCELLED).",
+	defaultSchedule: "1m",
+	poll: async (params, credentials, ctx) => {
+		const client = createSnowflakeClient(credentials);
+		const limit = params.limit ?? 200;
+		const statesPredicate = (params.states ?? DEFAULT_TASK_STATES).map((s) => quoteLiteral(s)).join(", ");
+		const priorHighWater = ctx.lastResponse?.highWaterValue ?? null;
+		const lookbackMinutes = params.lookbackMinutes ?? 60;
+		const since = priorHighWater ?? (/* @__PURE__ */ new Date(Date.now() - lookbackMinutes * 6e4)).toISOString();
+		const taskFilter = params.taskName ? `, TASK_NAME => ${quoteLiteral(params.taskName)}` : "";
+		const rows = (await executeSql(client, {
+			statement: `SELECT * FROM TABLE(INFORMATION_SCHEMA.TASK_HISTORY(${`SCHEDULED_TIME_RANGE_START => TO_TIMESTAMP_LTZ(${quoteLiteral(since)})${taskFilter}, RESULT_LIMIT => ${Number(limit)}`})) WHERE STATE IN (${statesPredicate}) ORDER BY SCHEDULED_TIME ASC`,
+			warehouse: params.warehouse,
+			role: params.role,
+			database: params.database,
+			schema: params.schema
+		})).rows;
+		const events = rows.map((row) => ({
+			name: readStringField(row, "NAME", "name") ?? "",
+			databaseName: readStringField(row, "DATABASE_NAME", "database_name"),
+			schemaName: readStringField(row, "SCHEMA_NAME", "schema_name"),
+			state: readStringField(row, "STATE", "state") ?? "UNKNOWN",
+			queryId: readStringField(row, "QUERY_ID", "query_id"),
+			scheduledTime: readStringField(row, "SCHEDULED_TIME", "scheduled_time"),
+			completedTime: readStringField(row, "COMPLETED_TIME", "completed_time"),
+			errorCode: readStringField(row, "ERROR_CODE", "error_code") ?? null,
+			errorMessage: readStringField(row, "ERROR_MESSAGE", "error_message") ?? null,
+			attemptNumber: readNumberField(row, "ATTEMPT_NUMBER", "attempt_number"),
+			runId: readStringField(row, "RUN_ID", "run_id"),
+			row
+		}));
+		const last = rows[rows.length - 1];
+		return {
+			events,
+			highWaterValue: readStringField(last ?? {}, "COMPLETED_TIME", "completed_time") ?? readStringField(last ?? {}, "SCHEDULED_TIME", "scheduled_time") ?? priorHighWater,
+			fetchedAt: isoNow()
+		};
+	},
+	idempotencyKey: (response) => `task-run:${response.highWaterValue ?? "initial"}:${response.events.length}`,
+	hasPayload: (response) => response.events.length > 0
+});
+function taskRunCompleted(input) {
+	return bindSnowflakePollingTrigger(taskRunCompletedDefinition, {
+		taskName: input?.taskName,
+		database: input?.database,
+		schema: input?.schema,
+		warehouse: input?.warehouse,
+		role: input?.role,
+		lookbackMinutes: input?.lookbackMinutes,
+		limit: input?.limit,
+		states: input?.states
+	}, input);
+}
+const DEFAULT_STATEMENT_STATES = [
+	"SUCCESS",
+	"FAIL",
+	"FAILED_WITH_ERROR",
+	"CANCELLED",
+	"INCIDENT"
+];
+const statementCompletedDefinition = defineSnowflakePollingTrigger({
+	responseSchema: z.object({
+		events: z.array(statementCompletedEventSchema),
+		highWaterValue: z.string().nullable(),
+		fetchedAt: z.string()
+	}).catchall(z.unknown()),
+	defaultName: "Snowflake Statement Completed",
+	defaultDescription: "Emits terminal statements from INFORMATION_SCHEMA.QUERY_HISTORY, optionally filtered by user / text / warehouse.",
+	defaultSchedule: "1m",
+	poll: async (params, credentials, ctx) => {
+		const client = createSnowflakeClient(credentials);
+		const limit = params.limit ?? 200;
+		const states = params.executionStatuses ?? DEFAULT_STATEMENT_STATES;
+		const priorHighWater = ctx.lastResponse?.highWaterValue ?? null;
+		const lookbackMinutes = params.lookbackMinutes ?? 30;
+		const args = [`END_TIME_RANGE_START => TO_TIMESTAMP_LTZ(${quoteLiteral(priorHighWater ?? (/* @__PURE__ */ new Date(Date.now() - lookbackMinutes * 6e4)).toISOString())})`, `RESULT_LIMIT => ${Number(limit)}`];
+		if (params.userName) args.push(`USER_NAME => ${quoteLiteral(params.userName)}`);
+		if (params.warehouse) args.push(`WAREHOUSE_NAME => ${quoteLiteral(params.warehouse)}`);
+		const clauses = [];
+		if (!params.includeInFlight) {
+			const statesPredicate = states.map((s) => quoteLiteral(s)).join(", ");
+			clauses.push(`EXECUTION_STATUS IN (${statesPredicate})`);
+		}
+		if (params.queryTextLike) clauses.push(`QUERY_TEXT ILIKE ${quoteLiteral(params.queryTextLike)}`);
+		const where = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
+		const rows = (await executeSql(client, {
+			statement: `SELECT * FROM TABLE(INFORMATION_SCHEMA.QUERY_HISTORY(${args.join(", ")}))${where} ORDER BY END_TIME ASC`,
+			warehouse: params.warehouse,
+			role: params.role,
+			database: params.database,
+			schema: params.schema
+		})).rows;
+		const events = rows.map((row) => ({
+			queryId: readStringField(row, "QUERY_ID", "query_id") ?? "",
+			executionStatus: readStringField(row, "EXECUTION_STATUS", "execution_status") ?? "UNKNOWN",
+			queryText: readStringField(row, "QUERY_TEXT", "query_text"),
+			errorCode: readStringField(row, "ERROR_CODE", "error_code") ?? null,
+			errorMessage: readStringField(row, "ERROR_MESSAGE", "error_message") ?? null,
+			startTime: readStringField(row, "START_TIME", "start_time"),
+			endTime: readStringField(row, "END_TIME", "end_time"),
+			warehouseName: readStringField(row, "WAREHOUSE_NAME", "warehouse_name"),
+			databaseName: readStringField(row, "DATABASE_NAME", "database_name"),
+			schemaName: readStringField(row, "SCHEMA_NAME", "schema_name"),
+			userName: readStringField(row, "USER_NAME", "user_name"),
+			roleName: readStringField(row, "ROLE_NAME", "role_name"),
+			totalElapsedTimeMs: readNumberField(row, "TOTAL_ELAPSED_TIME", "total_elapsed_time") ?? null,
+			row
+		}));
+		const last = rows[rows.length - 1];
+		return {
+			events,
+			highWaterValue: readStringField(last ?? {}, "END_TIME", "end_time") ?? readStringField(last ?? {}, "START_TIME", "start_time") ?? priorHighWater,
+			fetchedAt: isoNow()
+		};
+	},
+	idempotencyKey: (response) => `stmt:${response.highWaterValue ?? "initial"}:${response.events.length}`,
+	hasPayload: (response) => response.events.length > 0
+});
+function statementCompleted(input) {
+	return bindSnowflakePollingTrigger(statementCompletedDefinition, {
+		warehouse: input?.warehouse,
+		role: input?.role,
+		database: input?.database,
+		schema: input?.schema,
+		userName: input?.userName,
+		queryTextLike: input?.queryTextLike,
+		lookbackMinutes: input?.lookbackMinutes,
+		limit: input?.limit,
+		executionStatuses: input?.executionStatuses,
+		includeInFlight: input?.includeInFlight
+	}, input);
+}
+const pipeLoadBatchSchema = z.object({
+	events: z.array(pipeLoadEventSchema),
+	highWaterValue: z.string().nullable(),
+	fetchedAt: z.string()
+}).catchall(z.unknown());
+function buildPipeLoadDefinition(defaultName, defaultDescription, statusPredicate) {
+	return defineSnowflakePollingTrigger({
+		responseSchema: pipeLoadBatchSchema,
+		defaultName,
+		defaultDescription,
+		defaultSchedule: "1m",
+		poll: async (params, credentials, ctx) => {
+			const client = createSnowflakeClient(credentials);
+			const limit = params.limit ?? 200;
+			const priorHighWater = ctx.lastResponse?.highWaterValue ?? null;
+			const lookbackMinutes = params.lookbackMinutes ?? 60;
+			const args = [`START_TIME => TO_TIMESTAMP_LTZ(${quoteLiteral(priorHighWater ?? (/* @__PURE__ */ new Date(Date.now() - lookbackMinutes * 6e4)).toISOString())})`];
+			if (params.tableName) {
+				const tableFqn = buildFqn(params.database, params.schema, params.tableName);
+				args.push(`TABLE_NAME => ${quoteLiteral(tableFqn)}`);
+			}
+			const pipeFilter = params.pipeName ? ` AND PIPE_NAME = ${quoteLiteral(buildFqn(params.database, params.schema, params.pipeName))}` : "";
+			const rows = (await executeSql(client, {
+				statement: `SELECT * FROM TABLE(INFORMATION_SCHEMA.COPY_HISTORY(${args.join(", ")})) WHERE ${statusPredicate}${pipeFilter} ORDER BY LAST_LOAD_TIME ASC LIMIT ${Number(limit)}`,
+				warehouse: params.warehouse,
+				role: params.role,
+				database: params.database,
+				schema: params.schema
+			})).rows;
+			const events = rows.map((row) => ({
+				pipeName: readStringField(row, "PIPE_NAME", "pipe_name") ?? "",
+				filePath: readStringField(row, "FILE_NAME", "file_name") ?? "",
+				status: readStringField(row, "STATUS", "status") ?? "UNKNOWN",
+				loadTime: readStringField(row, "LAST_LOAD_TIME", "last_load_time"),
+				rowCount: readNumberField(row, "ROW_COUNT", "row_count") ?? null,
+				rowParsed: readNumberField(row, "ROW_PARSED", "row_parsed") ?? null,
+				errorLimit: readNumberField(row, "ERROR_LIMIT", "error_limit") ?? null,
+				errorsSeen: readNumberField(row, "ERRORS_SEEN", "errors_seen") ?? null,
+				firstErrorMessage: readStringField(row, "FIRST_ERROR_MESSAGE", "first_error_message") ?? null,
+				firstErrorLineNumber: readNumberField(row, "FIRST_ERROR_LINE_NUMBER", "first_error_line_number") ?? null,
+				firstErrorColumnName: readStringField(row, "FIRST_ERROR_COLUMN_NAME", "first_error_column_name") ?? null,
+				fileSize: readNumberField(row, "FILE_SIZE", "file_size") ?? null,
+				stageLocation: readStringField(row, "STAGE_LOCATION", "stage_location") ?? null,
+				row
+			}));
+			const last = rows[rows.length - 1];
+			return {
+				events,
+				highWaterValue: readStringField(last ?? {}, "LAST_LOAD_TIME", "last_load_time") ?? priorHighWater,
+				fetchedAt: isoNow()
+			};
+		},
+		idempotencyKey: (response) => `pipe-load:${response.highWaterValue ?? "initial"}:${response.events.length}`,
+		hasPayload: (response) => response.events.length > 0
+	});
+}
+const pipeLoadCompletedDefinition = buildPipeLoadDefinition("Snowflake Pipe Load Completed", "Emits successful Snowpipe loads polled from INFORMATION_SCHEMA.COPY_HISTORY.", `STATUS = 'LOADED'`);
+const pipeLoadFailedDefinition = buildPipeLoadDefinition("Snowflake Pipe Load Failed", "Emits failed Snowpipe loads polled from INFORMATION_SCHEMA.COPY_HISTORY.", `STATUS IN ('LOAD_FAILED', 'PARTIALLY_LOADED')`);
+function pipeLoadCompleted(input) {
+	return bindSnowflakePollingTrigger(pipeLoadCompletedDefinition, {
+		pipeName: input?.pipeName,
+		database: input?.database,
+		schema: input?.schema,
+		tableName: input?.tableName,
+		warehouse: input?.warehouse,
+		role: input?.role,
+		lookbackMinutes: input?.lookbackMinutes,
+		limit: input?.limit
+	}, input);
+}
+function pipeLoadFailed(input) {
+	return bindSnowflakePollingTrigger(pipeLoadFailedDefinition, {
+		pipeName: input?.pipeName,
+		database: input?.database,
+		schema: input?.schema,
+		tableName: input?.tableName,
+		warehouse: input?.warehouse,
+		role: input?.role,
+		lookbackMinutes: input?.lookbackMinutes,
+		limit: input?.limit
+	}, input);
+}
+/**
+* Diff-trigger response envelope carried across polls. The emitted shape
+* is `{ events: TEvent[], snapshot: Entry[], fetchedAt: string }`. The
+* `snapshot` field is the identity+signature list that the NEXT poll
+* will diff against — it is stored in `ctx.lastResponse` and replayed
+* into the trigger automatically.
+*/
+const diffSnapshotSchema = z.array(snowflakeDiffSnapshotEntrySchema);
+function buildDiffBatchSchema(event) {
+	return z.object({
+		events: z.array(event),
+		snapshot: diffSnapshotSchema,
+		fetchedAt: z.string()
+	}).catchall(z.unknown());
+}
+/**
+* Compute the diff between two snapshots. For `created`: entries in
+* `current` whose identity is not in `previous`. For `dropped`: entries
+* in `previous` whose identity is not in `current`. For `changed`:
+* entries in `current` whose signature differs from `previous`'s
+* (including entries that are newly present).
+*/
+function diffEntries(current, previous, mode) {
+	if (previous === void 0) return [];
+	const prevMap = new Map(previous.map((p) => [p.identity, p]));
+	const currMap = new Map(current.map((c) => [c.identity, c]));
+	if (mode === "created") return current.filter((c) => !prevMap.has(c.identity));
+	if (mode === "dropped") return previous.filter((p) => !currMap.has(p.identity)).map((p) => ({
+		identity: p.identity,
+		...p.signature !== void 0 ? { signature: p.signature } : {},
+		row: p.row ?? {}
+	}));
+	return current.filter((c) => {
+		const prev = prevMap.get(c.identity);
+		if (prev === void 0) return true;
+		return prev.signature !== c.signature;
+	});
+}
+function toSnapshotEntries(entries) {
+	return entries.map((e) => ({
+		identity: e.identity,
+		...e.signature !== void 0 ? { signature: e.signature } : {}
+	}));
+}
+function sortedIdempotencyKey(prefix, events, getIdentity = (e) => e.identity ?? "") {
+	return `${prefix}:${events.map(getIdentity).slice().sort().join(",") || "empty"}`;
+}
+const lifecycleBatchSchema = buildDiffBatchSchema(snowflakeObjectLifecycleEventSchema);
+function rowToLifecycleEntry(kind, row) {
+	const name = readStringField(row, "name", "NAME") ?? "";
+	const database = readStringField(row, "database_name", "DATABASE_NAME");
+	const schema = readStringField(row, "schema_name", "SCHEMA_NAME");
+	return {
+		identity: [
+			kind,
+			database ?? "",
+			schema ?? "",
+			name
+		].join("::"),
+		row
+	};
+}
+function lifecycleEventFromEntry(kind, change, entry, detectedAt) {
+	const row = entry.row;
+	return {
+		kind,
+		name: readStringField(row, "name", "NAME") ?? "",
+		change,
+		identity: entry.identity,
+		owner: readStringField(row, "owner", "OWNER"),
+		createdOn: readStringField(row, "created_on", "CREATED_ON"),
+		detectedAt,
+		row
+	};
+}
+function buildLifecycleDefinition(config) {
+	return defineSnowflakePollingTrigger({
+		responseSchema: lifecycleBatchSchema,
+		defaultName: config.defaultName,
+		defaultDescription: config.defaultDescription,
+		defaultSchedule: "5m",
+		poll: async (params, credentials, ctx) => {
+			const current = (await executeSql(createSnowflakeClient(credentials), {
+				statement: config.buildStatement(params),
+				warehouse: params.warehouse,
+				role: params.role,
+				database: params.database,
+				schema: params.schema
+			})).rows.map((row) => rowToLifecycleEntry(config.kind, row));
+			const previousSnapshot = ctx.lastResponse?.snapshot;
+			const detectedAt = isoNow();
+			let diffed;
+			if (previousSnapshot === void 0) diffed = config.change === "created" && params.emitInitialSnapshot ? current : [];
+			else diffed = diffEntries(current, previousSnapshot, config.change);
+			return {
+				events: diffed.map((entry) => lifecycleEventFromEntry(config.kind, config.change, entry, detectedAt)),
+				snapshot: toSnapshotEntries(current),
+				fetchedAt: detectedAt
+			};
+		},
+		idempotencyKey: (response) => sortedIdempotencyKey(`${config.kind}:${config.change}`, response.events),
+		hasPayload: (response) => response.events.length > 0
+	});
+}
+function likeClause(like) {
+	return like ? ` LIKE ${quoteLiteral(like)}` : "";
+}
+function inScope(params) {
+	const db = params.in?.database ?? params.database;
+	const schema = params.in?.schema ?? params.schema;
+	if (db && schema) return ` IN SCHEMA ${quoteIdentifier(db)}.${quoteIdentifier(schema)}`;
+	if (db) return ` IN DATABASE ${quoteIdentifier(db)}`;
+	return "";
+}
+const userCreatedDefinition = buildLifecycleDefinition({
+	kind: "USER",
+	change: "created",
+	defaultName: "Snowflake User Created",
+	defaultDescription: "Emits every new user observed via SHOW USERS since the prior poll.",
+	buildStatement: (params) => `SHOW USERS${likeClause(params.like)}`
+});
+const userDroppedDefinition = buildLifecycleDefinition({
+	kind: "USER",
+	change: "dropped",
+	defaultName: "Snowflake User Dropped",
+	defaultDescription: "Emits every user that has disappeared from SHOW USERS since the prior poll.",
+	buildStatement: (params) => `SHOW USERS${likeClause(params.like)}`
+});
+function userCreated(input) {
+	return bindSnowflakePollingTrigger(userCreatedDefinition, {
+		database: input?.database,
+		schema: input?.schema,
+		warehouse: input?.warehouse,
+		role: input?.role,
+		like: input?.like,
+		emitInitialSnapshot: input?.emitInitialSnapshot
+	}, input);
+}
+function userDropped(input) {
+	return bindSnowflakePollingTrigger(userDroppedDefinition, {
+		database: input?.database,
+		schema: input?.schema,
+		warehouse: input?.warehouse,
+		role: input?.role,
+		like: input?.like
+	}, input);
+}
+const roleCreatedDefinition = buildLifecycleDefinition({
+	kind: "ROLE",
+	change: "created",
+	defaultName: "Snowflake Role Created",
+	defaultDescription: "Emits every new role observed via SHOW ROLES since the prior poll.",
+	buildStatement: (params) => `SHOW ROLES${likeClause(params.like)}`
+});
+const roleDroppedDefinition = buildLifecycleDefinition({
+	kind: "ROLE",
+	change: "dropped",
+	defaultName: "Snowflake Role Dropped",
+	defaultDescription: "Emits every role that has disappeared from SHOW ROLES since the prior poll.",
+	buildStatement: (params) => `SHOW ROLES${likeClause(params.like)}`
+});
+function roleCreated(input) {
+	return bindSnowflakePollingTrigger(roleCreatedDefinition, {
+		warehouse: input?.warehouse,
+		role: input?.role,
+		like: input?.like,
+		emitInitialSnapshot: input?.emitInitialSnapshot
+	}, input);
+}
+function roleDropped(input) {
+	return bindSnowflakePollingTrigger(roleDroppedDefinition, {
+		warehouse: input?.warehouse,
+		role: input?.role,
+		like: input?.like
+	}, input);
+}
+const databaseCreatedDefinition = buildLifecycleDefinition({
+	kind: "DATABASE",
+	change: "created",
+	defaultName: "Snowflake Database Created",
+	defaultDescription: "Emits every new database observed via SHOW DATABASES since the prior poll.",
+	buildStatement: (params) => `SHOW DATABASES${likeClause(params.like)}`
+});
+const databaseDroppedDefinition = buildLifecycleDefinition({
+	kind: "DATABASE",
+	change: "dropped",
+	defaultName: "Snowflake Database Dropped",
+	defaultDescription: "Emits every database that disappeared from SHOW DATABASES since the prior poll.",
+	buildStatement: (params) => `SHOW DATABASES${likeClause(params.like)}`
+});
+function databaseCreated(input) {
+	return bindSnowflakePollingTrigger(databaseCreatedDefinition, {
+		warehouse: input?.warehouse,
+		role: input?.role,
+		like: input?.like,
+		emitInitialSnapshot: input?.emitInitialSnapshot
+	}, input);
+}
+function databaseDropped(input) {
+	return bindSnowflakePollingTrigger(databaseDroppedDefinition, {
+		warehouse: input?.warehouse,
+		role: input?.role,
+		like: input?.like
+	}, input);
+}
+const tableCreatedDefinition = buildLifecycleDefinition({
+	kind: "TABLE",
+	change: "created",
+	defaultName: "Snowflake Table Created",
+	defaultDescription: "Emits every new table observed via SHOW TABLES since the prior poll.",
+	buildStatement: (params) => `SHOW TABLES${likeClause(params.like)}${inScope(params)}`
+});
+const tableDroppedDefinition = buildLifecycleDefinition({
+	kind: "TABLE",
+	change: "dropped",
+	defaultName: "Snowflake Table Dropped",
+	defaultDescription: "Emits every table that disappeared from SHOW TABLES since the prior poll.",
+	buildStatement: (params) => `SHOW TABLES${likeClause(params.like)}${inScope(params)}`
+});
+function tableCreated(input) {
+	return bindSnowflakePollingTrigger(tableCreatedDefinition, {
+		in: input?.in,
+		database: input?.database,
+		schema: input?.schema,
+		warehouse: input?.warehouse,
+		role: input?.role,
+		like: input?.like,
+		emitInitialSnapshot: input?.emitInitialSnapshot
+	}, input);
+}
+function tableDropped(input) {
+	return bindSnowflakePollingTrigger(tableDroppedDefinition, {
+		in: input?.in,
+		database: input?.database,
+		schema: input?.schema,
+		warehouse: input?.warehouse,
+		role: input?.role,
+		like: input?.like
+	}, input);
+}
+const shareChangedBatchSchema = buildDiffBatchSchema(shareChangedEventSchema);
+const SHARE_SIGNATURE_FIELDS = [
+	"kind",
+	"owner",
+	"comment",
+	"to",
+	"database_name",
+	"listing_global_name"
+];
+function signatureOf(row, fields) {
+	return fields.map((field) => {
+		const upper = field.toUpperCase();
+		const v = row[field] ?? row[upper];
+		return v === void 0 || v === null ? "" : String(v);
+	}).join("|");
+}
+const shareChangedDefinition = defineSnowflakePollingTrigger({
+	responseSchema: shareChangedBatchSchema,
+	defaultName: "Snowflake Share Changed",
+	defaultDescription: "Emits share create / drop / modify events observed via SHOW SHARES. Modifications diff against a signature of kind / owner / comment / accounts / listing.",
+	defaultSchedule: "5m",
+	poll: async (params, credentials, ctx) => {
+		const current = (await executeSql(createSnowflakeClient(credentials), {
+			statement: `SHOW SHARES${likeClause(params.like)}`,
+			warehouse: params.warehouse,
+			role: params.role
+		})).rows.map((row) => ({
+			identity: `SHARE::${readStringField(row, "name", "NAME") ?? ""}`,
+			signature: signatureOf(row, SHARE_SIGNATURE_FIELDS),
+			row
+		}));
+		const previousSnapshot = ctx.lastResponse?.snapshot;
+		const detectedAt = isoNow();
+		const prevMap = new Map((previousSnapshot ?? []).map((p) => [p.identity, p]));
+		const currMap = new Map(current.map((c) => [c.identity, c]));
+		const events = [];
+		if (previousSnapshot !== void 0) {
+			for (const entry of current) {
+				const prev = prevMap.get(entry.identity);
+				if (prev === void 0) events.push({
+					name: readStringField(entry.row, "name", "NAME") ?? "",
+					kind: readStringField(entry.row, "kind", "KIND"),
+					change: "created",
+					identity: entry.identity,
+					detectedAt,
+					currentRow: entry.row
+				});
+				else if (prev.signature !== entry.signature) events.push({
+					name: readStringField(entry.row, "name", "NAME") ?? "",
+					kind: readStringField(entry.row, "kind", "KIND"),
+					change: "modified",
+					identity: entry.identity,
+					detectedAt,
+					currentRow: entry.row
+				});
+			}
+			for (const prev of previousSnapshot) if (!currMap.has(prev.identity)) events.push({
+				name: prev.identity.replace(/^SHARE::/u, ""),
+				change: "dropped",
+				identity: prev.identity,
+				detectedAt
+			});
+		} else if (params.emitInitialSnapshot) for (const entry of current) events.push({
+			name: readStringField(entry.row, "name", "NAME") ?? "",
+			kind: readStringField(entry.row, "kind", "KIND"),
+			change: "created",
+			identity: entry.identity,
+			detectedAt,
+			currentRow: entry.row
+		});
+		return {
+			events,
+			snapshot: toSnapshotEntries(current),
+			fetchedAt: detectedAt
+		};
+	},
+	idempotencyKey: (response) => sortedIdempotencyKey("share-changed", response.events),
+	hasPayload: (response) => response.events.length > 0
+});
+function shareChanged(input) {
+	return bindSnowflakePollingTrigger(shareChangedDefinition, {
+		warehouse: input?.warehouse,
+		role: input?.role,
+		like: input?.like,
+		emitInitialSnapshot: input?.emitInitialSnapshot
+	}, input);
+}
+const grantsChangedBatchSchema = buildDiffBatchSchema(grantChangedEventSchema);
+function grantIdentity(row) {
+	return `${readStringField(row, "privilege", "PRIVILEGE") ?? ""}::${readStringField(row, "granted_on", "GRANTED_ON") ?? ""}::${readStringField(row, "name", "NAME") ?? ""}::${readStringField(row, "granted_to", "GRANTED_TO") ?? ""}::${readStringField(row, "grantee_name", "GRANTEE_NAME") ?? ""}`;
+}
+function grantStatement(params) {
+	if ("role" in params.grantee) return `SHOW GRANTS TO ROLE ${quoteIdentifier(params.grantee.role)}`;
+	if ("user" in params.grantee) return `SHOW GRANTS TO USER ${quoteIdentifier(params.grantee.user)}`;
+	return `SHOW GRANTS TO SHARE ${quoteIdentifier(params.grantee.share)}`;
+}
+const grantsChangedDefinition = defineSnowflakePollingTrigger({
+	responseSchema: grantsChangedBatchSchema,
+	defaultName: "Snowflake Grants Changed",
+	defaultDescription: "Emits grant / revoke events observed via SHOW GRANTS TO <ROLE|USER|SHARE>. Diffs against the prior poll by (privilege, granted_on, name, grantee).",
+	defaultSchedule: "5m",
+	poll: async (params, credentials, ctx) => {
+		const current = (await executeSql(createSnowflakeClient(credentials), {
+			statement: grantStatement(params),
+			warehouse: params.warehouse,
+			role: params.sessionRole
+		})).rows.map((row) => ({
+			identity: grantIdentity(row),
+			row
+		}));
+		const previousSnapshot = ctx.lastResponse?.snapshot;
+		const detectedAt = isoNow();
+		const events = [];
+		if (previousSnapshot !== void 0) {
+			const prevSet = new Set(previousSnapshot.map((p) => p.identity));
+			const currSet = new Set(current.map((c) => c.identity));
+			for (const entry of current) if (!prevSet.has(entry.identity)) events.push(buildGrantEvent(entry.row, "granted", entry.identity, detectedAt));
+			for (const prev of previousSnapshot) if (!currSet.has(prev.identity)) {
+				const [privilege, grantedOn, name, granteeType, granteeName] = prev.identity.split("::");
+				events.push({
+					privilege: privilege ?? "",
+					grantedOn: grantedOn ?? "",
+					objectName: name ?? "",
+					granteeType,
+					granteeName: granteeName ?? "",
+					change: "revoked",
+					identity: prev.identity,
+					detectedAt,
+					row: {}
+				});
+			}
+		}
+		return {
+			events,
+			snapshot: toSnapshotEntries(current),
+			fetchedAt: detectedAt
+		};
+	},
+	idempotencyKey: (response) => sortedIdempotencyKey("grants-changed", response.events),
+	hasPayload: (response) => response.events.length > 0
+});
+function buildGrantEvent(row, change, identity, detectedAt) {
+	return {
+		privilege: readStringField(row, "privilege", "PRIVILEGE") ?? "",
+		grantedOn: readStringField(row, "granted_on", "GRANTED_ON") ?? "",
+		objectName: readStringField(row, "name", "NAME") ?? "",
+		granteeName: readStringField(row, "grantee_name", "GRANTEE_NAME") ?? "",
+		granteeType: readStringField(row, "granted_to", "GRANTED_TO"),
+		change,
+		identity,
+		detectedAt,
+		row
+	};
+}
+function grantsChanged(input) {
+	return bindSnowflakePollingTrigger(grantsChangedDefinition, input, input);
+}
+const warehouseCreditsBatchSchema = z.object({
+	events: z.array(warehouseCreditsEventSchema),
+	highWaterValue: z.string().nullable(),
+	fetchedAt: z.string()
+}).catchall(z.unknown());
+const warehouseQueueBatchSchema = z.object({
+	events: z.array(warehouseQueueEventSchema),
+	highWaterValue: z.string().nullable(),
+	fetchedAt: z.string()
+}).catchall(z.unknown());
+const warehouseCreditsUsageDefinition = defineSnowflakePollingTrigger({
+	responseSchema: warehouseCreditsBatchSchema,
+	defaultName: "Snowflake Warehouse Credits Usage",
+	defaultDescription: "Tails INFORMATION_SCHEMA.WAREHOUSE_METERING_HISTORY and emits per-warehouse credit buckets above an optional minimum.",
+	defaultSchedule: "5m",
+	poll: async (params, credentials, ctx) => {
+		const client = createSnowflakeClient(credentials);
+		const limit = params.limit ?? 200;
+		const priorHighWater = ctx.lastResponse?.highWaterValue ?? null;
+		const lookbackMinutes = params.lookbackMinutes ?? 60;
+		const args = [`DATE_RANGE_START => TO_TIMESTAMP_LTZ(${quoteLiteral(priorHighWater ?? (/* @__PURE__ */ new Date(Date.now() - lookbackMinutes * 6e4)).toISOString())})`];
+		if (params.warehouseName) args.push(`WAREHOUSE_NAME => ${quoteLiteral(params.warehouseName)}`);
+		const clauses = [];
+		if (params.minimum !== void 0) clauses.push(`CREDITS_USED >= ${Number(params.minimum)}`);
+		const where = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
+		const rows = (await executeSql(client, {
+			statement: `SELECT * FROM TABLE(INFORMATION_SCHEMA.WAREHOUSE_METERING_HISTORY(${args.join(", ")}))${where} ORDER BY END_TIME ASC LIMIT ${Number(limit)}`,
+			warehouse: params.warehouse,
+			role: params.role,
+			database: params.database,
+			schema: params.schema
+		})).rows;
+		const events = rows.map((row) => ({
+			warehouseName: readStringField(row, "WAREHOUSE_NAME", "warehouse_name") ?? "",
+			startTime: readStringField(row, "START_TIME", "start_time"),
+			endTime: readStringField(row, "END_TIME", "end_time"),
+			creditsUsed: readNumberField(row, "CREDITS_USED", "credits_used") ?? null,
+			creditsUsedCompute: readNumberField(row, "CREDITS_USED_COMPUTE", "credits_used_compute") ?? null,
+			creditsUsedCloudServices: readNumberField(row, "CREDITS_USED_CLOUD_SERVICES", "credits_used_cloud_services") ?? null,
+			row
+		}));
+		const last = rows[rows.length - 1];
+		return {
+			events,
+			highWaterValue: readStringField(last ?? {}, "END_TIME", "end_time") ?? priorHighWater,
+			fetchedAt: isoNow()
+		};
+	},
+	idempotencyKey: (response) => `wh-credits:${response.highWaterValue ?? "initial"}:${response.events.length}`,
+	hasPayload: (response) => response.events.length > 0
+});
+const warehouseQueueDepthDefinition = defineSnowflakePollingTrigger({
+	responseSchema: warehouseQueueBatchSchema,
+	defaultName: "Snowflake Warehouse Queue Depth",
+	defaultDescription: "Tails INFORMATION_SCHEMA.WAREHOUSE_LOAD_HISTORY and emits per-interval queue depth above an optional minimum.",
+	defaultSchedule: "5m",
+	poll: async (params, credentials, ctx) => {
+		const client = createSnowflakeClient(credentials);
+		const limit = params.limit ?? 200;
+		const priorHighWater = ctx.lastResponse?.highWaterValue ?? null;
+		const lookbackMinutes = params.lookbackMinutes ?? 60;
+		const args = [`DATE_RANGE_START => TO_TIMESTAMP_LTZ(${quoteLiteral(priorHighWater ?? (/* @__PURE__ */ new Date(Date.now() - lookbackMinutes * 6e4)).toISOString())})`];
+		if (params.warehouseName) args.push(`WAREHOUSE_NAME => ${quoteLiteral(params.warehouseName)}`);
+		const clauses = [];
+		if (params.minimum !== void 0) clauses.push(`AVG_QUEUED_LOAD >= ${Number(params.minimum)}`);
+		const where = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
+		const rows = (await executeSql(client, {
+			statement: `SELECT * FROM TABLE(INFORMATION_SCHEMA.WAREHOUSE_LOAD_HISTORY(${args.join(", ")}))${where} ORDER BY END_TIME ASC LIMIT ${Number(limit)}`,
+			warehouse: params.warehouse,
+			role: params.role,
+			database: params.database,
+			schema: params.schema
+		})).rows;
+		const events = rows.map((row) => ({
+			warehouseName: readStringField(row, "WAREHOUSE_NAME", "warehouse_name") ?? "",
+			startTime: readStringField(row, "START_TIME", "start_time"),
+			endTime: readStringField(row, "END_TIME", "end_time"),
+			avgRunning: readNumberField(row, "AVG_RUNNING", "avg_running") ?? null,
+			avgQueuedLoad: readNumberField(row, "AVG_QUEUED_LOAD", "avg_queued_load") ?? null,
+			avgQueuedProvisioning: readNumberField(row, "AVG_QUEUED_PROVISIONING", "avg_queued_provisioning") ?? null,
+			avgBlocked: readNumberField(row, "AVG_BLOCKED", "avg_blocked") ?? null,
+			row
+		}));
+		const last = rows[rows.length - 1];
+		return {
+			events,
+			highWaterValue: readStringField(last ?? {}, "END_TIME", "end_time") ?? priorHighWater,
+			fetchedAt: isoNow()
+		};
+	},
+	idempotencyKey: (response) => `wh-queue:${response.highWaterValue ?? "initial"}:${response.events.length}`,
+	hasPayload: (response) => response.events.length > 0
+});
+function warehouseCreditsUsage(input) {
+	return bindSnowflakePollingTrigger(warehouseCreditsUsageDefinition, input ?? {}, input);
+}
+function warehouseQueueDepth(input) {
+	return bindSnowflakePollingTrigger(warehouseQueueDepthDefinition, input ?? {}, input);
+}
+const statusPageIncidentBatchSchema = buildDiffBatchSchema(statusPageIncidentEventSchema);
+const statusPageComponentChangeBatchSchema = buildDiffBatchSchema(statusPageComponentChangeEventSchema);
+function incidentToEntry(incident) {
+	const row = incident;
+	return {
+		identity: `INCIDENT::${incident.id}`,
+		signature: `${incident.status}|${incident.updated_at}`,
+		row
+	};
+}
+function componentToEntry(component) {
+	const row = component;
+	return {
+		identity: `COMPONENT::${component.id}`,
+		signature: component.status,
+		row
+	};
+}
+function extractStatusPageOptions(params) {
+	const opts = {};
+	if (params.baseUrl !== void 0) opts.baseUrl = params.baseUrl;
+	if (params.fetchImpl !== void 0) opts.fetchImpl = params.fetchImpl;
+	if (params.timeoutMs !== void 0) opts.timeoutMs = params.timeoutMs;
+	if (params.headers !== void 0) opts.headers = params.headers;
+	if (params.signal !== void 0) opts.signal = params.signal;
+	return opts;
+}
+const statusPageIncidentDefinition = {
+	responseSchema: statusPageIncidentBatchSchema,
+	defaultName: "Snowflake Status Page Incident",
+	defaultDescription: "Polls https://status.snowflake.com/api/v2/incidents/unresolved.json and emits newly-appearing or status-changed incidents.",
+	defaultSchedule: "5m",
+	poll: async (params, _credentials, ctx) => {
+		const current = (await getUnresolvedIncidents(extractStatusPageOptions(params))).incidents.map(incidentToEntry);
+		const previousSnapshot = ctx.lastResponse?.snapshot;
+		const detectedAt = isoNow();
+		const events = [];
+		const prevMap = new Map((previousSnapshot ?? []).map((p) => [p.identity, p]));
+		const emitAll = previousSnapshot === void 0 && params.emitInitialSnapshot;
+		if (previousSnapshot === void 0 && !emitAll) {} else for (const entry of current) {
+			const prev = prevMap.get(entry.identity);
+			if (prev === void 0 || prev.signature !== entry.signature) {
+				const incident = entry.row;
+				events.push({
+					id: incident.id,
+					name: incident.name,
+					status: incident.status,
+					impact: incident.impact,
+					createdAt: incident.created_at,
+					updatedAt: incident.updated_at,
+					resolvedAt: incident.resolved_at ?? null,
+					shortlink: incident.shortlink,
+					detectedAt,
+					raw: entry.row
+				});
+			}
+		}
+		return {
+			events,
+			snapshot: toSnapshotEntries(current),
+			fetchedAt: detectedAt
+		};
+	},
+	idempotencyKey: (response) => sortedIdempotencyKey("status-incident", response.events, (e) => `${e.id}:${e.updatedAt ?? ""}`),
+	hasPayload: (response) => response.events.length > 0
+};
+const statusPageComponentChangeDefinition = {
+	responseSchema: statusPageComponentChangeBatchSchema,
+	defaultName: "Snowflake Status Page Component Changed",
+	defaultDescription: "Polls https://status.snowflake.com/api/v2/summary.json and emits a change event when any component transitions status.",
+	defaultSchedule: "2m",
+	poll: async (params, _credentials, ctx) => {
+		const current = ((await getStatusSummary(extractStatusPageOptions(params))).components ?? []).map(componentToEntry);
+		const previousSnapshot = ctx.lastResponse?.snapshot;
+		const detectedAt = isoNow();
+		const events = [];
+		if (previousSnapshot !== void 0) {
+			const prevMap = new Map(previousSnapshot.map((p) => [p.identity, p]));
+			for (const entry of current) {
+				const prevStatus = prevMap.get(entry.identity)?.signature ?? null;
+				if (prevStatus !== entry.signature) {
+					const component = entry.row;
+					events.push({
+						id: component.id,
+						name: component.name,
+						previousStatus: prevStatus,
+						currentStatus: component.status,
+						description: component.description ?? void 0,
+						changedAt: component.updated_at ?? detectedAt,
+						detectedAt,
+						raw: entry.row
+					});
+				}
+			}
+		}
+		return {
+			events,
+			snapshot: toSnapshotEntries(current),
+			fetchedAt: detectedAt
+		};
+	},
+	idempotencyKey: (response) => sortedIdempotencyKey("status-component", response.events, (e) => `${e.id}:${e.currentStatus}`),
+	hasPayload: (response) => response.events.length > 0
+};
+/**
+* Status-page pollers don't need Snowflake credentials, but they still
+* flow through the Snowflake binding factory so they show up in the
+* polling manifest alongside the rest. Credentials are declared but
+* unused — the poll callback ignores `ctx.credentials.snowflake`.
+*/
+function statusPageIncident(input) {
+	return bindSnowflakePollingTrigger(statusPageIncidentDefinition, input ?? {}, input);
+}
+function statusPageComponentChanged(input) {
+	return bindSnowflakePollingTrigger(statusPageComponentChangeDefinition, input ?? {}, input);
+}
+function resolveWebhookPath(override, fallback) {
+	return override ?? fallback;
+}
+function isoNowUtc() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+/**
+* The public SNS payload schema accepted by this trigger. SNS delivers
+* an application/json body; we validate it before signature-checking.
+*/
+const snsWebhookPayloadSchema = snsNotificationSchema;
+function s3RecordsToBatch(snsMessage, rawBody) {
+	const receivedAt = isoNowUtc();
+	return {
+		events: extractS3Records(snsMessage).map((record) => {
+			const bucket = record.s3?.bucket?.name ?? "";
+			const key = record.s3?.object?.key ?? "";
+			return {
+				provider: "aws-s3",
+				eventType: record.eventName ?? "",
+				eventTime: record.eventTime ?? receivedAt,
+				bucket,
+				key,
+				size: typeof record.s3?.object?.size === "number" ? record.s3.object.size : null,
+				etag: record.s3?.object?.eTag ?? null,
+				region: record.awsRegion ?? null,
+				sourceIp: record.requestParameters?.sourceIPAddress ?? null,
+				messageId: snsMessage.MessageId,
+				receivedAt,
+				raw: record
+			};
+		}),
+		provider: "aws-s3",
+		receivedAt,
+		messageId: snsMessage.MessageId,
+		topic: snsMessage.TopicArn,
+		raw: JSON.parse(rawBody)
+	};
+}
+/**
+* `triggers.autoIngestS3Sns` — receives AWS SNS HTTPS deliveries,
+* verifies the SNS signature against the signing certificate, and
+* emits normalized S3 object events. Subscription-confirmation
+* messages are surfaced via a sentinel event of type
+* `SubscriptionConfirmation` so operators can auto-confirm in
+* downstream logic.
+*/
+function autoIngestS3Sns(input) {
+	const { verifierOptions, path, ...rest } = input ?? {};
+	return createWebhookTriggerBindingFactory({
+		defaultName: "Snowflake Auto-Ingest — AWS SNS",
+		defaultDescription: "Receives Snowpipe auto-ingest notifications via AWS SNS HTTPS delivery. Verifies SNS signature against the SigningCertURL, pins TopicArn, and normalizes S3 object events.",
+		path: resolveWebhookPath(path, "/snowflake/auto-ingest/s3-sns"),
+		method: "POST",
+		payload: snsWebhookPayloadSchema,
+		credentialSets: [snowflake, snowflakeS3SnsWebhookCredentialSet],
+		response: { successStatus: 200 },
+		verify: async (request, ctx) => {
+			const creds = ctx.credentials["snowflake-s3-sns-webhook"];
+			try {
+				await verifySnsMessage(request.rawBody, {
+					...creds.expectedTopicArn ? { expectedTopicArn: creds.expectedTopicArn } : {},
+					...creds.allowedSigningCertHostPattern ? { allowedSigningCertHostPattern: creds.allowedSigningCertHostPattern } : {},
+					...verifierOptions ?? {}
+				});
+			} catch (err) {
+				if (err instanceof SnowflakeWebhookVerificationError) throw err;
+				throw new SnowflakeWebhookVerificationError({
+					message: "Unexpected error verifying SNS signature.",
+					reason: "unknown",
+					provider: "aws-s3",
+					cause: err
+				});
+			}
+		},
+		mapPayload: (payload) => {
+			if (payload.Type !== "Notification") return null;
+			const batch = s3RecordsToBatch(payload, JSON.stringify(payload));
+			return batch.events.length > 0 ? batch : null;
+		},
+		idempotencyKey: (_payload, mapped) => mapped ? `sns:${mapped.messageId ?? "no-id"}` : void 0
+	})(rest);
+}
+const gcsWebhookPayloadSchema = gcsPubSubPushSchema;
+function gcsPushToBatch(push) {
+	const receivedAt = isoNowUtc();
+	const payload = extractGcsObjectPayload(push);
+	const attributes = push.message.attributes ?? {};
+	if (!payload || !payload.bucket || !payload.name) return {
+		events: [],
+		provider: "gcp-gcs",
+		receivedAt,
+		messageId: push.message.messageId ?? null,
+		topic: push.subscription ?? null,
+		raw: push
+	};
+	const eventType = attributes.eventType ?? "OBJECT_FINALIZE";
+	const sizeNumber = typeof payload.size === "number" ? payload.size : typeof payload.size === "string" ? Number(payload.size) : null;
+	return {
+		events: [{
+			provider: "gcp-gcs",
+			eventType,
+			eventTime: payload.updated ?? payload.timeCreated ?? receivedAt,
+			bucket: payload.bucket,
+			key: payload.name,
+			size: sizeNumber !== null && Number.isFinite(sizeNumber) ? sizeNumber : null,
+			etag: payload.etag ?? null,
+			region: null,
+			sourceIp: null,
+			messageId: push.message.messageId ?? null,
+			receivedAt,
+			raw: payload
+		}],
+		provider: "gcp-gcs",
+		receivedAt,
+		messageId: push.message.messageId ?? null,
+		topic: push.subscription ?? null,
+		raw: push
+	};
+}
+/**
+* `triggers.autoIngestGcsPubSub` — receives GCP Pub/Sub push deliveries,
+* verifies the Google-signed OIDC JWT against Google's JWKS, and
+* emits normalized GCS object events extracted from the Pub/Sub
+* message body.
+*/
+function autoIngestGcsPubSub(input) {
+	const { verifierOptions, path, ...rest } = input ?? {};
+	return createWebhookTriggerBindingFactory({
+		defaultName: "Snowflake Auto-Ingest — GCS Pub/Sub",
+		defaultDescription: "Receives Snowpipe auto-ingest notifications via GCP Pub/Sub push. Verifies the Google-signed OIDC JWT in the Authorization header and normalizes GCS object events.",
+		path: resolveWebhookPath(path, "/snowflake/auto-ingest/gcs-pubsub"),
+		method: "POST",
+		payload: gcsWebhookPayloadSchema,
+		credentialSets: [snowflake, snowflakeGcsPubSubWebhookCredentialSet],
+		response: { successStatus: 204 },
+		verify: async (request, ctx) => {
+			const creds = ctx.credentials["snowflake-gcs-pubsub-webhook"];
+			try {
+				parsePubSubPush(request.rawBody);
+				await verifyPubSubPushAuthorization(request.headers.authorization, {
+					expectedAudience: creds.expectedAudience,
+					expectedServiceAccount: creds.expectedServiceAccount,
+					...creds.issuer ? { issuer: creds.issuer } : {},
+					...creds.jwksUri ? { jwksUri: creds.jwksUri } : {},
+					...verifierOptions ?? {}
+				});
+			} catch (err) {
+				if (err instanceof SnowflakeWebhookVerificationError) throw err;
+				throw new SnowflakeWebhookVerificationError({
+					message: "Unexpected error verifying Pub/Sub push.",
+					reason: "unknown",
+					provider: "gcp-gcs",
+					cause: err
+				});
+			}
+		},
+		mapPayload: (payload) => {
+			const batch = gcsPushToBatch(payload);
+			return batch.events.length > 0 ? batch : null;
+		},
+		idempotencyKey: (_payload, mapped) => mapped ? `pubsub:${mapped.messageId ?? "no-id"}` : void 0
+	})(rest);
+}
+/**
+* Event Grid wire format is `AzureEventGridEvent[]`. Keystroke's
+* webhook primitive validates a single payload schema — so we accept
+* either a single event or a wrapper object. The runtime reparses the
+* raw body to preserve the array shape.
+*/
+const azureWebhookPayloadSchema = z.union([z.array(azureEventGridEventSchema), azureEventGridEventSchema]);
+function azureBatchToBatch(events, rawBody) {
+	const receivedAt = isoNowUtc();
+	const mapped = [];
+	let topic = null;
+	for (const event of events) {
+		if (event.eventType === EVENT_GRID_VALIDATION_EVENT_TYPE) continue;
+		topic = event.topic ?? topic;
+		const loc = parseAzureBlobLocation(event);
+		const data = event.data;
+		mapped.push({
+			provider: "azure-blob",
+			eventType: event.eventType,
+			eventTime: event.eventTime,
+			bucket: loc.bucket,
+			key: loc.key,
+			size: typeof data.contentLength === "number" ? data.contentLength : null,
+			etag: typeof data.eTag === "string" ? data.eTag : null,
+			region: null,
+			sourceIp: null,
+			messageId: event.id,
+			receivedAt,
+			raw: event
+		});
+	}
+	return {
+		events: mapped,
+		provider: "azure-blob",
+		receivedAt,
+		messageId: events[0]?.id ?? null,
+		topic,
+		raw: JSON.parse(rawBody)
+	};
+}
+/**
+* `triggers.autoIngestAzureEventGrid` — receives Azure Event Grid
+* deliveries. Validates shared-secret header (if configured), parses
+* the batch, and emits normalized Azure Blob object events. The
+* synchronous subscription-validation handshake is NOT supported
+* through the Keystroke static-response primitive; operators must
+* use manual validation URLs (see IMPLEMENTATION_NOTES.md).
+*/
+function autoIngestAzureEventGrid(input) {
+	const { verifierOptions, path, ...rest } = input ?? {};
+	return createWebhookTriggerBindingFactory({
+		defaultName: "Snowflake Auto-Ingest — Azure Event Grid",
+		defaultDescription: "Receives Snowpipe auto-ingest notifications via Azure Event Grid. Validates shared-secret header, drops subscription-validation events (manual handshake required), and normalizes Azure Blob object events.",
+		path: resolveWebhookPath(path, "/snowflake/auto-ingest/azure-eventgrid"),
+		method: "POST",
+		payload: azureWebhookPayloadSchema,
+		credentialSets: [snowflake, snowflakeAzureEventGridWebhookCredentialSet],
+		response: { successStatus: 200 },
+		verify: async (request, ctx) => {
+			const creds = ctx.credentials["snowflake-azure-eventgrid-webhook"];
+			try {
+				verifyEventGridRequest({
+					rawBody: request.rawBody,
+					headers: request.headers
+				}, {
+					...creds.sharedSecret ? { sharedSecret: creds.sharedSecret } : {},
+					...creds.sharedSecretHeader ? { sharedSecretHeader: creds.sharedSecretHeader } : {},
+					...creds.expectedTopicArn ? { expectedTopic: creds.expectedTopicArn } : {},
+					...verifierOptions ?? {}
+				});
+			} catch (err) {
+				if (err instanceof SnowflakeWebhookVerificationError) throw err;
+				throw new SnowflakeWebhookVerificationError({
+					message: "Unexpected error verifying Event Grid request.",
+					reason: "unknown",
+					provider: "azure-blob",
+					cause: err
+				});
+			}
+		},
+		mapPayload: (payload) => {
+			const events = Array.isArray(payload) ? payload : [payload];
+			const batch = azureBatchToBatch(events, JSON.stringify(events));
+			return batch.events.length > 0 ? batch : null;
+		},
+		idempotencyKey: (_payload, mapped) => mapped ? `eventgrid:${mapped.messageId ?? "no-id"}` : void 0
+	})(rest);
+}
+/**
+* Convenience namespace grouping every polling trigger in this package.
+* Equivalent to calling the individual factory functions directly.
+*/
+const polling = Object.freeze({
+	streamHasNewRows,
+	streamAppendOnly,
+	scheduledSql,
+	scheduledDelta,
+	taskRunCompleted,
+	statementCompleted,
+	pipeLoadCompleted,
+	pipeLoadFailed,
+	userCreated,
+	userDropped,
+	roleCreated,
+	roleDropped,
+	databaseCreated,
+	databaseDropped,
+	tableCreated,
+	tableDropped,
+	shareChanged,
+	grantsChanged,
+	warehouseCreditsUsage,
+	warehouseQueueDepth,
+	statusPageIncident,
+	statusPageComponentChanged
+});
+/**
+* Convenience namespace grouping every auto-ingest webhook trigger.
+*/
+const webhooks = Object.freeze({
+	autoIngestS3Sns,
+	autoIngestGcsPubSub,
+	autoIngestAzureEventGrid
+});
+/**
+* Nested `autoIngest` namespace per the spec (§7 PLAN.md) so callers
+* can reach the three webhook triggers via `triggers.autoIngest.<cloud>`.
+*/
+const autoIngest = Object.freeze({
+	s3Sns: autoIngestS3Sns,
+	gcsPubSub: autoIngestGcsPubSub,
+	azureEventGrid: autoIngestAzureEventGrid
+});
+
+//#endregion
+export { autoIngest, autoIngestAzureEventGrid, autoIngestGcsPubSub, autoIngestS3Sns, databaseCreated, databaseDropped, grantsChanged, pipeLoadCompleted, pipeLoadFailed, polling, roleCreated, roleDropped, scheduledDelta, scheduledSql, shareChanged, statementCompleted, statusPageComponentChanged, statusPageIncident, streamAppendOnly, streamHasNewRows, tableCreated, tableDropped, taskRunCompleted, userCreated, userDropped, warehouseCreditsUsage, warehouseQueueDepth, webhooks };