@prismatic-io/components-airtable 0.0.0-stage → 0.1.0

package/npm-dist/index.cjs

@@ -0,0 +1,1547 @@
+let _prismatic_io_spectral = require("@prismatic-io/spectral");
+let _prismatic_io_spectral_http = require("@prismatic-io/spectral/http");
+let node_crypto = require("node:crypto");
+var connections_default = [
+	(0, _prismatic_io_spectral.oauth2Connection)({
+		oauth2Type: _prismatic_io_spectral.OAuth2Type.AuthorizationCode,
+		oauth2PkceMethod: _prismatic_io_spectral.OAuth2PkceMethod.S256,
+		key: "oauth",
+		display: {
+			label: "OAuth 2.0",
+			description: "Authenticate requests to Airtable using OAuth 2.0."
+		},
+		inputs: {
+			authorizeUrl: {
+				label: "Authorize URL",
+				placeholder: "Enter Authorize URL",
+				type: "string",
+				required: true,
+				shown: false,
+				comments: "The OAuth 2.0 Authorization URL for Airtable",
+				default: "https://airtable.com/oauth2/v1/authorize"
+			},
+			tokenUrl: {
+				label: "Token URL",
+				placeholder: "Enter Token URL",
+				type: "string",
+				required: true,
+				shown: false,
+				comments: "The OAuth 2.0 Token URL for Airtable",
+				default: "https://airtable.com/oauth2/v1/token"
+			},
+			scopes: {
+				label: "Scopes",
+				placeholder: "Enter scopes",
+				type: "string",
+				required: true,
+				shown: true,
+				comments: "A space-delimited set of one or more scopes to get the user's permission to access.",
+				default: "data.records:read data.records:write data.recordComments:read data.recordComments:write schema.bases:read schema.bases:write webhook:manage"
+			},
+			clientId: {
+				label: "Client ID",
+				placeholder: "Enter Client ID",
+				type: "string",
+				required: true,
+				shown: true,
+				comments: "Provide the Client ID you received from https://airtable.com/create/oauth.",
+				example: "cli1234567890abcd"
+			},
+			clientSecret: {
+				label: "Client Secret",
+				placeholder: "Enter Client Secret",
+				type: "password",
+				required: true,
+				shown: true,
+				comments: "Provide the Client Secret you received from https://airtable.com/create/oauth."
+			}
+		}
+	}),
+	(0, _prismatic_io_spectral.connection)({
+		key: "personalAccessToken",
+		display: {
+			label: "Personal Access Token",
+			description: "Authenticate requests to Airtable using a personal access token."
+		},
+		inputs: { apiKey: {
+			label: "API Key",
+			placeholder: "Enter Personal Access Token",
+			type: "password",
+			required: true,
+			shown: true,
+			comments: "You can generate an API key from https://airtable.com/create/tokens",
+			example: "patAbCdEfGh1234567.1234567890abcdefghijklmnopqr"
+		} }
+	}),
+	(0, _prismatic_io_spectral.connection)({
+		key: "apiKey",
+		display: {
+			label: "API Key and Base ID (Deprecated)",
+			description: "Authenticate requests to Airtable using an API key and base ID. This connection is deprecated as of February 1, 2024."
+		},
+		inputs: {
+			base: {
+				label: "Airtable Base ID",
+				placeholder: "Enter Airtable Base ID",
+				type: "string",
+				required: true,
+				shown: true,
+				comments: "Visit https://airtable.com/api and select your workspace. The ID of your base will be printed for you in green.",
+				example: "appLkNDICXNqxSDhG"
+			},
+			apiKey: {
+				label: "API Key",
+				placeholder: "Enter API Key",
+				type: "password",
+				required: true,
+				shown: true,
+				comments: "You can generate an API key from https://airtable.com/account.",
+				example: "keyvTlNCTqEXAMPLE"
+			}
+		}
+	})
+];
+//#endregion
+//#region src/client.ts
+const createAirtableClient = (airtableConnection, debug = false) => {
+	return (0, _prismatic_io_spectral_http.createClient)({
+		baseUrl: "https://api.airtable.com",
+		headers: {
+			Authorization: `Bearer ${airtableConnection.token?.access_token || airtableConnection.fields.apiKey}`,
+			"Content-Type": "application/json"
+		},
+		debug
+	});
+};
+//#endregion
+//#region src/examplePayloads/bases.ts
+const listBasesExamplePayload = { data: [
+	{
+		id: "appLkNDICXNqxSDhG",
+		name: "Apartment Hunting",
+		permissionLevel: "create"
+	},
+	{
+		id: "appSW9R5uCNmRmfl6",
+		name: "Project Tracker",
+		permissionLevel: "edit"
+	},
+	{
+		id: "appVZ3mDrP8fK4xyL",
+		name: "Marketing Campaigns",
+		permissionLevel: "read"
+	}
+] };
+const getBaseSchemaExamplePayload = { data: { tables: [{
+	description: "Apartments to track.",
+	fields: [
+		{
+			description: "Name of the apartment",
+			id: "fld1VnoyuotSTyxW1",
+			name: "Name",
+			type: "singleLineText"
+		},
+		{
+			id: "fldoaIqdn5szURHpw",
+			name: "Pictures",
+			type: "multipleAttachments"
+		},
+		{
+			id: "fldumZe00w09RYTW6",
+			name: "District",
+			options: {
+				inverseLinkFieldId: "fldWnCJlo2z6ttT8Y",
+				isReversed: false,
+				linkedTableId: "tblK6MZHez0ZvBChZ",
+				prefersSingleRecordLink: true
+			},
+			type: "multipleRecordLinks"
+		},
+		{
+			id: "fldPrQNxGqKXLbR4w",
+			name: "Price",
+			type: "currency",
+			options: {
+				precision: 2,
+				symbol: "$"
+			}
+		}
+	],
+	id: "tbltp8DGLhqbUmjK1",
+	name: "Apartments",
+	primaryFieldId: "fld1VnoyuotSTyxW1",
+	views: [{
+		id: "viwQpsuEDqHFqegkp",
+		name: "Grid view",
+		type: "grid"
+	}, {
+		id: "viwKLb2UxT9mQpP4d",
+		name: "Gallery view",
+		type: "gallery"
+	}]
+}, {
+	fields: [{
+		id: "fldEVzvQOoULO38yl",
+		name: "Name",
+		type: "singleLineText"
+	}, {
+		description: "Apartments that belong to this district",
+		id: "fldWnCJlo2z6ttT8Y",
+		name: "Apartments",
+		options: {
+			inverseLinkFieldId: "fldumZe00w09RYTW6",
+			isReversed: false,
+			linkedTableId: "tbltp8DGLhqbUmjK1",
+			prefersSingleRecordLink: false
+		},
+		type: "multipleRecordLinks"
+	}],
+	id: "tblK6MZHez0ZvBChZ",
+	name: "Districts",
+	primaryFieldId: "fldEVzvQOoULO38yl",
+	views: [{
+		id: "viwi3KXvrKug2mIBS",
+		name: "Grid view",
+		type: "grid"
+	}]
+}] } };
+//#endregion
+//#region src/examplePayloads/misc.ts
+const rawRequestExamplePayload = { data: {
+	data: { tables: [{
+		id: "tbltp8DGLhqbUmjK1",
+		name: "Apartments",
+		primaryFieldId: "fld1VnoyuotSTyxW1",
+		fields: [{
+			id: "fld1VnoyuotSTyxW1",
+			name: "Name",
+			type: "singleLineText"
+		}],
+		views: [{
+			id: "viwQpsuEDqHFqegkp",
+			name: "Grid view",
+			type: "grid"
+		}]
+	}] },
+	headers: {}
+} };
+//#endregion
+//#region src/examplePayloads/records.ts
+const recordExamplePayload = { data: {
+	id: "recZ6qSLw0OCA6Xul",
+	createdTime: "2022-06-01T17:50:40.000Z",
+	fields: {
+		Notes: "We finished this and we're ready to move on to our backlog",
+		Status: "Complete",
+		"Start date": "2022-05-31",
+		Projects: "Updated sales process",
+		Priority: "High",
+		"Assigned to": "Jane Doe",
+		Count: 42
+	}
+} };
+const createRecordExamplePayload = recordExamplePayload;
+const getRecordExamplePayload = recordExamplePayload;
+const updateRecordExamplePayload = recordExamplePayload;
+const listRecordsExamplePayload = { data: [{
+	id: "recZ6qSLw0OCA6Xul",
+	createdTime: "2022-06-01T17:50:40.000Z",
+	fields: {
+		Notes: "We finished this and we're ready to move on to our backlog",
+		Status: "Complete",
+		"Start date": "2022-05-31",
+		Projects: "Updated sales process",
+		Priority: "High",
+		"Assigned to": "Jane Doe",
+		Count: 42
+	}
+}, {
+	id: "rec3EKPqD9kLdNPx2",
+	createdTime: "2022-05-15T14:23:10.000Z",
+	fields: {
+		Notes: "Initial setup and configuration",
+		Status: "In Progress",
+		"Start date": "2022-05-15",
+		Projects: "New feature development",
+		Priority: "Medium",
+		"Assigned to": "John Smith",
+		Count: 15
+	}
+}] };
+const deleteRecordExamplePayload = { data: {
+	deleted: true,
+	id: "recZ6qSLw0OCA6Xul"
+} };
+//#endregion
+//#region src/examplePayloads/triggers.ts
+const baseChangesTriggerExamplePayload = {
+	payload: {
+		headers: {
+			Accept: "*/*",
+			"Content-Type": "application/json",
+			Host: "hooks.example.com",
+			"User-Agent": "Airtable Webhooks",
+			"X-Airtable-Content-MAC": "hmacSHA256=abc123def456..."
+		},
+		queryParameters: {},
+		rawBody: { data: "<data (1024 bytes)>" },
+		body: { data: {
+			notification: {
+				base: { id: "appABCDEFGHIJKLMN" },
+				webhook: { id: "achABCDEFGHIJKLMN" },
+				timestamp: "2023-01-15T10:30:00.000Z"
+			},
+			payloads: [{
+				actionMetadata: {
+					source: "client",
+					sourceMetadata: { user: {
+						email: "user@example.com",
+						id: "usrABCDEFGHIJKLMN",
+						permissionLevel: "create"
+					} }
+				},
+				baseTransactionNumber: 42,
+				payloadFormat: "v0",
+				timestamp: "2023-01-15T10:30:00.000Z"
+			}],
+			payloadCount: 1,
+			cursor: 43
+		} },
+		pathFragment: "",
+		webhookUrls: { "Base Changes Flow": "https://hooks.example.com/trigger/BASE_CHANGES_TRIGGER" },
+		webhookApiKeys: { "Base Changes Flow": ["api-key-base-changes"] },
+		invokeUrl: "https://hooks.example.com/trigger/BASE_CHANGES_TRIGGER",
+		executionId: "ExecutionResult:base-changes-execution-456",
+		customer: {
+			id: "Q3VzdG9tZXI6ZXhhbXBsZS1jdXN0b21lci1pZA==",
+			name: "Example Customer",
+			externalId: "customer-12345"
+		},
+		instance: {
+			id: "SW5zdGFuY2U6ZXhhbXBsZS1pbnN0YW5jZS1pZA==",
+			name: "Airtable Base Monitor Instance"
+		},
+		user: {
+			id: "VXNlcjpleGFtcGxlLXVzZXItaWQ=",
+			email: "user@example.com",
+			name: "Jane Doe",
+			externalId: "user-67890"
+		},
+		integration: {
+			name: "Airtable Base Changes",
+			id: "SW50ZWdyYXRpb246YWlydGFibGUtYmFzZS1jaGFuZ2Vz",
+			versionSequenceId: "1",
+			externalVersion: "1.0.0"
+		},
+		flow: {
+			name: "Monitor Base Changes",
+			id: "RmxvdzpiYXNlLWNoYW5nZXM=",
+			stableId: "YmFzZS1jaGFuZ2VzLXN0YWJsZQ=="
+		},
+		startedAt: "2023-01-15T10:30:00.000Z",
+		globalDebug: false
+	},
+	branch: "Notification"
+};
+const pollChangesTriggerExamplePayload = { payload: {
+	headers: {},
+	queryParameters: {},
+	rawBody: { data: null },
+	body: { data: {
+		created: [{
+			id: "recABCDEFGHIJ1234",
+			createdTime: "2026-05-25T14:30:00.000Z",
+			fields: {
+				Name: "Acme Spring Launch",
+				Status: "Active",
+				Notes: "Newly created campaign record."
+			}
+		}],
+		updated: [{
+			id: "recXYZWVUTSR5678",
+			createdTime: "2026-04-10T09:15:00.000Z",
+			fields: {
+				Name: "Q1 Holiday Campaign",
+				Status: "Completed",
+				Notes: "Existing record, modified after last poll."
+			}
+		}]
+	} },
+	pathFragment: "",
+	webhookUrls: {},
+	webhookApiKeys: {},
+	invokeUrl: "",
+	executionId: "RXhhbXBsZUV4ZWN1dGlvblJlc3VsdElk",
+	customer: {
+		id: "testCustomerId",
+		name: "Test Customer",
+		externalId: "testExternalId"
+	},
+	instance: {
+		id: "testInstanceId",
+		name: "Test Instance"
+	},
+	user: {
+		id: "testUserId",
+		email: "user@example.com",
+		name: "Test User",
+		externalId: "testUserExternalId"
+	},
+	integration: {
+		id: "testIntegrationId",
+		name: "Test Integration",
+		versionSequenceId: "1",
+		externalVersion: ""
+	},
+	flow: {
+		id: "testFlowId",
+		name: "Test Flow",
+		stableId: "testFlowStableId"
+	},
+	startedAt: "2024-01-15T00:00:00.000Z",
+	globalDebug: false
+} };
+//#endregion
+//#region src/examplePayloads/users.ts
+const getCurrentUserExamplePayload = { data: {
+	id: "usrL2PNC5o3H4lBEi",
+	email: "jane.doe@example.com",
+	scopes: [
+		"data.records:read",
+		"data.records:write",
+		"data.recordComments:read",
+		"data.recordComments:write",
+		"schema.bases:read",
+		"schema.bases:write",
+		"webhook:manage"
+	]
+} };
+//#endregion
+//#region src/examplePayloads/webhooks.ts
+const listWebhooksExamplePayload = { data: [{
+	id: "ach00000000000001",
+	specification: { options: { filters: {
+		dataTypes: ["tableData"],
+		recordChangeScope: "tbltp8DGLhqbUmjK1"
+	} } },
+	notificationUrl: "https://example.com/receive-webhook",
+	cursorForNextPayload: 5,
+	areNotificationsEnabled: true,
+	lastNotificationResult: {
+		success: true,
+		completionTimestamp: "2022-02-01T21:25:05.663Z",
+		durationMs: 2.603,
+		retryNumber: 0
+	},
+	lastSuccessfulNotificationTime: "2022-02-01T21:25:05.663Z",
+	isHookEnabled: true,
+	expirationTime: "2023-01-20T00:00:00.000Z"
+}, {
+	id: "ach00000000000002",
+	specification: { options: { filters: { dataTypes: ["tableData", "tableMetadata"] } } },
+	notificationUrl: "https://hooks.example.io/airtable",
+	cursorForNextPayload: 12,
+	areNotificationsEnabled: true,
+	lastNotificationResult: {
+		success: true,
+		completionTimestamp: "2022-02-15T14:30:22.145Z",
+		durationMs: 1.854,
+		retryNumber: 0
+	},
+	lastSuccessfulNotificationTime: "2022-02-15T14:30:22.145Z",
+	isHookEnabled: true,
+	expirationTime: "2023-02-10T00:00:00.000Z"
+}] };
+const createWebhookExamplePayload = { data: {
+	id: "ach00000000000001",
+	macSecretBase64: "c3VwZXIgZHVwZXIgc2VjcmV0IGtleSBmb3Igd2ViaG9vaw==",
+	expirationTime: "2023-01-20T00:00:00.000Z"
+} };
+const deleteWebhookExamplePayload = { data: {} };
+const refreshWebhookExamplePayload = { data: { expirationTime: "2023-01-30T00:00:00.000Z" } };
+//#endregion
+//#region src/inputs/common.ts
+const connectionInput = (0, _prismatic_io_spectral.input)({
+	label: "Connection",
+	type: "connection",
+	required: true,
+	comments: "The Airtable connection to use."
+});
+const baseIdInput = (0, _prismatic_io_spectral.input)({
+	label: "Base ID",
+	type: "string",
+	required: false,
+	example: "appLkNDICXNqxSDhG",
+	placeholder: "Enter base ID",
+	comments: "The ID of the base to interact with. Required if you use an OAuth connection, and optional if you specify base ID with a legacy API Key connection.",
+	clean: _prismatic_io_spectral.util.types.toString,
+	dataSource: "selectBase"
+});
+const tableName = (0, _prismatic_io_spectral.input)({
+	label: "Table Name",
+	type: "string",
+	required: true,
+	example: "Marketing Campaigns",
+	placeholder: "Enter table name",
+	comments: "The name of the table to access.",
+	dataSource: "selectTable",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+//#endregion
+//#region src/inputs/bases.ts
+const listBasesInputs = { airtableConnection: connectionInput };
+const getBaseSchemaInputs = {
+	airtableConnection: connectionInput,
+	baseId: baseIdInput
+};
+//#endregion
+//#region src/inputs/dataSources.ts
+const includeIdInput = (0, _prismatic_io_spectral.input)({
+	label: "Include ID in Dropdown",
+	type: "boolean",
+	required: false,
+	default: "false",
+	clean: _prismatic_io_spectral.util.types.toBool,
+	comments: "When true, the base or table ID is shown next to each dropdown menu option."
+});
+const selectBaseInputs = {
+	airtableConnection: connectionInput,
+	includeId: includeIdInput
+};
+const selectTableInputs = {
+	airtableConnection: connectionInput,
+	baseId: {
+		...baseIdInput,
+		required: true,
+		dataSource: void 0
+	},
+	includeId: includeIdInput
+};
+const selectRecordInputs = {
+	airtableConnection: connectionInput,
+	baseId: {
+		...baseIdInput,
+		dataSource: void 0
+	},
+	tableName: {
+		...tableName,
+		dataSource: void 0
+	},
+	includeId: includeIdInput
+};
+const selectWebhookInputs = {
+	airtableConnection: connectionInput,
+	baseId: {
+		...baseIdInput,
+		dataSource: void 0
+	},
+	includeId: includeIdInput
+};
+//#endregion
+//#region src/inputs/misc.ts
+const { debugRequest: _, ...httpInputs } = _prismatic_io_spectral_http.inputs;
+const rawRequestInputs = {
+	connection: connectionInput,
+	...httpInputs,
+	url: {
+		...httpInputs.url,
+		comments: "The request path only (e.g., `/v0/meta/bases/{BASE_ID}/tables`). The base URL [https://api.airtable.com](https://api.airtable.com) is already included. For example, to call `https://api.airtable.com/v0/meta/bases/{BASE_ID}/tables`, enter only `/v0/meta/bases/{BASE_ID}/tables` in this field.",
+		example: "/v0/meta/bases/{BASE_ID}/tables"
+	}
+};
+//#endregion
+//#region src/util/index.ts
+const getBaseId = (airtableConnection, baseId) => {
+	if (!airtableConnection && !baseId) throw new Error("You must specify a base ID");
+	return baseId || airtableConnection.fields.base;
+};
+const cleanDynamicValues = (values) => {
+	if (values) {
+		const parsedJson = _prismatic_io_spectral.util.types.toObject(values);
+		if (!Array.isArray(parsedJson)) throw new Error("Dynamic Fields should be an array");
+		for (const pair of parsedJson) if (!("key" in pair) || !("value" in pair)) throw new Error("Each item in Dynamic Fields should be a key-value pair");
+		return _prismatic_io_spectral.util.types.keyValPairListToObject(parsedJson);
+	}
+	return {};
+};
+const paginateData = async (client, url, recordArrayName, params, fetchAll) => {
+	const records = [];
+	let offset = "";
+	do {
+		const { data } = await client.get(url, { params: {
+			...params,
+			offset
+		} });
+		records.push(...data[recordArrayName]);
+		offset = data.offset;
+	} while (offset && fetchAll);
+	return records;
+};
+const needsRefresh = (expirationTime) => {
+	const expiration = new Date(expirationTime);
+	const now = /* @__PURE__ */ new Date();
+	return (expiration.getTime() - now.getTime()) / (1e3 * 60 * 60 * 24) < 7;
+};
+const toStringList = (value) => {
+	if (value && Array.isArray(value)) return value;
+	return [];
+};
+const toOptionalString = (value) => value ? _prismatic_io_spectral.util.types.toString(value) : void 0;
+function getBase64FromUrl(url) {
+	const lastPathSegmentMatch = url.match(/\/([^/]+)$/);
+	return lastPathSegmentMatch ? lastPathSegmentMatch[1] : "";
+}
+const resolvePollingRecordChanges = (data) => {
+	const changesObject = data ?? {};
+	return [...(changesObject.created ?? []).map((record) => ({
+		changeType: "created",
+		record
+	})), ...(changesObject.updated ?? []).map((record) => ({
+		changeType: "updated",
+		record
+	}))];
+};
+const LOOK_BACK_DATE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+const lookBackDateClean = (value) => {
+	if (value === void 0 || value === null || typeof value === "string" && value.trim() === "") return "";
+	const raw = typeof value === "string" ? value.trim() : String(value);
+	const match = typeof value === "string" ? raw.match(LOOK_BACK_DATE_PATTERN) : null;
+	if (!match) throw new Error(`Look-back Date must be a date in YYYY-MM-DD format. Received: ${raw}`);
+	const [, yearStr, monthStr, dayStr] = match;
+	const year = Number(yearStr);
+	const month = Number(monthStr);
+	const day = Number(dayStr);
+	const parsed = new Date(Date.UTC(year, month - 1, day));
+	if (parsed.getUTCFullYear() !== year || parsed.getUTCMonth() !== month - 1 || parsed.getUTCDate() !== day) throw new Error(`Look-back Date must be a date in YYYY-MM-DD format. Received: ${raw}`);
+	if (parsed.getTime() > Date.now()) throw new Error(`Look-back Date cannot be a future date. Received: ${raw}`);
+	return parsed.toISOString();
+};
+//#endregion
+//#region src/inputs/records.ts
+const recordIdInput = (0, _prismatic_io_spectral.input)({
+	label: "Record ID",
+	type: "string",
+	required: true,
+	example: "rec6r4kNmGDk5D52F",
+	placeholder: "Enter record ID",
+	comments: "The unique identifier for the record. Functions as the primary key for the row in the table.",
+	dataSource: "selectRecord",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const recordFields = (0, _prismatic_io_spectral.input)({
+	label: "Record Fields",
+	type: "string",
+	collection: "keyvaluelist",
+	required: false,
+	placeholder: "Add field key-value pairs",
+	comments: "The key-value pairs to set on the record. Each key maps to a column name in the table.",
+	clean: (values) => _prismatic_io_spectral.util.types.keyValPairListToObject(values)
+});
+const dynamicFields = (0, _prismatic_io_spectral.input)({
+	label: "Dynamic Fields",
+	type: "code",
+	language: "json",
+	required: false,
+	comments: "A JSON array of key-value pairs that can be configured at deploy time with a key-value config variable. When provided, the default 'Record Fields' input is ignored.",
+	example: JSON.stringify([{
+		key: "name",
+		value: "My Example Account"
+	}, {
+		key: "phone",
+		value: "5551234567"
+	}], null, 2),
+	clean: cleanDynamicValues
+});
+const listRecordsInputs = {
+	airtableConnection: connectionInput,
+	baseId: baseIdInput,
+	tableName,
+	view: (0, _prismatic_io_spectral.input)({
+		label: "View",
+		type: "string",
+		example: "Grid view",
+		placeholder: "Enter view name or ID",
+		required: false,
+		comments: "The name or ID of a view in the table. When set, only records in that view are returned, sorted in the order defined by the view.",
+		clean: (value) => _prismatic_io_spectral.util.types.toString(value) || void 0
+	}),
+	fields: (0, _prismatic_io_spectral.input)({
+		label: "Fields",
+		type: "string",
+		example: "Name, Email, Status",
+		placeholder: "Enter field names",
+		required: false,
+		collection: "valuelist",
+		comments: "The names (or IDs) of the fields to return. When omitted, all fields are returned.",
+		clean: (values) => Array.isArray(values) && values.length ? values.map((field) => _prismatic_io_spectral.util.types.toString(field)) : void 0
+	}),
+	filterByFormula: (0, _prismatic_io_spectral.input)({
+		label: "Filter By Formula",
+		type: "string",
+		example: "AND({Quantity} * {Price} > 100, NOT({Shipped?}))",
+		placeholder: "Enter Airtable formula",
+		required: false,
+		comments: "An Airtable formula used to limit results to records matching specific criteria.",
+		clean: (value) => _prismatic_io_spectral.util.types.toString(value) || void 0
+	})
+};
+const getRecordInputs = {
+	airtableConnection: connectionInput,
+	baseId: baseIdInput,
+	tableName,
+	record: recordIdInput
+};
+const createRecordInputs = {
+	airtableConnection: connectionInput,
+	baseId: baseIdInput,
+	tableName,
+	recordFields,
+	dynamicFields
+};
+const updateRecordInputs = {
+	airtableConnection: connectionInput,
+	baseId: baseIdInput,
+	tableName,
+	record: recordIdInput,
+	recordFields,
+	dynamicFields
+};
+const deleteRecordInputs = {
+	airtableConnection: connectionInput,
+	baseId: baseIdInput,
+	tableName,
+	recordId: recordIdInput
+};
+//#endregion
+//#region src/inputs/triggers.ts
+const dataTypes = (0, _prismatic_io_spectral.input)({
+	label: "Data Types",
+	type: "string",
+	collection: "valuelist",
+	required: true,
+	default: ["tableData"],
+	model: [
+		{
+			label: "Table Data (Records)",
+			value: "tableData"
+		},
+		{
+			label: "Table Fields (Schema)",
+			value: "tableFields"
+		},
+		{
+			label: "Table Metadata",
+			value: "tableMetadata"
+		}
+	],
+	comments: "Types of changes to monitor.",
+	clean: toStringList
+});
+const recordChangeScope = (0, _prismatic_io_spectral.input)({
+	label: "Record Change Scope",
+	type: "string",
+	required: false,
+	comments: "Optional table ID or view ID to limit webhook to specific table/view. Leave empty to monitor all tables in base.",
+	example: "tblMwMnUJpKoJUDzo",
+	placeholder: "Enter table ID or view ID",
+	clean: toOptionalString
+});
+const pollView = (0, _prismatic_io_spectral.input)({
+	label: "View",
+	type: "string",
+	example: "Grid view",
+	placeholder: "Enter view name or ID",
+	required: false,
+	comments: "Optional view (name or ID) to scope the poll to. When set, only records in that view are considered.",
+	clean: toOptionalString
+});
+const additionalFilter = (0, _prismatic_io_spectral.input)({
+	label: "Additional Filter Formula",
+	type: "string",
+	required: false,
+	example: "{Status} = 'Active'",
+	placeholder: "Enter Airtable formula",
+	comments: "Optional Airtable formula combined (AND) with the modification-time filter applied by the trigger.",
+	clean: toOptionalString
+});
+const lookBackDate = (0, _prismatic_io_spectral.input)({
+	label: "Look-back Date",
+	placeholder: "Enter look-back date (YYYY-MM-DD)",
+	type: "string",
+	required: false,
+	comments: "The date the initial sync starts from, in YYYY-MM-DD format. Cannot be a future date. Leave empty to start from the first recurrence with no backfill. When set, the initial sync seeds each record modified on or after this date once, ignoring the visibility filters.",
+	example: "2026-01-01",
+	clean: lookBackDateClean
+});
+const showNewRecords = (0, _prismatic_io_spectral.input)({
+	label: "Show New Records",
+	type: "boolean",
+	required: false,
+	default: "true",
+	comments: "When true, records with a `createdTime` after the last poll are included in the trigger results.",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const showUpdatedRecords = (0, _prismatic_io_spectral.input)({
+	label: "Show Updated Records",
+	type: "boolean",
+	required: false,
+	default: "true",
+	comments: "When true, records modified after the last poll (but created earlier) are included in the trigger results.",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const webhookInputs = {};
+const baseChangesInputs = {
+	airtableConnection: connectionInput,
+	baseId: {
+		...baseIdInput,
+		required: true,
+		comments: "The ID of the base to interact with."
+	},
+	dataTypes,
+	recordChangeScope
+};
+const pollChangesInputs = {
+	airtableConnection: connectionInput,
+	baseId: {
+		...baseIdInput,
+		required: true,
+		comments: "The ID of the base containing the table to poll."
+	},
+	tableName,
+	lookBackDate,
+	pollView,
+	additionalFilter,
+	showNewRecords,
+	showUpdatedRecords
+};
+//#endregion
+//#region src/inputs/users.ts
+const getCurrentUserInputs = { airtableConnection: connectionInput };
+//#endregion
+//#region src/inputs/webhooks.ts
+const notificationUrlInput = (0, _prismatic_io_spectral.input)({
+	label: "Notification URL",
+	type: "string",
+	required: false,
+	placeholder: "Enter notification URL",
+	example: "https://your-webhook-endpoint.com/airtable/notifications",
+	comments: "The URL that receives notification pings when the webhook fires.",
+	clean: toOptionalString
+});
+const specificationInput = (0, _prismatic_io_spectral.input)({
+	label: "Specification",
+	type: "code",
+	language: "json",
+	required: true,
+	comments: "A JSON object describing the types of changes the webhook listens for.",
+	example: JSON.stringify({ options: { filters: {
+		fromSources: ["publicApi"],
+		dataTypes: ["tableData"],
+		recordChangeScope: "tblMwMnUJpKoJUDzo"
+	} } }, null, 2),
+	clean: _prismatic_io_spectral.util.types.toObject
+});
+const webhookIdInput = (0, _prismatic_io_spectral.input)({
+	label: "Webhook ID",
+	type: "string",
+	required: true,
+	placeholder: "Enter webhook ID",
+	example: "ach00000000000001",
+	comments: "The unique identifier for the webhook.",
+	dataSource: "selectWebhook",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const listWebhooksInputs = {
+	airtableConnection: connectionInput,
+	baseId: baseIdInput
+};
+const createWebhookInputs = {
+	airtableConnection: connectionInput,
+	baseId: baseIdInput,
+	notificationUrl: notificationUrlInput,
+	specification: specificationInput
+};
+const deleteWebhookInputs = {
+	airtableConnection: connectionInput,
+	baseId: baseIdInput,
+	webhookId: webhookIdInput
+};
+const refreshWebhookInputs = {
+	airtableConnection: connectionInput,
+	baseId: baseIdInput,
+	webhookId: webhookIdInput
+};
+//#endregion
+//#region src/actions/bases/index.ts
+var bases_default = {
+	getBaseSchema: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Base Schema",
+			description: "Retrieve the schema of all tables within a base."
+		},
+		inputs: getBaseSchemaInputs,
+		perform: async (context, params) => {
+			const { data } = await createAirtableClient(params.airtableConnection, context.debug.enabled).get(`/v0/meta/bases/${params.baseId}/tables`);
+			return { data };
+		},
+		examplePayload: getBaseSchemaExamplePayload
+	}),
+	listBases: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Bases",
+			description: "List all bases within the Airtable account."
+		},
+		inputs: listBasesInputs,
+		perform: async (context, params) => {
+			return { data: await paginateData(createAirtableClient(params.airtableConnection, context.debug.enabled), "/v0/meta/bases", "bases", {}, true) };
+		},
+		examplePayload: listBasesExamplePayload
+	})
+};
+//#endregion
+//#region src/actions/misc/index.ts
+var misc_default = { rawRequest: (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Raw Request",
+		description: "Send a raw HTTP request to Airtable."
+	},
+	inputs: rawRequestInputs,
+	perform: async (context, { connection, ...rest }) => {
+		const apiKey = connection.token?.access_token || connection.fields.apiKey;
+		const { data, headers } = await (0, _prismatic_io_spectral_http.sendRawRequest)("https://api.airtable.com", {
+			...rest,
+			debugRequest: context.debug.enabled
+		}, { Authorization: `Bearer ${apiKey}` });
+		return { data: {
+			data,
+			headers
+		} };
+	},
+	examplePayload: rawRequestExamplePayload
+}) };
+//#endregion
+//#region src/actions/records/index.ts
+var records_default = {
+	createRecord: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Create Record",
+			description: "Create a new record in the specified table."
+		},
+		perform: async (context, { recordFields, dynamicFields, airtableConnection, baseId, tableName }) => {
+			const NO_RECORDS = 0;
+			const client = createAirtableClient(airtableConnection, context.debug.enabled);
+			const retrievedBaseId = getBaseId(airtableConnection, baseId);
+			const fields = Object.keys(dynamicFields)?.length > NO_RECORDS ? dynamicFields : recordFields;
+			const { data } = await client.post(`/v0/${retrievedBaseId}/${tableName}`, {
+				fields,
+				typecast: true
+			});
+			return { data };
+		},
+		inputs: createRecordInputs,
+		examplePayload: createRecordExamplePayload
+	}),
+	deleteRecord: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Delete Record",
+			description: "Delete a record from the specified table."
+		},
+		perform: async (context, params) => {
+			const client = createAirtableClient(params.airtableConnection);
+			const baseId = getBaseId(params.airtableConnection, params.baseId);
+			const { data } = await client.delete(`/v0/${baseId}/${params.tableName}/${params.recordId}`);
+			return { data };
+		},
+		inputs: deleteRecordInputs,
+		examplePayload: deleteRecordExamplePayload
+	}),
+	getRecord: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Record",
+			description: "Retrieve a record by ID from the specified table."
+		},
+		perform: async (context, params) => {
+			const client = createAirtableClient(params.airtableConnection, context.debug.enabled);
+			const baseId = getBaseId(params.airtableConnection, params.baseId);
+			const { data } = await client.get(`/v0/${baseId}/${params.tableName}/${params.record}`);
+			return { data };
+		},
+		inputs: getRecordInputs,
+		examplePayload: getRecordExamplePayload
+	}),
+	listRecords: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Records",
+			description: "List all records within the specified table."
+		},
+		perform: async (context, params) => {
+			return { data: await paginateData(createAirtableClient(params.airtableConnection, context.debug.enabled), `/v0/${getBaseId(params.airtableConnection, params.baseId)}/${params.tableName}`, "records", {
+				view: params.view,
+				fields: params.fields,
+				filterByFormula: params.filterByFormula
+			}, true) };
+		},
+		inputs: listRecordsInputs,
+		examplePayload: listRecordsExamplePayload
+	}),
+	updateRecord: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Update Record",
+			description: "Update the field values of a record in the specified table."
+		},
+		perform: async (context, { recordFields, record, baseId, tableName, airtableConnection, dynamicFields }) => {
+			const NO_RECORDS = 0;
+			const client = createAirtableClient(airtableConnection, context.debug.enabled);
+			const retrievedBaseId = getBaseId(airtableConnection, baseId);
+			const fields = Object.keys(dynamicFields)?.length > NO_RECORDS ? dynamicFields : recordFields;
+			const { data } = await client.patch(`/v0/${retrievedBaseId}/${tableName}/${record}`, {
+				fields,
+				typecast: true
+			});
+			return { data };
+		},
+		inputs: updateRecordInputs,
+		examplePayload: updateRecordExamplePayload
+	})
+};
+//#endregion
+//#region src/actions/users/index.ts
+var users_default = { getCurrentUser: (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Get Current User",
+		description: "Retrieve the user ID and OAuth scopes for the current user."
+	},
+	inputs: getCurrentUserInputs,
+	perform: async (context, params) => {
+		const { data } = await createAirtableClient(params.airtableConnection, context.debug.enabled).get("/v0/meta/whoami");
+		return { data };
+	},
+	examplePayload: getCurrentUserExamplePayload
+}) };
+//#endregion
+//#region src/actions/webhooks/createWebhook.ts
+const createWebhook = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Create Webhook",
+		description: "Create a new webhook subscription for a base."
+	},
+	perform: async (context, params) => {
+		const client = createAirtableClient(params.airtableConnection, context.debug.enabled);
+		const baseId = getBaseId(params.airtableConnection, params.baseId);
+		const payload = {
+			notificationUrl: params.notificationUrl,
+			specification: params.specification
+		};
+		const { data } = await client.post(`/v0/bases/${baseId}/webhooks`, payload);
+		return { data };
+	},
+	inputs: createWebhookInputs,
+	examplePayload: createWebhookExamplePayload
+});
+//#endregion
+//#region src/actions/webhooks/index.ts
+var webhooks_default = {
+	deleteWebhook: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Delete Webhook",
+			description: "Delete a webhook subscription from a base."
+		},
+		perform: async (context, params) => {
+			const client = createAirtableClient(params.airtableConnection, context.debug.enabled);
+			const baseId = getBaseId(params.airtableConnection, params.baseId);
+			await client.delete(`/v0/bases/${baseId}/webhooks/${params.webhookId}`);
+			return { data: {} };
+		},
+		inputs: deleteWebhookInputs,
+		examplePayload: deleteWebhookExamplePayload
+	}),
+	listWebhooks: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Webhooks",
+			description: "List all webhook subscriptions registered for a base."
+		},
+		perform: async (context, params) => {
+			const client = createAirtableClient(params.airtableConnection, context.debug.enabled);
+			const baseId = getBaseId(params.airtableConnection, params.baseId);
+			const { data } = await client.get(`/v0/bases/${baseId}/webhooks`);
+			return { data: data.webhooks };
+		},
+		inputs: listWebhooksInputs,
+		examplePayload: listWebhooksExamplePayload
+	}),
+	createWebhook,
+	refreshWebhook: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Refresh Webhook",
+			description: "Extend the expiration of an existing webhook subscription."
+		},
+		perform: async (context, params) => {
+			const client = createAirtableClient(params.airtableConnection, context.debug.enabled);
+			const baseId = getBaseId(params.airtableConnection, params.baseId);
+			const { data } = await client.post(`/v0/bases/${baseId}/webhooks/${params.webhookId}/refresh`);
+			return { data };
+		},
+		inputs: refreshWebhookInputs,
+		examplePayload: refreshWebhookExamplePayload
+	})
+};
+//#endregion
+//#region src/actions/index.ts
+var actions_default = {
+	...bases_default,
+	...records_default,
+	...users_default,
+	...misc_default,
+	...webhooks_default
+};
+//#endregion
+//#region src/dataSources/selectBase.ts
+const selectBase = (0, _prismatic_io_spectral.dataSource)({
+	dataSourceType: "picklist",
+	display: {
+		label: "Select Base",
+		description: "Select an Airtable base from a dropdown."
+	},
+	inputs: selectBaseInputs,
+	perform: async (context, params) => {
+		return { result: (await paginateData(createAirtableClient(params.airtableConnection), "/v0/meta/bases", "bases", {}, true)).map((base) => ({
+			key: base.id,
+			label: params.includeId ? `${base.name} (id: ${base.id})` : base.name
+		})) };
+	}
+});
+//#endregion
+//#region src/dataSources/selectRecord.ts
+const selectRecord = (0, _prismatic_io_spectral.dataSource)({
+	dataSourceType: "picklist",
+	display: {
+		label: "Select Record",
+		description: "Select a record from a table."
+	},
+	inputs: selectRecordInputs,
+	perform: async (context, { airtableConnection, baseId, tableName, includeId }) => {
+		return { result: (await paginateData(createAirtableClient(airtableConnection), `/v0/${baseId}/${tableName}`, "records", {}, true)).map((record) => {
+			const label = includeId ? `${record.fields.Name} (id: ${record.id})` : record.fields.Name;
+			return {
+				key: record.id,
+				label: _prismatic_io_spectral.util.types.toString(label)
+			};
+		}) };
+	}
+});
+//#endregion
+//#region src/dataSources/index.ts
+var dataSources_default = {
+	selectBase,
+	selectTable: (0, _prismatic_io_spectral.dataSource)({
+		dataSourceType: "picklist",
+		display: {
+			label: "Select Table",
+			description: "Select a table from an Airtable base."
+		},
+		inputs: selectTableInputs,
+		perform: async (context, params) => {
+			return { result: (await paginateData(createAirtableClient(params.airtableConnection), `/v0/meta/bases/${params.baseId}/tables`, "tables", {}, true)).map((table) => ({
+				key: table.id,
+				label: params.includeId ? `${table.name} (id: ${table.id})` : table.name
+			})) };
+		}
+	}),
+	selectWebhook: (0, _prismatic_io_spectral.dataSource)({
+		dataSourceType: "picklist",
+		display: {
+			label: "Select Webhook",
+			description: "Select a webhook subscription from an Airtable base."
+		},
+		inputs: selectWebhookInputs,
+		perform: async (context, { airtableConnection, baseId, includeId }) => {
+			const { data } = await createAirtableClient(airtableConnection).get(`/v0/bases/${baseId}/webhooks`);
+			return { result: data.webhooks.map((webhook) => {
+				const label = includeId ? `${webhook.notificationUrl} (id: ${webhook.id})` : webhook.notificationUrl;
+				return {
+					key: webhook.id,
+					label: _prismatic_io_spectral.util.types.toString(label)
+				};
+			}) };
+		}
+	}),
+	selectRecord
+};
+//#endregion
+//#region src/helpers/triggers/webhookExists.ts
+const webhookExists = async ({ client, baseId, webhookId }) => {
+	try {
+		await client.get(`/v0/bases/${baseId}/webhooks/${webhookId}/payloads`);
+		return true;
+	} catch (e) {
+		const error = e;
+		if (error.message.includes("404")) return false;
+		throw new Error(`Failed to check if webhook exists: ${error.message}`);
+	}
+};
+//#endregion
+//#region src/helpers/triggers/baseChangesCreate.ts
+const baseChangesCreate = async ({ flow, webhookUrls, crossFlowState, logger, debug }, { airtableConnection, baseId, dataTypes, recordChangeScope }) => {
+	const integrationFlowName = flow.name;
+	const encodedId = getBase64FromUrl(webhookUrls[integrationFlowName]);
+	const baseChangesState = crossFlowState?.[encodedId] || {};
+	let stateWebhookId = baseChangesState.webhookId || "";
+	const stateBaseId = baseChangesState.baseId || "";
+	const stateDataTypes = baseChangesState.dataTypes || [];
+	const stateRecordChangeScope = baseChangesState.recordChangeScope || "";
+	const sameConfig = `${stateBaseId}${stateDataTypes.join(",")}${stateRecordChangeScope}` === `${baseId}${dataTypes.join(",")}${recordChangeScope || ""}`;
+	const client = createAirtableClient(airtableConnection, debug.enabled);
+	if (stateWebhookId) {
+		if (!await webhookExists({
+			client,
+			baseId,
+			webhookId: stateWebhookId
+		})) {
+			logger.info(`Webhook ${stateWebhookId} from state is deleted or expired, resetting`);
+			stateWebhookId = "";
+		}
+	}
+	if (stateWebhookId && sameConfig) {
+		logger.info("Webhook already created with this configuration, skipping");
+		return;
+	}
+	if (stateWebhookId && !sameConfig) {
+		logger.info(`Config changed, deleting previous webhook ${stateWebhookId}`);
+		try {
+			await client.delete(`/v0/bases/${stateBaseId}/webhooks/${stateWebhookId}`);
+		} catch (e) {
+			if (e.message.includes("404")) logger.info("Webhook already deleted (404), skipping");
+			else throw e;
+		}
+	}
+	const webhookUrl = webhookUrls[flow.name];
+	logger.info(`Creating Airtable webhook for base ${baseId} at ${webhookUrl}`);
+	const specification = { options: { filters: { dataTypes: dataTypes || ["tableData"] } } };
+	if (recordChangeScope) specification.options.filters.recordChangeScope = recordChangeScope;
+	const { data: webhook } = await client.post(`/v0/bases/${baseId}/webhooks`, {
+		notificationUrl: webhookUrl,
+		specification
+	});
+	crossFlowState[encodedId] = {
+		webhookId: webhook.id,
+		macSecret: webhook.macSecretBase64,
+		expirationTime: webhook.expirationTime,
+		baseId,
+		cursor: null,
+		dataTypes,
+		recordChangeScope,
+		webhookUrl,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	if (debug.enabled) logger.debug("Stored state", JSON.stringify(crossFlowState[encodedId], null, 2));
+	logger.info(`Airtable webhook created successfully (ID: ${webhook.id}, expires: ${webhook.expirationTime})`);
+};
+//#endregion
+//#region src/helpers/triggers/baseChangesDelete.ts
+const baseChangesDelete = async ({ flow, webhookUrls, crossFlowState, logger, debug }, { airtableConnection }) => {
+	const integrationFlowName = flow.name;
+	const encodedId = getBase64FromUrl(webhookUrls[integrationFlowName]);
+	const { webhookId, baseId } = crossFlowState?.[encodedId] || {};
+	if (!webhookId) {
+		logger.warn("No webhook ID found in instance state, skipping deletion");
+		return;
+	}
+	const client = createAirtableClient(airtableConnection, debug.enabled);
+	logger.info(`Deleting Airtable webhook ${webhookId} from base ${baseId}`);
+	try {
+		await client.delete(`/v0/bases/${baseId}/webhooks/${webhookId}`);
+		logger.info("Airtable webhook deleted successfully");
+	} catch (e) {
+		if (e.message.includes("404")) logger.info("Webhook already deleted (404), skipping");
+		else throw e;
+	} finally {
+		if (crossFlowState[encodedId]) delete crossFlowState[encodedId];
+	}
+};
+//#endregion
+//#region src/helpers/triggers/autoRefreshWebhook.ts
+const autoRefreshWebhook = async ({ client, baseId, webhookId, expirationTime, logger, debug }) => {
+	if (needsRefresh(expirationTime)) {
+		if (debug) logger.info(`Webhook expiring soon (${expirationTime}), refreshing...`);
+		try {
+			const { data: refreshData } = await client.post(`/v0/bases/${baseId}/webhooks/${webhookId}/refresh`);
+			if (debug) logger.info(`Webhook expiration refreshed (new expiration: ${refreshData.expirationTime})`);
+			return refreshData.expirationTime;
+		} catch (e) {
+			const error = e;
+			if (debug) logger.error(`Failed to refresh webhook: ${error.message}`);
+			return expirationTime;
+		}
+	}
+	return expirationTime;
+};
+//#endregion
+//#region src/helpers/triggers/listWebhookPayloads.ts
+const listWebhookPayloads = async ({ client, baseId, webhookId, lastCursor, logger, debug }) => {
+	const allPayloads = [];
+	let currentCursor = lastCursor;
+	let mightHaveMore = true;
+	if (debug) logger.info(`Fetching webhook payloads (starting cursor: ${currentCursor || "null"})`);
+	while (mightHaveMore) {
+		const url = currentCursor ? `/v0/bases/${baseId}/webhooks/${webhookId}/payloads?cursor=${currentCursor}` : `/v0/bases/${baseId}/webhooks/${webhookId}/payloads`;
+		const { data: payloadData } = await client.get(url);
+		allPayloads.push(...payloadData.payloads);
+		currentCursor = payloadData.cursor;
+		mightHaveMore = payloadData.mightHaveMore;
+		if (debug) logger.debug(`Fetched ${payloadData.payloads.length} payloads (cursor: ${currentCursor}, mightHaveMore: ${mightHaveMore})`);
+	}
+	return {
+		allPayloads,
+		currentCursor
+	};
+};
+//#endregion
+//#region src/helpers/triggers/validateMacSignature.ts
+const validateMacSignature = ({ macSecret, payload, logger, debug }) => {
+	const macHeader = _prismatic_io_spectral.util.types.lowerCaseHeaders(payload.headers)["x-airtable-content-mac"];
+	if (!macHeader) throw new Error("No MAC header found in request");
+	const macSecretDecoded = Buffer.from(macSecret, "base64");
+	const bodyString = Buffer.isBuffer(payload.rawBody.data) ? payload.rawBody.data.toString("utf8") : JSON.stringify(payload.rawBody.data);
+	const hmac = (0, node_crypto.createHmac)("sha256", macSecretDecoded);
+	hmac.update(bodyString, "utf8");
+	const expectedContentHmac = `hmac-sha256=${hmac.digest("hex")}`;
+	if (debug) logger.debug("MAC validation details", {
+		macHeader,
+		expectedContentHmac,
+		bodyPreview: bodyString.substring(0, 100)
+	});
+	if (macHeader !== expectedContentHmac) throw new Error("Invalid MAC signature - request not from Airtable or using incorrect secret");
+	if (debug) logger.debug("MAC signature validated successfully");
+};
+//#endregion
+//#region src/helpers/triggers/baseChangesPerform.ts
+const baseChangesPerform = async ({ flow, webhookUrls, crossFlowState, logger, debug }, payload, { airtableConnection, baseId }) => {
+	const integrationFlowName = flow.name;
+	const encodedId = getBase64FromUrl(webhookUrls[integrationFlowName]);
+	const baseChangesState = crossFlowState?.[encodedId] || {};
+	if (debug) logger.debug("Base changes state", JSON.stringify(baseChangesState, null, 2));
+	const { webhookId, expirationTime, cursor: lastCursor, macSecret } = baseChangesState;
+	if (!webhookId || !expirationTime || !macSecret) throw new Error("Missing required instance state properties, cannot process payload");
+	const client = createAirtableClient(airtableConnection, debug.enabled);
+	if (!await webhookExists({
+		client,
+		baseId,
+		webhookId
+	})) throw new Error(`Webhook ${webhookId} is deleted or expired, cannot process payload`);
+	if (_prismatic_io_spectral.util.types.lowerCaseHeaders(payload.headers)["prismatic-invoke-type"] === "Scheduled") {
+		logger.info(`${integrationFlowName} Trigger invoked by schedule - refreshing webhook`);
+		const newExpirationTime = await autoRefreshWebhook({
+			client,
+			baseId,
+			webhookId,
+			expirationTime,
+			logger,
+			debug: debug.enabled
+		});
+		crossFlowState[encodedId] = {
+			...baseChangesState,
+			expirationTime: newExpirationTime
+		};
+		return {
+			payload: {
+				...payload,
+				body: { data: {
+					expirationTime: newExpirationTime,
+					message: "Webhook refreshed"
+				} }
+			},
+			branch: "Refresh"
+		};
+	}
+	validateMacSignature({
+		macSecret,
+		payload,
+		logger,
+		debug: debug.enabled
+	});
+	const { allPayloads, currentCursor } = await listWebhookPayloads({
+		client,
+		baseId,
+		webhookId,
+		lastCursor,
+		logger,
+		debug: debug.enabled
+	});
+	const newExpirationTime = await autoRefreshWebhook({
+		client,
+		baseId,
+		webhookId,
+		expirationTime,
+		logger,
+		debug: debug.enabled
+	});
+	crossFlowState[encodedId] = {
+		...baseChangesState,
+		cursor: currentCursor,
+		expirationTime: newExpirationTime
+	};
+	if (debug) logger.info(`Retrieved ${allPayloads.length} total payloads, stored cursor: ${currentCursor}`);
+	return {
+		payload: {
+			...payload,
+			body: { data: {
+				notification: payload.body.data,
+				payloads: allPayloads,
+				payloadCount: allPayloads.length,
+				cursor: currentCursor
+			} }
+		},
+		branch: "Notification"
+	};
+};
+//#endregion
+//#region src/triggers/baseChanges.ts
+const baseChanges = (0, _prismatic_io_spectral.trigger)({
+	display: {
+		label: "Base Change Notifications",
+		description: "Receive base change notifications from Airtable. Automatically creates and manages a webhook subscription when the instance is deployed, and removes the subscription when the instance is deleted."
+	},
+	webhookLifecycleHandlers: {
+		create: baseChangesCreate,
+		delete: baseChangesDelete
+	},
+	perform: baseChangesPerform,
+	inputs: baseChangesInputs,
+	synchronousResponseSupport: "invalid",
+	scheduleSupport: "valid",
+	allowsBranching: true,
+	staticBranchNames: ["Notification", "Refresh"],
+	examplePayload: baseChangesTriggerExamplePayload
+});
+const fetchAirtableRecordsSince = async (connection, baseId, tableNameOrId, lastPolledAtIso, debug, maxPages, view, additionalFilter, resumeOffset) => {
+	const client = createAirtableClient(connection, debug);
+	const modifiedFilter = `IS_AFTER(LAST_MODIFIED_TIME(), DATETIME_PARSE("${lastPolledAtIso}"))`;
+	const filterByFormula = additionalFilter ? `AND(${additionalFilter}, ${modifiedFilter})` : modifiedFilter;
+	const records = [];
+	let offset = resumeOffset;
+	let pages = 0;
+	do {
+		const { data } = await client.get(`/v0/${baseId}/${tableNameOrId}`, { params: {
+			filterByFormula,
+			pageSize: 100,
+			...view && { view },
+			...offset && { offset }
+		} });
+		records.push(...data.records ?? []);
+		offset = data.offset;
+		pages++;
+	} while (offset && pages < maxPages);
+	return {
+		records,
+		offset
+	};
+};
+const partitionRecordsByTimestamp = (records, boundaryIso, opts) => {
+	const boundary = new Date(boundaryIso);
+	const created = [];
+	const updated = [];
+	for (const record of records) {
+		const createdAt = typeof record.createdTime === "string" ? new Date(record.createdTime) : null;
+		const isNew = createdAt !== null && createdAt > boundary;
+		if (isNew && (opts.isBackfill || opts.showNewRecords)) created.push(record);
+		else if (!isNew && (opts.isBackfill || opts.showUpdatedRecords)) updated.push(record);
+	}
+	return {
+		created,
+		updated
+	};
+};
+//#endregion
+//#region src/triggers/pollChangesTrigger.ts
+const pollChangesTrigger = (0, _prismatic_io_spectral.pollingTrigger)({
+	display: {
+		label: "New and Updated Records",
+		description: "Retrieves existing and ongoing records in a specified Airtable table. Load history once, check for changes on a schedule, or both."
+	},
+	examplePayload: pollChangesTriggerExamplePayload,
+	inputs: pollChangesInputs,
+	triggerResolverSupport: "valid",
+	batchConfig: { batchSize: 50 },
+	triggerResolver: {
+		resolveItems: (_context, { payload }) => resolvePollingRecordChanges(payload.body.data),
+		getNextPaginationState: (_context, { payload }) => payload.paginationState ?? null
+	},
+	perform: async (context, payload, params) => {
+		const incoming = payload.paginationState;
+		const now = incoming?.drainStartedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+		const state = context.polling.getState() ?? {};
+		const seedSince = params.lookBackDate ? new Date(params.lookBackDate).toISOString() : now;
+		const lastPolledAt = state.lastPolledAt ?? seedSince;
+		const isBackfill = state.backfillActive === true || !state.lastPolledAt && Boolean(params.lookBackDate);
+		const maxPages = context.batch?.enabled === true ? 1 : 100;
+		const { records, offset } = await fetchAirtableRecordsSince(params.airtableConnection, params.baseId, params.tableName, lastPolledAt, context.debug.enabled, maxPages, params.pollView, params.additionalFilter, incoming?.offset);
+		const endOfStream = !offset;
+		const result = partitionRecordsByTimestamp(records, lastPolledAt, {
+			isBackfill,
+			showNewRecords: params.showNewRecords !== false,
+			showUpdatedRecords: params.showUpdatedRecords !== false
+		});
+		const nextCursor = endOfStream ? null : {
+			offset,
+			drainStartedAt: now
+		};
+		let advancedCursor = lastPolledAt;
+		if (!endOfStream && context.batch?.enabled !== true) {
+			advancedCursor = records.map((r) => r.createdTime).filter((t) => typeof t === "string").sort().pop() ?? lastPolledAt;
+			context.logger.warn(`Polling truncated at the page cap for table ${params.tableName}. Advancing cursor to ${advancedCursor}; next poll resumes from there.`);
+		}
+		context.polling.setState({
+			lastPolledAt: endOfStream ? now : advancedCursor,
+			...isBackfill && !endOfStream ? { backfillActive: true } : {}
+		});
+		return {
+			payload: {
+				...payload,
+				paginationState: nextCursor ?? void 0,
+				body: { data: result }
+			},
+			polledNoChanges: (result.created?.length ?? 0) === 0 && (result.updated?.length ?? 0) === 0 && nextCursor === null && !incoming
+		};
+	}
+});
+//#endregion
+//#region src/triggers/index.ts
+var triggers_default = {
+	webhook: (0, _prismatic_io_spectral.trigger)({
+		display: {
+			label: "Webhook",
+			description: "Receive and validate webhook requests from Airtable for manually configured webhook subscriptions."
+		},
+		perform: async (context, payload) => {
+			return Promise.resolve({ payload });
+		},
+		inputs: webhookInputs,
+		synchronousResponseSupport: "invalid",
+		scheduleSupport: "invalid"
+	}),
+	baseChanges,
+	pollChangesTrigger
+};
+//#endregion
+//#region src/index.ts
+var src_default = (0, _prismatic_io_spectral.component)({
+	key: "airtable",
+	documentationUrl: "https://prismatic.io/docs/components/airtable/",
+	public: true,
+	display: {
+		label: "Airtable",
+		description: "Manage records, tables, and bases in Airtable.",
+		iconPath: "icon.png",
+		category: "Data Platforms"
+	},
+	actions: actions_default,
+	connections: connections_default,
+	dataSources: dataSources_default,
+	triggers: triggers_default,
+	hooks: { error: _prismatic_io_spectral_http.handleErrors }
+});
+//#endregion
+//#region npm-dist/.entry.ts
+var _entry_default = (0, _prismatic_io_spectral.callableComponent)(src_default);
+//#endregion
+module.exports = _entry_default;