@prismatic-io/components-google-calendar 0.0.0-stage → 0.0.1

package/npm-dist/index.cjs

@@ -0,0 +1,1617 @@
+let _prismatic_io_spectral = require("@prismatic-io/spectral");
+let _prismatic_io_spectral_http = require("@prismatic-io/spectral/http");
+let _googleapis_calendar = require("@googleapis/calendar");
+let uuid = require("uuid");
+//#region src/connections.ts
+const googleConnection = (0, _prismatic_io_spectral.oauth2Connection)({
+	oauth2Type: _prismatic_io_spectral.OAuth2Type.AuthorizationCode,
+	key: "oauth2",
+	display: {
+		label: "OAuth 2.0",
+		description: "OAuth 2.0 connection for Google Calendar"
+	},
+	inputs: {
+		authorizeUrl: {
+			label: "Authorize URL",
+			placeholder: "Enter OAuth 2.0 Authorization URL",
+			type: "string",
+			required: true,
+			shown: false,
+			comments: "The OAuth 2.0 Authorization URL for Google Calendar API.",
+			default: "https://accounts.google.com/o/oauth2/v2/auth?access_type=offline&prompt=consent"
+		},
+		tokenUrl: {
+			label: "Token URL",
+			placeholder: "Enter OAuth 2.0 Token URL",
+			type: "string",
+			required: true,
+			shown: false,
+			comments: "The OAuth 2.0 Token URL for Google Calendar API.",
+			default: "https://oauth2.googleapis.com/token"
+		},
+		scopes: {
+			label: "Scopes",
+			placeholder: "Enter OAuth scopes (space-delimited)",
+			type: "string",
+			required: false,
+			shown: true,
+			comments: "Space-delimited list of OAuth 2.0 scopes. See [Google Calendar API scopes](https://developers.google.com/calendar/api/auth) for available options.",
+			default: "https://www.googleapis.com/auth/calendar"
+		},
+		clientId: {
+			label: "Client ID",
+			placeholder: "Enter Client ID",
+			type: "string",
+			required: true,
+			example: "123456789012-abc123def456ghi789jkl012mno345pq.apps.googleusercontent.com",
+			comments: "Client ID from your Google Cloud Platform OAuth 2.0 credentials.",
+			shown: true
+		},
+		clientSecret: {
+			label: "Client Secret",
+			placeholder: "Enter Client Secret",
+			type: "password",
+			example: "GOCSPX-abcd1234efgh5678ijkl",
+			comments: "Client Secret from your Google Cloud Platform OAuth 2.0 credentials.",
+			required: true,
+			shown: true
+		}
+	}
+});
+var connections_default = [googleConnection];
+//#endregion
+//#region src/client.ts
+const validateConnection = (connection) => {
+	if (connection.key !== googleConnection.key) throw new _prismatic_io_spectral.ConnectionError(connection, "Unknown Connection type provided.");
+	if (!connection.token?.access_token) throw new _prismatic_io_spectral.ConnectionError(connection, "Received valid Connection type but did not find valid access token.");
+};
+const createClient = ({ connection }) => {
+	validateConnection(connection);
+	const oauth2Client = new _googleapis_calendar.auth.OAuth2(_prismatic_io_spectral.util.types.toString(connection.fields.clientId), _prismatic_io_spectral.util.types.toString(connection.fields.clientSecret));
+	const token = _prismatic_io_spectral.util.types.toString(connection.token.access_token);
+	oauth2Client.setCredentials({ access_token: token });
+	return (0, _googleapis_calendar.calendar)({
+		version: "v3",
+		auth: oauth2Client
+	});
+};
+const getAccessToken = ({ connection }) => {
+	validateConnection(connection);
+	return _prismatic_io_spectral.util.types.toString(connection.token.access_token);
+};
+//#endregion
+//#region src/utils/cleanInputs.ts
+const YYYY_MM_DD = /^\d{4}-\d{2}-\d{2}$/;
+const lookBackDateClean = (value) => {
+	const raw = _prismatic_io_spectral.util.types.toString(value).trim();
+	if (!raw) return "";
+	if (!YYYY_MM_DD.test(raw)) throw new Error("Look-back Date must be in YYYY-MM-DD format.");
+	const parsed = /* @__PURE__ */ new Date(`${raw}T00:00:00Z`);
+	if (Number.isNaN(parsed.getTime())) throw new Error("Look-back Date is not a valid calendar date.");
+	const [y, m, d] = raw.split("-").map(Number);
+	if (parsed.getUTCFullYear() !== y || parsed.getUTCMonth() + 1 !== m || parsed.getUTCDate() !== d) throw new Error("Look-back Date is not a valid calendar date.");
+	if (parsed.getTime() > Date.now()) throw new Error("Look-back Date cannot be a future date.");
+	return raw;
+};
+//#endregion
+//#region src/inputs.ts
+const calendarId = (0, _prismatic_io_spectral.input)({
+	label: "Calendar ID",
+	type: "string",
+	required: true,
+	placeholder: "Enter Calendar ID",
+	example: "en.usa#holiday@group.v.calendar.google.com",
+	comments: "The unique identifier of the calendar. Use 'primary' for the user's primary calendar.",
+	clean: _prismatic_io_spectral.util.types.toString,
+	dataSource: "selectCalendar"
+});
+const startTime = (0, _prismatic_io_spectral.input)({
+	label: "Start Time",
+	type: "string",
+	required: true,
+	placeholder: "Enter start time (ISO 8601 format)",
+	example: "2026-05-28T17:00:00-07:00",
+	comments: "The start time of the event in ISO 8601 format with timezone offset."
+});
+const timeZone = (0, _prismatic_io_spectral.input)({
+	label: "Time Zone",
+	type: "string",
+	required: true,
+	placeholder: "Enter timezone (IANA format)",
+	example: "America/Chicago",
+	comments: "The timezone of the event in IANA Time Zone Database format. See [IANA timezone list](https://www.iana.org/time-zones)."
+});
+const endTime = (0, _prismatic_io_spectral.input)({
+	label: "End Time",
+	type: "string",
+	required: true,
+	placeholder: "Enter end time (ISO 8601 format)",
+	example: "2026-05-28T19:00:00-07:00",
+	comments: "The end time of the event in ISO 8601 format with timezone offset."
+});
+const summary = (0, _prismatic_io_spectral.input)({
+	label: "Summary",
+	type: "string",
+	required: true,
+	placeholder: "Enter event summary",
+	example: "Team Standup Meeting",
+	comments: "The title or summary of the event."
+});
+const description = (0, _prismatic_io_spectral.input)({
+	label: "Description",
+	type: "string",
+	required: true,
+	placeholder: "Enter event description",
+	example: "Discuss sprint progress and blockers",
+	comments: "A detailed description of the event."
+});
+const attendees = (0, _prismatic_io_spectral.input)({
+	label: "Attendees",
+	type: "code",
+	default: JSON.stringify([{
+		email: "john.doe@example.com",
+		optional: false
+	}, {
+		email: "jane.smith@example.com",
+		optional: true
+	}], null, 2),
+	language: "json",
+	required: false,
+	comments: "Array of attendee objects with email addresses and optional flags. See [Google Calendar Events API](https://developers.google.com/calendar/api/v3/reference/events/insert) for full schema.",
+	clean: (value) => value ? _prismatic_io_spectral.util.types.toObject(value) : void 0
+});
+const remindMethod = (0, _prismatic_io_spectral.input)({
+	label: "Remind Method",
+	type: "string",
+	model: [{
+		label: "Email",
+		value: "email"
+	}, {
+		label: "Popup",
+		value: "popup"
+	}],
+	required: false,
+	placeholder: "Select reminder method",
+	comments: "How to send the event reminder. Only used when 'Default Reminder' is false."
+});
+const remindMinutes = (0, _prismatic_io_spectral.input)({
+	label: "Remind Before (minutes)",
+	type: "string",
+	required: false,
+	placeholder: "Enter minutes before event",
+	example: "30",
+	comments: "Number of minutes before the event to send the reminder. Only used when 'Default Reminder' is false."
+});
+const eventLocation = (0, _prismatic_io_spectral.input)({
+	label: "Event Location",
+	type: "string",
+	required: false,
+	placeholder: "Enter event location",
+	example: "Conference Room A, Building 3",
+	comments: "The physical or virtual location of the event."
+});
+const eventId = (0, _prismatic_io_spectral.input)({
+	label: "Event ID",
+	type: "string",
+	required: true,
+	placeholder: "Enter Event ID",
+	dataSource: "selectEvent",
+	example: "20260101_q8ue475rr4p7opsd4c0lr7g5pg",
+	comments: "The unique identifier of the event."
+});
+const useDefaultReminder = (0, _prismatic_io_spectral.input)({
+	label: "Default Reminder",
+	type: "boolean",
+	required: true,
+	comments: "When true, the event uses the default reminder settings from the calendar."
+});
+const maxResults = (0, _prismatic_io_spectral.input)({
+	label: "Max Results",
+	type: "string",
+	required: false,
+	placeholder: "Enter maximum number of results (1-250)",
+	comments: "Maximum number of results to return (1-250).",
+	example: "50",
+	clean: (value) => value !== "" ? _prismatic_io_spectral.util.types.toInt(value) : void 0
+});
+const pageToken = (0, _prismatic_io_spectral.input)({
+	label: "Page Token",
+	type: "string",
+	required: false,
+	placeholder: "Enter page token from previous response",
+	comments: "Pagination token returned from a previous request to retrieve the next page of results.",
+	example: "lslTXFcbLQKkb0vP9Kgh5hy0Y0OnC7Z9ZPHPwPmMnxSk3eiDRMkct7D8E",
+	clean: (value) => value !== "" ? _prismatic_io_spectral.util.types.toString(value) : void 0
+});
+const syncToken = (0, _prismatic_io_spectral.input)({
+	label: "Sync Token",
+	type: "string",
+	required: false,
+	placeholder: "Enter sync token from previous response",
+	comments: "Token for retrieving only resources modified since the last sync request.",
+	example: "lslTXFcbLQKkb0vP9Kgh5hy0Y0OnC7Z9ZPHPwPmMnxSk3eiDRMkct7D8E",
+	clean: (value) => value !== "" ? _prismatic_io_spectral.util.types.toString(value) : void 0
+});
+const connectionInput = (0, _prismatic_io_spectral.input)({
+	label: "Connection",
+	type: "connection",
+	required: true,
+	comments: "The Google Calendar connection to use."
+});
+const addConferenceEvent = (0, _prismatic_io_spectral.input)({
+	label: "Add Conference Event",
+	type: "boolean",
+	default: "false",
+	required: false,
+	comments: "When true, creates a Google Meet conference link for the event.",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const sendUpdates = (0, _prismatic_io_spectral.input)({
+	label: "Send Updates",
+	type: "string",
+	model: [
+		{
+			label: "",
+			value: ""
+		},
+		{
+			label: "All",
+			value: "all"
+		},
+		{
+			label: "External Only",
+			value: "externalOnly"
+		},
+		{
+			label: "None",
+			value: "none"
+		}
+	],
+	required: false,
+	default: "",
+	comments: "Whether to send notifications about the creation of the new event. Note that some emails might still be sent. The default is false.",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const selectCalendarInputs = { connection: connectionInput };
+const selectEventInputs = {
+	connection: connectionInput,
+	calendarId: {
+		...calendarId,
+		comments: "Calendar ID to get events from.",
+		dataSource: void 0
+	}
+};
+const fetchAll = (0, _prismatic_io_spectral.input)({
+	label: "Fetch All",
+	type: "boolean",
+	required: false,
+	comments: "When true, fetches all pages of results, ignoring the 'Max Results' and 'Page Token' inputs.",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const calendarChangeEventsInputs = {
+	connection: connectionInput,
+	calendarId: {
+		...calendarId,
+		comments: "The calendar to monitor for changes."
+	}
+};
+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.",
+	example: "2026-01-01",
+	clean: lookBackDateClean
+});
+const pollEventsTriggerInputs = {
+	connection: connectionInput,
+	calendarId: {
+		...calendarId,
+		comments: "The calendar to poll for event changes."
+	},
+	lookBackDate
+};
+//#endregion
+//#region src/parseReturn.ts
+const parseReturn = (config) => {
+	Object.fromEntries(Object.entries(config).filter(([key]) => !["paramsSerializer", "validateStatus"].includes(key)));
+};
+//#endregion
+//#region src/actions/createCalendar.ts
+const createCalendar = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Create Calendar",
+		description: "Create a new calendar"
+	},
+	perform: async (_context, params) => {
+		const { config, ...base } = await createClient({ connection: params.googleConnection }).calendars.insert({ requestBody: {
+			summary: _prismatic_io_spectral.util.types.toString(params.summary),
+			timeZone: _prismatic_io_spectral.util.types.toString(params.timeZone),
+			description: _prismatic_io_spectral.util.types.toString(params.description)
+		} });
+		return { data: {
+			config: parseReturn(config),
+			...base
+		} };
+	},
+	inputs: {
+		summary,
+		description,
+		timeZone,
+		googleConnection: connectionInput
+	}
+});
+//#endregion
+//#region src/actions/createEvent.ts
+const createEvent = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Create Event",
+		description: "Create a new event in a given calendar"
+	},
+	perform: async (_context, params) => {
+		const useDefaultReminder = _prismatic_io_spectral.util.types.toBool(params.useDefaultReminder);
+		const remindMethod = _prismatic_io_spectral.util.types.toString(params.remindMethod);
+		const remindMinutes = _prismatic_io_spectral.util.types.toString(params.remindMinutes);
+		const { config, ...base } = await createClient({ connection: params.connection }).events.insert({
+			calendarId: _prismatic_io_spectral.util.types.toString(params.calendarId),
+			...params.addConferenceEvent && { conferenceDataVersion: 1 },
+			requestBody: {
+				...params.addConferenceEvent && { conferenceData: { createRequest: {
+					requestId: (0, uuid.v4)(),
+					conferenceSolutionKey: { type: "hangoutsMeet" }
+				} } },
+				summary: _prismatic_io_spectral.util.types.toString(params.summary),
+				location: _prismatic_io_spectral.util.types.toString(params.eventLocation),
+				description: _prismatic_io_spectral.util.types.toString(params.description),
+				start: {
+					dateTime: _prismatic_io_spectral.util.types.toString(params.startTime),
+					timeZone: _prismatic_io_spectral.util.types.toString(params.timeZone)
+				},
+				end: {
+					dateTime: _prismatic_io_spectral.util.types.toString(params.endTime),
+					timeZone: _prismatic_io_spectral.util.types.toString(params.timeZone)
+				},
+				attendees: params.attendees,
+				reminders: {
+					...!useDefaultReminder && remindMethod && remindMinutes && { overrides: [{
+						method: remindMethod,
+						minutes: _prismatic_io_spectral.util.types.toInt(remindMinutes)
+					}] },
+					useDefault: useDefaultReminder
+				}
+			},
+			sendUpdates: params.sendUpdates || void 0
+		});
+		return { data: {
+			config: parseReturn(config),
+			...base
+		} };
+	},
+	inputs: {
+		calendarId,
+		summary,
+		description,
+		timeZone,
+		startTime,
+		endTime,
+		eventLocation,
+		attendees,
+		remindMethod,
+		useDefaultReminder,
+		remindMinutes,
+		addConferenceEvent,
+		connection: connectionInput,
+		sendUpdates
+	}
+});
+//#endregion
+//#region src/actions/deleteCalendar.ts
+const deleteCalendar = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Delete Calendar",
+		description: "Delete an existing calendar by Id"
+	},
+	perform: async (_context, params) => {
+		const { config, ...base } = await createClient({ connection: params.connection }).calendarList.delete({ calendarId: _prismatic_io_spectral.util.types.toString(params.calendarId) });
+		return { data: {
+			config: parseReturn(config),
+			...base
+		} };
+	},
+	inputs: {
+		calendarId,
+		connection: connectionInput
+	}
+});
+//#endregion
+//#region src/actions/deleteEvent.ts
+const deleteEvent = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Delete Event",
+		description: "Delete an event by an Id"
+	},
+	perform: async (_context, params) => {
+		const { config, ...base } = await createClient({ connection: params.connection }).events.delete({
+			calendarId: _prismatic_io_spectral.util.types.toString(params.calendarId),
+			eventId: _prismatic_io_spectral.util.types.toString(params.eventId),
+			sendUpdates: params.sendUpdates || void 0
+		});
+		return { data: {
+			config: parseReturn(config),
+			...base
+		} };
+	},
+	inputs: {
+		calendarId,
+		eventId,
+		connection: connectionInput,
+		sendUpdates: {
+			...sendUpdates,
+			comments: "Guests who should receive notifications about the deletion of the event."
+		}
+	}
+});
+//#endregion
+//#region src/actions/getCalendar.ts
+const getCalendar = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Get Calendar",
+		description: "Get the information and metadata of a calendar by Id"
+	},
+	perform: async (_context, params) => {
+		const { config, ...base } = await createClient({ connection: params.connection }).calendars.get({ calendarId: _prismatic_io_spectral.util.types.toString(params.calendarId) });
+		return { data: {
+			config: parseReturn(config),
+			...base
+		} };
+	},
+	inputs: {
+		connection: connectionInput,
+		calendarId
+	}
+});
+//#endregion
+//#region src/actions/getEvent.ts
+const getEvent = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Get Event",
+		description: "Get the information and metadata of an event by Id"
+	},
+	perform: async (_context, params) => {
+		const { config, ...base } = await createClient({ connection: params.connection }).events.get({
+			calendarId: _prismatic_io_spectral.util.types.toString(params.calendarId),
+			eventId: _prismatic_io_spectral.util.types.toString(params.eventId)
+		});
+		return { data: {
+			config: parseReturn(config),
+			...base
+		} };
+	},
+	inputs: {
+		calendarId,
+		eventId,
+		connection: connectionInput
+	}
+});
+//#endregion
+//#region src/helpers/listAllCalendars.ts
+const listAllCalendars = async (params) => {
+	const client = createClient({ connection: params.connection });
+	const MAX_RESULTS = 250;
+	if (params.fetchAll) params.pageToken = void 0;
+	const maxResults = params.fetchAll ? MAX_RESULTS : _prismatic_io_spectral.util.types.toInt(params.maxResults) || void 0;
+	let calendarList = await client.calendarList.list({
+		pageToken: _prismatic_io_spectral.util.types.toString(params.pageToken) || void 0,
+		maxResults
+	});
+	let nextPageToken = calendarList.data.nextPageToken;
+	if (!params.fetchAll || !nextPageToken) return calendarList;
+	const allItems = [...calendarList.data.items];
+	while (nextPageToken) {
+		calendarList = await client.calendarList.list({
+			pageToken: nextPageToken,
+			maxResults
+		});
+		allItems.push(...calendarList.data.items);
+		nextPageToken = calendarList.data.nextPageToken;
+	}
+	calendarList.data.items = allItems;
+	return calendarList;
+};
+//#endregion
+//#region src/actions/listCalendar.ts
+const listCalendar = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "List Calendars",
+		description: "List all calendars"
+	},
+	perform: async (_context, params) => {
+		const { config, ...base } = await listAllCalendars(params);
+		return { data: {
+			config: parseReturn(config),
+			...base
+		} };
+	},
+	inputs: {
+		pageToken,
+		maxResults,
+		connection: connectionInput,
+		fetchAll
+	}
+});
+//#endregion
+//#region src/helpers/listAllEvents.ts
+const listAllEvents = async (params) => {
+	const client = createClient({ connection: params.googleConnection });
+	const MAX_RESULTS = 250;
+	if (params.fetchAll) params.pageToken = void 0;
+	const maxResults = params.fetchAll ? MAX_RESULTS : _prismatic_io_spectral.util.types.toInt(params.maxResults) || void 0;
+	const requestParams = {
+		calendarId: params.calendarId,
+		maxResults,
+		pageToken: params.pageToken,
+		syncToken: params.syncToken,
+		maxAttendees: params.maxAttendees,
+		timeZone: params.timeZone,
+		q: params.q,
+		timeMax: params.timeMax,
+		timeMin: params.timeMin,
+		orderBy: params.orderBy,
+		singleEvents: params.singleEvents,
+		updatedMin: params.updatedMin,
+		showDeleted: params.showDeleted,
+		showHiddenInvitations: params.showHiddenInvitations
+	};
+	let eventsList = await client.events.list(requestParams);
+	let nextPageToken = eventsList.data.nextPageToken;
+	if (!params.fetchAll || !nextPageToken) return eventsList;
+	const allItems = [...eventsList.data.items];
+	while (nextPageToken) {
+		eventsList = await client.events.list({
+			...requestParams,
+			pageToken: nextPageToken
+		});
+		allItems.push(...eventsList.data.items);
+		nextPageToken = eventsList.data.nextPageToken;
+	}
+	eventsList.data.items = allItems;
+	return eventsList;
+};
+//#endregion
+//#region src/actions/listEvents.ts
+const listEvents = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "List Events",
+		description: "List all events in a given calendar"
+	},
+	perform: async (_context, params) => {
+		const { config, ...base } = await listAllEvents(params);
+		return { data: {
+			config: parseReturn(config),
+			...base
+		} };
+	},
+	inputs: {
+		googleConnection: connectionInput,
+		calendarId,
+		fetchAll,
+		maxResults,
+		pageToken,
+		syncToken,
+		maxAttendees: (0, _prismatic_io_spectral.input)({
+			label: "Max Attendees",
+			type: "string",
+			required: false,
+			placeholder: "Enter maximum attendees",
+			example: "10",
+			comments: "Maximum number of attendees to include in the response. If there are more attendees, only the participant is returned.",
+			clean: (value) => value !== "" ? _prismatic_io_spectral.util.types.toInt(value) : void 0
+		}),
+		orderBy: (0, _prismatic_io_spectral.input)({
+			label: "Order By",
+			type: "string",
+			model: [{
+				label: "Start Time",
+				value: "startTime"
+			}, {
+				label: "Updated",
+				value: "updated"
+			}],
+			required: false,
+			placeholder: "Select sort order",
+			comments: "The order of events returned in the result. Default is an unspecified, stable order.",
+			clean: (value) => value !== "" ? _prismatic_io_spectral.util.types.toString(value) : void 0
+		}),
+		q: (0, _prismatic_io_spectral.input)({
+			label: "Query",
+			type: "string",
+			required: false,
+			placeholder: "Enter search terms",
+			example: "team meeting",
+			comments: "Free text search terms to find events matching in summary, description, location, or attendee fields.",
+			clean: (value) => value !== "" ? _prismatic_io_spectral.util.types.toString(value) : void 0
+		}),
+		showDeleted: (0, _prismatic_io_spectral.input)({
+			label: "Show Deleted",
+			type: "boolean",
+			default: "false",
+			required: false,
+			comments: "When true, includes deleted events in the response.",
+			clean: _prismatic_io_spectral.util.types.toBool
+		}),
+		showHiddenInvitations: (0, _prismatic_io_spectral.input)({
+			label: "Show Hidden Invitations",
+			type: "boolean",
+			required: false,
+			comments: "When true, includes hidden invitations in the response.",
+			clean: _prismatic_io_spectral.util.types.toBool
+		}),
+		singleEvents: (0, _prismatic_io_spectral.input)({
+			label: "Single Events",
+			type: "boolean",
+			default: "false",
+			required: false,
+			comments: "When true, expands recurring events into instances and returns only single one-off events and instances, not the underlying recurring events.",
+			clean: _prismatic_io_spectral.util.types.toBool
+		}),
+		timeMin: (0, _prismatic_io_spectral.input)({
+			label: "Time Min",
+			type: "string",
+			required: false,
+			placeholder: "Enter start time (ISO 8601 format)",
+			example: "2026-06-03T10:00:00-07:00",
+			comments: "Lower bound for filtering events by end time. Must be in ISO 8601 format with timezone offset.",
+			clean: (value) => value !== "" ? _prismatic_io_spectral.util.types.toString(value) : void 0
+		}),
+		timeMax: (0, _prismatic_io_spectral.input)({
+			label: "Time Max",
+			type: "string",
+			required: false,
+			placeholder: "Enter end time (ISO 8601 format)",
+			example: "2026-06-03T10:00:00-07:00",
+			comments: "Upper bound for filtering events by start time. Must be in ISO 8601 format with timezone offset.",
+			clean: (value) => value !== "" ? _prismatic_io_spectral.util.types.toString(value) : void 0
+		}),
+		updatedMin: (0, _prismatic_io_spectral.input)({
+			label: "Updated Min",
+			type: "string",
+			required: false,
+			placeholder: "Enter minimum update time (RFC 3339)",
+			example: "2026-01-01T00:00:00Z",
+			comments: "Lower bound for filtering by last modification time (RFC 3339 format). Deleted entries since this time are always included regardless of 'Show Deleted' setting.",
+			clean: (value) => value !== "" ? _prismatic_io_spectral.util.types.toString(value) : void 0
+		}),
+		timeZone: (0, _prismatic_io_spectral.input)({
+			label: "Time Zone",
+			type: "string",
+			required: false,
+			placeholder: "Enter timezone (IANA format)",
+			example: "America/Chicago",
+			comments: "Time zone used in the response.",
+			clean: (value) => value !== "" ? _prismatic_io_spectral.util.types.toString(value) : void 0
+		})
+	}
+});
+//#endregion
+//#region src/actions/rawRequest.ts
+const { debugRequest: _, ...rawRequestInputs } = _prismatic_io_spectral_http.inputs;
+const rawRequest = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Raw Request",
+		description: "Send raw HTTP request to Google Calendar"
+	},
+	inputs: {
+		connection: connectionInput,
+		...rawRequestInputs,
+		url: {
+			...rawRequestInputs.url,
+			comments: "Input the path only (/colors), The base URL is already included (https://www.googleapis.com/calendar/v3). For example, to connect to https://www.googleapis.com/calendar/v3/colors, only /colors is entered in this field.",
+			example: "/colors"
+		}
+	},
+	perform: async (context, { connection, ...rawRequestInputs }) => {
+		const accessToken = getAccessToken({ connection });
+		try {
+			const { data } = await (0, _prismatic_io_spectral_http.sendRawRequest)("https://www.googleapis.com/calendar/v3", {
+				...rawRequestInputs,
+				debugRequest: context.debug.enabled
+			}, { Authorization: `Bearer ${accessToken}` });
+			return { data };
+		} catch (error) {
+			const handled = (0, _prismatic_io_spectral_http.handleErrors)(error);
+			const serialized = _prismatic_io_spectral.util.types.toJSON(handled);
+			throw new Error(serialized);
+		}
+	}
+});
+//#endregion
+//#region src/actions/index.ts
+var actions_default = {
+	listCalendar,
+	createCalendar,
+	getCalendar,
+	deleteCalendar,
+	listEvents,
+	createEvent,
+	getEvent,
+	updateEvent: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Update Event",
+			description: "Update the information and metadata of an existing event"
+		},
+		perform: async (_context, params) => {
+			const reminderMethod = _prismatic_io_spectral.util.types.toString(params.remindMethod);
+			const remindMinutes = _prismatic_io_spectral.util.types.toInt(params.remindMinutes);
+			const reminderInfoNeeded = reminderMethod && remindMinutes;
+			const { config, ...base } = await createClient({ connection: params.connection }).events.update({
+				calendarId: _prismatic_io_spectral.util.types.toString(params.calendarId),
+				eventId: _prismatic_io_spectral.util.types.toString(params.eventId),
+				requestBody: {
+					summary: _prismatic_io_spectral.util.types.toString(params.summary) || void 0,
+					location: _prismatic_io_spectral.util.types.toString(params.eventLocation) || void 0,
+					description: _prismatic_io_spectral.util.types.toString(params.description) || void 0,
+					start: {
+						dateTime: _prismatic_io_spectral.util.types.toString(params.startTime),
+						timeZone: _prismatic_io_spectral.util.types.toString(params.timeZone)
+					},
+					end: {
+						dateTime: _prismatic_io_spectral.util.types.toString(params.endTime),
+						timeZone: _prismatic_io_spectral.util.types.toString(params.timeZone)
+					},
+					attendees: params.attendees,
+					reminders: {
+						overrides: _prismatic_io_spectral.util.types.toBool(params.useDefaultReminder) !== true && reminderInfoNeeded ? [{
+							method: _prismatic_io_spectral.util.types.toString(params.remindMethod),
+							minutes: _prismatic_io_spectral.util.types.toInt(params.remindMinutes)
+						}] : void 0,
+						useDefault: _prismatic_io_spectral.util.types.toBool(params.useDefaultReminder)
+					}
+				},
+				sendUpdates: params.sendUpdates || void 0
+			});
+			return { data: {
+				config: parseReturn(config),
+				...base
+			} };
+		},
+		inputs: {
+			calendarId,
+			eventId,
+			summary: {
+				...summary,
+				required: false
+			},
+			description: {
+				...description,
+				required: false
+			},
+			timeZone,
+			startTime,
+			endTime,
+			eventLocation: {
+				...eventLocation,
+				required: false
+			},
+			attendees,
+			useDefaultReminder,
+			remindMethod,
+			remindMinutes,
+			connection: connectionInput,
+			sendUpdates: {
+				...sendUpdates,
+				comments: "Guests who should receive notifications about the event update (for example, title changes, etc.)."
+			}
+		}
+	}),
+	deleteEvent,
+	rawRequest
+};
+//#endregion
+//#region src/dataSources/index.ts
+var dataSources_default = {
+	selectCalendar: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Calendar",
+			description: "A list of selectable calendars"
+		},
+		inputs: selectCalendarInputs,
+		perform: async (_context, { connection }) => {
+			const { data: calendarList } = await listAllCalendars({
+				connection,
+				fetchAll: true
+			});
+			const pickListOptions = calendarList.items.map((calendar) => ({
+				key: calendar.id,
+				label: calendar.summary
+			}));
+			pickListOptions.sort((a, b) => a.label.localeCompare(b.label));
+			return { result: pickListOptions };
+		},
+		dataSourceType: "picklist",
+		examplePayload: { result: [{
+			label: "Holidays in United States",
+			key: "en.usa#holiday@group.v.calendar.google.com"
+		}] }
+	}),
+	selectEvent: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Event",
+			description: "A list of selectable events"
+		},
+		inputs: selectEventInputs,
+		perform: async (_context, { connection: googleConnection, calendarId }) => {
+			const pickListOptions = (await listAllEvents({
+				googleConnection,
+				calendarId,
+				fetchAll: true
+			})).data.items.map((event) => ({
+				key: event.id,
+				label: `${event.summary} (${event.start.date} to ${event.end.date})`
+			}));
+			pickListOptions.sort((a, b) => a.label.localeCompare(b.label));
+			return { result: pickListOptions };
+		},
+		dataSourceType: "picklist",
+		examplePayload: { result: [{
+			label: "New Year's Day (2020-01-01 to 2020-01-02)",
+			key: "20200101_q8ue475rr4p7opsd4c0lr7g5pg"
+		}] }
+	})
+};
+//#endregion
+//#region src/examplePayloads.ts
+const pollEventsTriggerPayload = {
+	branch: "default",
+	payload: {
+		headers: {},
+		queryParameters: null,
+		rawBody: {
+			data: null,
+			contentType: null
+		},
+		paginationState: void 0,
+		body: { data: {
+			changes: {
+				summary: {
+					totalChanges: 0,
+					created: 0,
+					updated: 0,
+					deleted: 0,
+					syncTokenAvailable: true
+				},
+				createdEvents: [],
+				updatedEvents: [],
+				deletedEvents: [],
+				allChanges: []
+			},
+			calendarId: "example@group.calendar.google.com",
+			syncToken: "exampleSyncToken"
+		} },
+		pathFragment: "",
+		webhookUrls: {},
+		webhookApiKeys: {},
+		invokeUrl: "",
+		executionId: "RXhhbXBsZUV4ZWN1dGlvblJlc3VsdElkMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY=",
+		customer: {
+			id: "testCustomerId",
+			name: "Test Customer",
+			externalId: "testCustomerExternalId"
+		},
+		instance: {
+			id: "SW5zdGFuY2U6OGRiNWQ4NmYtMjBkYS00MzI5LWI2MmMtM2ZhOWFiNDUwYjUw",
+			name: "Google Calendar - Polling Events"
+		},
+		user: {
+			id: "testUserId",
+			email: "testUserEmail@example.com",
+			name: "Test User",
+			externalId: "testUserExternalId"
+		},
+		integration: {
+			id: "SW50ZWdyYXRpb246ZDk2YzcxNmItODFmMS00NmQ4LTk0NzItNDU3NDZmMzg2Mjgw",
+			name: "Google Calendar - DEV",
+			versionSequenceId: "testIntegrationVersionSequenceId",
+			externalVersion: ""
+		},
+		flow: {
+			id: "SW50ZWdyYXRpb25GbG93OmM4Y2IzY2UwLTFjYTUtNDVhZC04Yjc1LWNmNDc4YWE1Y2RlYQ==",
+			name: "Poll Events",
+			stableId: "test-flow-stable-id"
+		},
+		startedAt: "2026-01-07 14:22:38.313677+00",
+		globalDebug: false
+	},
+	polledNoChanges: false
+};
+const calendarChangeEventsPayload = {
+	branch: "Push Notifications",
+	payload: {
+		headers: {
+			Accept: "*/*",
+			"Accept-Encoding": "gzip, deflate, br",
+			Host: "hooks.example.com",
+			"User-Agent": "APIs-Google; (+https://developers.google.com/webmasters/APIs-Google.html)",
+			"X-Amz-Cf-Id": "ExampleCloudFrontId123456789012345678901234567890123456==",
+			"X-Amzn-Trace-Id": "Root=1-12345678-abcdef0123456789abcdef01",
+			"X-Forwarded-For": "192.0.2.1, 198.51.100.1",
+			"X-Goog-Changed": "content,properties",
+			"X-Goog-Channel-Expiration": "Wed, 07 Jan 2026 07:10:37 GMT",
+			"X-Goog-Channel-ID": "12345678-abcd-1234-abcd-123456789012",
+			"X-Goog-Message-Number": "123456",
+			"X-Goog-Resource-ID": "ExampleResourceId1234567890",
+			"X-Goog-Resource-State": "update",
+			"X-Goog-Resource-URI": "https://www.googleapis.com/calendar/v3/calendars/primary/events?alt=json"
+		},
+		queryParameters: null,
+		rawBody: {
+			data: null,
+			contentType: "application/octet-stream"
+		},
+		body: {
+			data: {
+				calendar: {
+					id: "primary",
+					summary: "Example Calendar",
+					description: "This is an example calendar",
+					timeZone: "America/Chicago"
+				},
+				events: {
+					totalEvents: 2,
+					recentEvents: [{
+						id: "example_event_1",
+						summary: "Team Meeting",
+						start: {
+							dateTime: "2026-01-07T10:00:00-06:00",
+							timeZone: "America/Chicago"
+						},
+						end: {
+							dateTime: "2026-01-07T11:00:00-06:00",
+							timeZone: "America/Chicago"
+						},
+						updated: "2026-01-07T08:30:00.000Z"
+					}, {
+						id: "example_event_2",
+						summary: "Lunch Break",
+						start: {
+							dateTime: "2026-01-07T12:00:00-06:00",
+							timeZone: "America/Chicago"
+						},
+						end: {
+							dateTime: "2026-01-07T13:00:00-06:00",
+							timeZone: "America/Chicago"
+						},
+						updated: "2026-01-07T08:15:00.000Z"
+					}]
+				},
+				notification: {
+					resourceState: "update",
+					changedFields: "content,properties",
+					resourceId: "ExampleResourceId1234567890",
+					timestamp: "2026-01-07T14:26:35.618Z"
+				}
+			},
+			contentType: "application/octet-stream"
+		},
+		pathFragment: "",
+		webhookUrls: { "Calendar Change Events": "https://hooks.example.com/trigger/RXhhbXBsZUluc3RhbmNlRmxvd0NvbmZpZ0lkMTIzNDU2Nzg5MDEyMzQ1Njc4OTA=" },
+		webhookApiKeys: { "Calendar Change Events": [] },
+		invokeUrl: "https://hooks.example.com/trigger/RXhhbXBsZUluc3RhbmNlRmxvd0NvbmZpZ0lkMTIzNDU2Nzg5MDEyMzQ1Njc4OTA=",
+		executionId: "RXhhbXBsZUV4ZWN1dGlvblJlc3VsdElkMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY=",
+		customer: {
+			id: "testCustomerId",
+			name: "Test Customer",
+			externalId: "testCustomerExternalId"
+		},
+		instance: {
+			id: "SW5zdGFuY2U6OGRiNWQ4NmYtMjBkYS00MzI5LWI2MmMtM2ZhOWFiNDUwYjUw",
+			name: "Google Calendar - DEV - Calendar Change Events"
+		},
+		user: {
+			id: "testUserId",
+			email: "testUserEmail@example.com",
+			name: "Test User",
+			externalId: "testUserExternalId"
+		},
+		integration: {
+			id: "SW50ZWdyYXRpb246ZDk2YzcxNmItODFmMS00NmQ4LTk0NzItNDU3NDZmMzg2Mjgw",
+			name: "Google Calendar - DEV",
+			versionSequenceId: "testIntegrationVersionSequenceId",
+			externalVersion: ""
+		},
+		flow: {
+			id: "SW50ZWdyYXRpb25GbG93OmM4Y2IzY2UwLTFjYTUtNDVhZC04Yjc1LWNmNDc4YWE1Y2RlYQ==",
+			name: "Calendar Change Events",
+			stableId: "test-flow-stable-id"
+		},
+		startedAt: "2026-01-07 14:22:38.313677+00",
+		globalDebug: false
+	},
+	response: {
+		statusCode: 200,
+		contentType: "application/json"
+	}
+};
+//#endregion
+//#region src/utils/resolvePollingRecordChanges.ts
+const resolvePollingRecordChanges = (data) => {
+	const changesObject = data ?? {
+		createdEvents: [],
+		updatedEvents: [],
+		deletedEvents: [],
+		allChanges: []
+	};
+	return [
+		...(changesObject.createdEvents ?? []).map((record) => ({
+			changeType: "created",
+			record
+		})),
+		...(changesObject.updatedEvents ?? []).map((record) => ({
+			changeType: "updated",
+			record
+		})),
+		...(changesObject.deletedEvents ?? []).map((record) => ({
+			changeType: "deleted",
+			record
+		}))
+	];
+};
+//#endregion
+//#region src/utils/index.ts
+function getBase64FromUrl(url) {
+	const lastPathSegmentMatch = url.match(/\/([^/]+)$/);
+	return lastPathSegmentMatch ? lastPathSegmentMatch[1] : "";
+}
+//#endregion
+//#region src/helpers/stopWatch.ts
+const stopWatch = async ({ calendar, channelId, resourceId }) => {
+	await calendar.channels.stop({ requestBody: {
+		id: channelId,
+		resourceId
+	} });
+};
+const stopWatchWithErrorHandling = async (params, logger) => {
+	try {
+		await stopWatch(params);
+		logger.info("Previous Calendar watch stopped successfully");
+	} catch (err) {
+		const error = err;
+		logger.warn("Failed to stop previous Calendar watch (continuing):", error?.errors?.[0]?.reason || error?.message);
+	}
+};
+//#endregion
+//#region src/helpers/manageWatch.ts
+const manageWatch = async ({ calendar, calendarId, webhookAddress, newChannelId, previousWatch, logger }) => {
+	if (previousWatch?.channelId && previousWatch?.resourceId) await stopWatchWithErrorHandling({
+		calendar,
+		channelId: previousWatch.channelId,
+		resourceId: previousWatch.resourceId
+	}, logger);
+	const expiration = Date.now() + 10080 * 60 * 1e3;
+	try {
+		const res = await calendar.events.watch({
+			calendarId,
+			requestBody: {
+				id: newChannelId,
+				type: "web_hook",
+				address: webhookAddress,
+				expiration: _prismatic_io_spectral.util.types.toString(expiration)
+			}
+		});
+		logger.info("New Calendar watch created successfully");
+		if (!res.data.id || !res.data.resourceId || !res.data.expiration) throw new Error("Calendar watch creation returned incomplete data");
+		return {
+			channelId: res.data.id,
+			resourceId: res.data.resourceId,
+			expiration: res.data.expiration
+		};
+	} catch (error) {
+		logger.error("Failed to create Calendar watch. Does the calendar still exist?");
+		throw error;
+	}
+};
+//#endregion
+//#region src/helpers/calendarChangeEventsCreate.ts
+const calendarChangeEventsCreate = async (context, { connection, calendarId }) => {
+	const calendar = createClient({ connection });
+	const integrationFlowName = context.flow.name;
+	const address = context.webhookUrls[integrationFlowName];
+	const stateKey = getBase64FromUrl(address);
+	const newChannelId = (0, uuid.v4)();
+	const previousWatch = context.crossFlowState[stateKey];
+	context.logger.info(`Started Calendar Change Events Trigger deploy for ${integrationFlowName}`);
+	context.logger.info(`Creating watch for calendar ${calendarId}`);
+	const watchResult = await manageWatch({
+		calendar,
+		calendarId,
+		webhookAddress: address,
+		newChannelId,
+		logger: context.logger,
+		previousWatch
+	});
+	context.crossFlowState[stateKey] = watchResult;
+	context.logger.info("Establishing initial sync token for incremental sync");
+	const syncStateKey = `${stateKey}_syncToken`;
+	const lastListExecutedAtStateKey = `${stateKey}_lastListExecutedAt`;
+	try {
+		const response = await listAllEvents({
+			googleConnection: connection,
+			calendarId,
+			fetchAll: true,
+			singleEvents: true,
+			showDeleted: true
+		});
+		if (response.data.nextSyncToken) {
+			context.crossFlowState[syncStateKey] = response.data.nextSyncToken;
+			context.crossFlowState[lastListExecutedAtStateKey] = (/* @__PURE__ */ new Date()).toISOString();
+			context.logger.info("Initial sync token established. Future notifications will track changes from this point.");
+		} else throw new Error("No sync token found");
+	} catch (error) {
+		context.logger.error("Failed to establish initial sync token:", error instanceof Error ? error.message : "Unknown error");
+		throw error;
+	}
+	context.logger.info(`Finished Calendar Change Events Trigger deploy for ${integrationFlowName}`);
+};
+//#endregion
+//#region src/helpers/calendarChangeEventsDelete.ts
+const calendarChangeEventsDelete = async (context, { connection }) => {
+	const integrationFlowName = context.flow.name;
+	context.logger.info(`Started Calendar Change Events Trigger delete for ${integrationFlowName}`);
+	const address = context.webhookUrls[integrationFlowName];
+	const stateKey = getBase64FromUrl(address);
+	const syncStateKey = `${stateKey}_syncToken`;
+	const lastListExecutedAtStateKey = `${stateKey}_lastListExecutedAt`;
+	const previousWatch = context.crossFlowState[stateKey];
+	if (previousWatch?.channelId && previousWatch?.resourceId) await stopWatchWithErrorHandling({
+		calendar: createClient({ connection }),
+		channelId: previousWatch.channelId,
+		resourceId: previousWatch.resourceId
+	}, context.logger);
+	else context.logger.info("No previous Calendar watch found in state, nothing to stop");
+	delete context.crossFlowState[stateKey];
+	delete context.crossFlowState[syncStateKey];
+	delete context.crossFlowState[lastListExecutedAtStateKey];
+	context.logger.info(`Finished Calendar Change Events Trigger delete for ${integrationFlowName}`);
+};
+//#endregion
+//#region src/helpers/retrieveIncrementalChanges.ts
+const retrieveIncrementalChanges = async (connection, calendarId, syncToken) => {
+	const response = await listAllEvents({
+		googleConnection: connection,
+		calendarId,
+		syncToken,
+		fetchAll: true,
+		singleEvents: true,
+		showDeleted: true
+	});
+	return {
+		events: response.data.items || [],
+		nextSyncToken: response.data.nextSyncToken
+	};
+};
+//#endregion
+//#region src/helpers/calendarChangeEventsPerform.ts
+const calendarChangeEventsPerform = async (context, payload, { connection, calendarId }) => {
+	const headers = _prismatic_io_spectral.util.types.lowerCaseHeaders(payload.headers);
+	const invokeType = headers["prismatic-invoke-type"];
+	const integrationFlowName = context.flow.name;
+	const address = context.webhookUrls[integrationFlowName];
+	const stateKey = getBase64FromUrl(address);
+	const previousWatch = context.crossFlowState[stateKey];
+	if (!previousWatch) throw new Error("No previous watch found in state");
+	if (invokeType === "Scheduled") {
+		if (context.debug.enabled) context.logger.info("Scheduled renewal triggered");
+		const watchResult = await manageWatch({
+			calendar: createClient({ connection }),
+			calendarId,
+			webhookAddress: address,
+			newChannelId: (0, uuid.v4)(),
+			logger: context.logger,
+			previousWatch
+		});
+		context.crossFlowState[stateKey] = watchResult;
+		payload.body.data = watchResult;
+		return {
+			payload,
+			branch: "Log Messages",
+			response: {
+				statusCode: 200,
+				contentType: "application/json"
+			}
+		};
+	}
+	let changeDetails = null;
+	const resourceState = headers["x-goog-resource-state"];
+	const resourceId = headers["x-goog-resource-id"];
+	const changedFields = headers["x-goog-changed"];
+	const isValidChannel = headers["x-goog-channel-id"] === previousWatch.channelId;
+	const isValidResource = resourceId === previousWatch.resourceId;
+	if (!isValidChannel || !isValidResource) throw new Error("Unauthorized webhook call: Channel or resource ID mismatch");
+	if (resourceState === "sync") {
+		if (context.debug.enabled) context.logger.info("Sync notification received");
+		payload.body.data = { notification: {
+			resourceState,
+			resourceId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			type: "sync"
+		} };
+		return {
+			payload,
+			branch: "Log Messages",
+			response: {
+				statusCode: 200,
+				contentType: "application/json"
+			}
+		};
+	}
+	if (context.debug.enabled) context.logger.info("Notification received");
+	if (resourceState === "exists") {
+		const calendar = createClient({ connection });
+		let calendarInfo = null;
+		let changes = null;
+		let syncExpired = false;
+		const calendarResponse = await calendar.calendars.get({ calendarId });
+		calendarInfo = {
+			id: calendarResponse.data.id,
+			summary: calendarResponse.data.summary,
+			description: calendarResponse.data.description,
+			timeZone: calendarResponse.data.timeZone
+		};
+		const syncStateKey = `${stateKey}_syncToken`;
+		const previousSyncToken = context.crossFlowState[syncStateKey];
+		let changedEvents = [];
+		let newSyncToken;
+		if (!previousSyncToken) throw new Error("No sync token found in state");
+		try {
+			if (context.debug.enabled) context.logger.info("Using sync token to fetch incremental changes");
+			const eventsResponse = await retrieveIncrementalChanges(connection, calendarId, previousSyncToken);
+			if (eventsResponse.events && eventsResponse.events.length > 0) changedEvents = eventsResponse.events.map((event) => {
+				let changeType;
+				if (event.status === "cancelled") changeType = "deleted";
+				else if (!event.created || !event.updated) changeType = "unknown";
+				else {
+					const createdTime = new Date(event.created).getTime();
+					changeType = new Date(event.updated).getTime() - createdTime < 1e3 ? "created" : "updated";
+				}
+				return {
+					changeType,
+					id: event.id,
+					summary: event.summary || "[No title]",
+					status: event.status,
+					start: event.start,
+					end: event.end,
+					created: event.created,
+					updated: event.updated,
+					organizer: event.organizer?.email,
+					attendees: event.attendees?.map((a) => ({
+						email: a.email,
+						responseStatus: a.responseStatus,
+						optional: a.optional
+					})),
+					location: event.location,
+					description: event.description,
+					recurringEventId: event.recurringEventId,
+					htmlLink: event.htmlLink
+				};
+			});
+			newSyncToken = eventsResponse.nextSyncToken;
+		} catch (e) {
+			const syncError = e;
+			if (syncError?.response?.status === 410) {
+				context.logger.warn("Sync token expired, re-establishing baseline");
+				syncExpired = true;
+				const lastListExecutedAtStateKey = `${stateKey}_lastListExecutedAt`;
+				const lastListExecutedAt = context.crossFlowState[lastListExecutedAtStateKey];
+				const response = await listAllEvents({
+					googleConnection: connection,
+					calendarId,
+					updatedMin: lastListExecutedAt,
+					fetchAll: true,
+					singleEvents: true,
+					showDeleted: true
+				});
+				context.crossFlowState[lastListExecutedAtStateKey] = (/* @__PURE__ */ new Date()).toISOString();
+				newSyncToken = response.data.nextSyncToken;
+			} else throw syncError;
+		}
+		if (!newSyncToken) throw new Error("No new sync token found to continue incremental sync");
+		context.crossFlowState[syncStateKey] = newSyncToken;
+		if (context.debug.enabled) context.logger.info("Updated sync token for next incremental sync");
+		if (syncExpired) {
+			changes = {
+				summary: {
+					totalChanges: 0,
+					created: 0,
+					updated: 0,
+					deleted: 0,
+					syncTokenAvailable: !!previousSyncToken,
+					syncTokenUpdated: !!newSyncToken
+				},
+				createdEvents: [],
+				updatedEvents: [],
+				deletedEvents: [],
+				allChanges: []
+			};
+			changeDetails = {
+				calendar: calendarInfo,
+				changes,
+				notification: {
+					resourceState: "resync",
+					reason: "sync_token_expired",
+					timestamp: (/* @__PURE__ */ new Date()).toISOString()
+				}
+			};
+		} else {
+			const createdEvents = changedEvents.filter((e) => e.changeType === "created");
+			const updatedEvents = changedEvents.filter((e) => e.changeType === "updated");
+			const deletedEvents = changedEvents.filter((e) => e.changeType === "deleted");
+			changes = {
+				summary: {
+					totalChanges: changedEvents.length,
+					created: createdEvents.length,
+					updated: updatedEvents.length,
+					deleted: deletedEvents.length,
+					syncTokenAvailable: !!previousSyncToken,
+					syncTokenUpdated: !!newSyncToken
+				},
+				createdEvents,
+				updatedEvents,
+				deletedEvents,
+				allChanges: changedEvents
+			};
+			changeDetails = {
+				calendar: calendarInfo,
+				changes,
+				notification: {
+					resourceState,
+					changedFields,
+					resourceId,
+					timestamp: (/* @__PURE__ */ new Date()).toISOString()
+				}
+			};
+		}
+	} else changeDetails = {
+		calendar: null,
+		changes: null,
+		notification: {
+			resourceState,
+			changedFields,
+			resourceId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		}
+	};
+	payload.body.data = changeDetails;
+	return {
+		payload,
+		branch: "Push Notifications",
+		response: {
+			statusCode: 200,
+			contentType: "application/json"
+		}
+	};
+};
+//#endregion
+//#region src/helpers/pollEventsTriggerPerform.ts
+const classifyEvent = (event) => {
+	if (event.status === "cancelled") return "deleted";
+	if (!event.created || !event.updated) return "unknown";
+	const createdTime = new Date(event.created).getTime();
+	return new Date(event.updated).getTime() - createdTime < 1e3 ? "created" : "updated";
+};
+const processEvents = (events) => {
+	const createdEvents = [];
+	const updatedEvents = [];
+	const deletedEvents = [];
+	return {
+		processedEvents: events.map((event) => {
+			const changeType = classifyEvent(event);
+			const processed = {
+				changeType,
+				id: event.id,
+				summary: event.summary || "[No title]",
+				status: event.status,
+				start: event.start,
+				end: event.end,
+				created: event.created,
+				updated: event.updated,
+				organizer: event.organizer?.email,
+				attendees: event.attendees?.map((a) => ({
+					email: a.email,
+					responseStatus: a.responseStatus,
+					optional: a.optional
+				})),
+				location: event.location,
+				description: event.description,
+				recurringEventId: event.recurringEventId,
+				htmlLink: event.htmlLink
+			};
+			if (changeType === "created") createdEvents.push(processed);
+			else if (changeType === "updated") updatedEvents.push(processed);
+			else if (changeType === "deleted") deletedEvents.push(processed);
+			return processed;
+		}),
+		createdEvents,
+		updatedEvents,
+		deletedEvents
+	};
+};
+const pollEventsTriggerPerform = async (context, payload, { connection, calendarId, lookBackDate }) => {
+	const pollState = context.polling.getState();
+	const isBatching = context.batch?.enabled === true;
+	const incoming = payload.paginationState;
+	const newLastPolledAt = incoming?.drainStartedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+	let syncToken = incoming?.syncToken ?? pollState.syncToken;
+	let events = [];
+	let nextPageToken;
+	let drained = true;
+	try {
+		if (incoming?.pageToken) {
+			const response = await listAllEvents({
+				googleConnection: connection,
+				calendarId,
+				pageToken: incoming.pageToken,
+				fetchAll: false,
+				maxResults: 50,
+				singleEvents: true,
+				showDeleted: true
+			});
+			events = response.data.items || [];
+			nextPageToken = response.data.nextPageToken;
+			if (response.data.nextSyncToken) syncToken = response.data.nextSyncToken;
+			drained = !nextPageToken;
+		} else if (syncToken) if (isBatching) {
+			const response = await listAllEvents({
+				googleConnection: connection,
+				calendarId,
+				syncToken,
+				fetchAll: false,
+				maxResults: 50,
+				singleEvents: true,
+				showDeleted: true
+			});
+			events = response.data.items || [];
+			nextPageToken = response.data.nextPageToken;
+			if (response.data.nextSyncToken) syncToken = response.data.nextSyncToken;
+			drained = !nextPageToken;
+		} else {
+			const result = await retrieveIncrementalChanges(connection, calendarId, syncToken);
+			events = result.events;
+			syncToken = result.nextSyncToken;
+		}
+		else {
+			if (context.debug.enabled) context.logger.info("No sync token found, performing initial sync");
+			const response = await listAllEvents({
+				googleConnection: connection,
+				calendarId,
+				updatedMin: lookBackDate ? (/* @__PURE__ */ new Date(`${lookBackDate}T00:00:00Z`)).toISOString() : newLastPolledAt,
+				fetchAll: !isBatching,
+				maxResults: isBatching ? 50 : void 0,
+				singleEvents: true,
+				showDeleted: true
+			});
+			syncToken = response.data.nextSyncToken;
+			nextPageToken = response.data.nextPageToken;
+			events = response.data.items || [];
+			drained = !nextPageToken;
+			if (!isBatching) events = lookBackDate ? events : [];
+		}
+	} catch (e) {
+		const syncError = e;
+		if (syncError.response?.status === 410) {
+			if (context.debug.enabled) context.logger.warn("Sync token is no longer valid, performing incremental sync from last polled date");
+			const resyncTimeMin = pollState.lastPolledAt;
+			if (context.debug.enabled) context.logger.info(`Resyncing from ${resyncTimeMin}`);
+			const initialResponse = await listAllEvents({
+				googleConnection: connection,
+				calendarId,
+				updatedMin: resyncTimeMin,
+				fetchAll: !isBatching,
+				maxResults: isBatching ? 50 : void 0,
+				singleEvents: true,
+				showDeleted: true
+			});
+			syncToken = initialResponse.data.nextSyncToken;
+			nextPageToken = initialResponse.data.nextPageToken;
+			events = initialResponse.data.items || [];
+			drained = !nextPageToken;
+			if (!syncToken && drained) throw new Error("No sync token found after resync");
+		} else throw syncError;
+	}
+	const { processedEvents, createdEvents, updatedEvents, deletedEvents } = processEvents(events);
+	let nextPaginationState = null;
+	if (!drained) nextPaginationState = {
+		...syncToken ? { syncToken } : {},
+		pageToken: nextPageToken,
+		drainStartedAt: newLastPolledAt
+	};
+	const stateUpdate = {
+		syncToken,
+		lastPolledAt: drained ? newLastPolledAt : pollState.lastPolledAt
+	};
+	context.polling.setState(stateUpdate);
+	const changes = {
+		summary: {
+			totalChanges: processedEvents.length,
+			created: createdEvents.length,
+			updated: updatedEvents.length,
+			deleted: deletedEvents.length,
+			syncTokenAvailable: !!syncToken
+		},
+		createdEvents,
+		updatedEvents,
+		deletedEvents,
+		allChanges: processedEvents
+	};
+	const polledNoChanges = processedEvents.length === 0 && nextPaginationState === null && !incoming;
+	return {
+		payload: {
+			...payload,
+			paginationState: nextPaginationState ?? void 0,
+			body: { data: {
+				changes,
+				calendarId,
+				syncToken
+			} }
+		},
+		polledNoChanges
+	};
+};
+//#endregion
+//#region src/triggers/index.ts
+var triggers_default = {
+	calendarChangeEvents: (0, _prismatic_io_spectral.trigger)({
+		display: {
+			label: "Calendar Change Events",
+			description: "Receive change notifications for a Google Calendar. Automatically creates and manages a Google Calendar push notification subscription when the instance is deployed, and removes the subscription when the instance is deleted."
+		},
+		perform: calendarChangeEventsPerform,
+		inputs: calendarChangeEventsInputs,
+		synchronousResponseSupport: "invalid",
+		scheduleSupport: "valid",
+		allowsBranching: true,
+		staticBranchNames: ["Push Notifications", "Log Messages"],
+		examplePayload: calendarChangeEventsPayload,
+		webhookLifecycleHandlers: {
+			create: calendarChangeEventsCreate,
+			delete: calendarChangeEventsDelete
+		}
+	}),
+	pollEventsTrigger: (0, _prismatic_io_spectral.pollingTrigger)({
+		display: {
+			label: "New and Updated Events",
+			description: "Retrieves existing and ongoing events in a specified Google Calendar. Load history once, check for changes on a schedule, or both."
+		},
+		inputs: pollEventsTriggerInputs,
+		triggerResolverSupport: "valid",
+		batchConfig: { batchSize: 50 },
+		triggerResolver: {
+			resolveItems: (_context, { payload }) => resolvePollingRecordChanges(payload.body.data?.changes),
+			getNextPaginationState: (_context, { payload }) => payload.paginationState ?? null
+		},
+		perform: pollEventsTriggerPerform,
+		examplePayload: pollEventsTriggerPayload
+	})
+};
+//#endregion
+//#region src/index.ts
+var src_default = (0, _prismatic_io_spectral.component)({
+	key: "google-calendar",
+	public: true,
+	documentationUrl: "https://prismatic.io/docs/components/google-calendar/",
+	display: {
+		label: "Google Calendar",
+		description: "Manage calendars and events in Google Calendar",
+		iconPath: "icon.png",
+		category: "Application Connectors"
+	},
+	actions: actions_default,
+	hooks: { error: _prismatic_io_spectral_http.handleErrors },
+	connections: connections_default,
+	dataSources: dataSources_default,
+	triggers: triggers_default
+});
+//#endregion
+//#region npm-dist/.entry.ts
+var _entry_default = (0, _prismatic_io_spectral.callableComponent)(src_default);
+//#endregion
+module.exports = _entry_default;