@oomol-lab/open-connector 1.7.0 → 1.8.0

package/src/providers/gitlab/trigger-on-project-event.js

@@ -0,0 +1,186 @@
+import { IntegrationConnectionError, PermanentIntegrationError, TransientIntegrationError, } from "../../triggers/common/integration.js";
+import { sameSecret } from "../../triggers/signature.js";
+import { snapshot, events } from "./trigger-on-project-event.definition.js";
+const eventNames = new Map([
+    ["Push Hook", "push"],
+    ["Tag Push Hook", "tag_push"],
+    ["Issue Hook", "issues"],
+    ["Confidential Issue Hook", "confidential_issues"],
+    ["Note Hook", "note"],
+    ["Confidential Note Hook", "confidential_note"],
+    ["Merge Request Hook", "merge_requests"],
+    ["Job Hook", "job"],
+    ["Pipeline Hook", "pipeline"],
+    ["Wiki Page Hook", "wiki_page"],
+    ["Deployment Hook", "deployment"],
+    ["Feature Flag Hook", "feature_flag"],
+    ["Release Hook", "releases"],
+    ["Milestone Hook", "milestone"],
+    ["Emoji Hook", "emoji"],
+    ["Resource Access Token Hook", "resource_access_token"],
+    ["Resource Deploy Token Hook", "resource_deploy_token"],
+]);
+export const gitlabProjectEvent = {
+    initialState: { checkpoint: null, subscription: {} },
+    snapshot,
+    receive(context) {
+        if (!sameSecret(context.header("x-gitlab-token"), context.callbackSecret)) {
+            return { body: "", contentType: "text/plain", outcome: "respond", status: 404 };
+        }
+        const gitlabEvent = context.header("x-gitlab-event")?.trim();
+        if (!gitlabEvent)
+            return { outcome: "ignored", reason: "GitLab event header is missing." };
+        const event = eventNames.get(gitlabEvent);
+        if (event == null)
+            return { outcome: "ignored", reason: "GitLab event header is unknown." };
+        if (!resolveConfig(context.config).events.includes(event))
+            return { outcome: "ignored", reason: "GitLab event is not subscribed." };
+        const deliveryId = context.header("idempotency-key") ?? "";
+        return {
+            dedupeKey: deliveryId.length == 0 ? undefined : deliveryId,
+            outcome: "event",
+            outputs: {
+                body: context.payload,
+                deliveryId,
+                event,
+                gitlabEvent,
+            },
+        };
+    },
+    async reconcile(context) {
+        const state = requireState(context.state);
+        const config = resolveConfig(context.config);
+        const known = subscriptionId(state);
+        if (!context.active) {
+            const ids = known == null ? await findByUrl(context, config) : [known];
+            for (const id of ids ?? [])
+                await remove(context, config, id);
+            await state.saveSubscription({}, later(context.now));
+            return { outcome: "ready" };
+        }
+        const matches = await findByUrl(context, config);
+        if (matches == null)
+            throw new PermanentIntegrationError("The GitLab project does not exist or is not visible.");
+        let hookId = known ?? matches[0];
+        if (hookId == null) {
+            const created = await request(context, "hook create", {
+                body: desired(context.endpointUrl, context.callbackSecret, config),
+                endpoint: endpoint(config),
+                method: "POST",
+            });
+            success(created, "hook create");
+            hookId = readId(created.data);
+        }
+        else {
+            const aligned = await request(context, "hook update", {
+                body: desired(context.endpointUrl, context.callbackSecret, config),
+                endpoint: `${endpoint(config)}/${hookId}`,
+                method: "PUT",
+            });
+            if (aligned.status == 404) {
+                await state.saveSubscription({}, context.now);
+                return { outcome: "pending" };
+            }
+            success(aligned, "hook update");
+        }
+        for (const duplicate of matches.filter((value) => value != hookId))
+            await remove(context, config, duplicate);
+        await state.saveSubscription({ hookId }, later(context.now));
+        return { outcome: "ready" };
+    },
+};
+function resolveConfig(value) {
+    return {
+        events: value.events,
+        insecureSsl: value.insecureSsl,
+        project: value.project,
+        pushBranchFilter: value.pushBranchFilter,
+    };
+}
+function endpoint(config) {
+    return `/projects/${encodeURIComponent(config.project)}/hooks`;
+}
+function desired(url, token, config) {
+    return {
+        branch_filter_strategy: "wildcard",
+        description: "Managed by Open Flow.",
+        enable_ssl_verification: !config.insecureSsl,
+        name: `Open Flow ${url.slice(url.lastIndexOf("/") + 1)}`,
+        push_events_branch_filter: config.pushBranchFilter,
+        url,
+        token,
+        ...Object.fromEntries(events.map((event) => [`${event}_events`, config.events.includes(event)])),
+    };
+}
+async function findByUrl(context, config) {
+    const matches = [];
+    for (let page = 1; page <= 10; page += 1) {
+        const result = await request(context, "hook list", {
+            endpoint: endpoint(config),
+            method: "GET",
+            query: { page, per_page: 100 },
+        });
+        if (result.status == 404)
+            return null;
+        success(result, "hook list");
+        const hooks = Array.isArray(result.data) ? result.data : [];
+        for (const hook of hooks) {
+            const value = record(hook);
+            if (value?.url === context.endpointUrl && (typeof value.id == "number" || typeof value.id == "string"))
+                matches.push(String(value.id));
+        }
+        if (hooks.length < 100)
+            break;
+    }
+    return matches;
+}
+async function remove(context, config, hookId) {
+    const result = await request(context, "hook delete", {
+        endpoint: `${endpoint(config)}/${hookId}`,
+        method: "DELETE",
+    });
+    if (result.status != 404)
+        success(result, "hook delete");
+}
+async function request(context, operation, value) {
+    try {
+        return await context.connector.execute(value, context.signal);
+    }
+    catch (cause) {
+        if (cause instanceof IntegrationConnectionError)
+            throw cause;
+        throw new TransientIntegrationError(`GitLab ${operation} request failed.`, { cause });
+    }
+}
+function success(result, operation) {
+    if (result.status >= 200 && result.status < 300)
+        return;
+    if (result.status == 401 || result.status == 403)
+        throw new IntegrationConnectionError(`GitLab ${operation} rejected the Connection.`);
+    if ([400, 404, 422].includes(result.status))
+        throw new PermanentIntegrationError(`GitLab ${operation} rejected the subscription.`);
+    throw new TransientIntegrationError(`GitLab ${operation} failed with status ${result.status}.`);
+}
+function readId(data) {
+    const value = record(data)?.id;
+    if (typeof value != "number" && typeof value != "string")
+        throw new TransientIntegrationError("GitLab hook response is missing its ID.");
+    return String(value);
+}
+function requireState(value) {
+    if (value == null)
+        throw new PermanentIntegrationError("GitLab Integration state is missing.");
+    return value;
+}
+function subscriptionId(state) {
+    const value = state.subscription.hookId;
+    return typeof value == "string" && value.length > 0 ? value : null;
+}
+function later(now) {
+    return new Date(now.getTime() + 30 * 24 * 60 * 60 * 1_000);
+}
+function record(value) {
+    return value != null && typeof value == "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}

package/src/providers/gmail/executors.d.ts

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ExecutionContext, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+import type { PollDefinition } from "../../triggers/common/poll.ts";
 import type { ProviderActionHandlers } from "../provider-runtime.ts";
 declare const service = "gmail";
 interface ActionContext {
@@ -13,4 +15,5 @@ export declare const gmailActionHandlers: ProviderActionHandlers<typeof service,
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];
 export {};

package/src/providers/gmail/executors.js

@@ -5,6 +5,7 @@ import { defineProviderExecutors, defineProviderProxy, ProviderRequestError, rea
 import { decodeGmailAttachment } from "./attachment-stream.js";
 import { buildRecipients, encodeMimeMessage, extractBodyContent, firstAddress, normalizeGmailMessage, normalizeMessageId, normalizeThreadId, parseAddressList, readHeader, resolveReplyHeaders, summarizeGmailMessage, } from "./message.js";
 import { gmailOAuthScopes } from "./scopes.js";
+import { gmailMessageReceived } from "./trigger-on-message-received.js";
 const service = "gmail";
 const gmailApiBaseUrl = "https://gmail.googleapis.com/gmail/v1";
 const detailHydrationBatchSize = 10;
@@ -789,3 +790,4 @@ async function readGmailError(response) {
         looseArray(error?.errors).some((entry) => gmailQuotaReasons.has(optionalString(optionalRecord(entry)?.reason) ?? ""));
     return new ProviderRequestError(response.status, optionalString(error?.message) ?? `gmail request failed with ${response.status}`, withRetryAfterSeconds(response), rateLimited ? "rate_limited" : undefined);
 }
+export const triggers = [gmailMessageReceived];

package/src/providers/gmail/trigger-on-message-received.d.ts

@@ -0,0 +1,2 @@
+import type { PollDefinition } from "../../triggers/common/poll.ts";
+export declare const gmailMessageReceived: PollDefinition;

package/src/providers/gmail/trigger-on-message-received.definition.d.ts

@@ -0,0 +1,4 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "poll";
+};

package/src/providers/gmail/trigger-on-message-received.definition.js

@@ -0,0 +1,74 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const defaultPageSize = 25;
+const eventSchema = s.object({
+    historyId: { type: ["string", "null"] },
+    labelIds: s.array(s.string()),
+    messageId: s.string(),
+    messageTimestamp: s.string(),
+    sender: s.string(),
+    subject: s.string(),
+    threadId: s.string(),
+    to: s.string(),
+}, {
+    additionalProperties: false,
+    required: ["messageId", "threadId", "historyId", "labelIds", "subject", "sender", "to", "messageTimestamp"],
+});
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "includeDrafts",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: false,
+            description: "Also trigger on draft messages.",
+        },
+        {
+            handle: "includeSpamAndTrash",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: false,
+            description: "Also trigger on messages in SPAM and TRASH.",
+        },
+        {
+            handle: "labelNamesOrIds",
+            jsonSchema: s.array(s.string({ minLength: 1 })),
+            nullable: false,
+            description: "Only trigger on messages carrying all of these labels, referenced by name or ID.",
+            value: [],
+        },
+        {
+            handle: "maxMessagesPerPoll",
+            jsonSchema: s.integer({ maximum: 100, minimum: 1 }),
+            nullable: false,
+            value: defaultPageSize,
+        },
+        {
+            handle: "readStatus",
+            jsonSchema: s.stringEnum(["Read", "Unread", "All"]),
+            nullable: false,
+            value: "All",
+        },
+        {
+            handle: "search",
+            jsonSchema: s.string(),
+            nullable: false,
+            description: "Gmail search-syntax query the message must match.",
+            value: "",
+        },
+        {
+            handle: "sender",
+            jsonSchema: s.string(),
+            nullable: false,
+            description: "Only trigger on messages whose sender matches this address or name.",
+            value: "",
+        },
+    ],
+    definitionVersion: 2,
+    description: "Polls the Gmail mailbox and triggers when a new message is received.",
+    displayName: "New Message Received",
+    key: "gmail.on_message_received",
+    name: "on_message_received",
+    outputs: [{ handle: "events", jsonSchema: s.array(eventSchema), nullable: false }],
+    provider: "gmail",
+    type: "poll",
+};

package/src/providers/gmail/trigger-on-message-received.js

@@ -0,0 +1,232 @@
+import { eventsPollOutputs, maximumPollEventsPerPage, PermanentPollError, PollConnectionError, TransientPollError, } from "../../triggers/common/poll.js";
+import { snapshot } from "./trigger-on-message-received.definition.js";
+export const gmailMessageReceived = {
+    buildOutputs: eventsPollOutputs,
+    snapshot,
+    async poll(context) {
+        const config = resolveConfig(context.config);
+        if (context.checkpoint === null)
+            return { checkpoint: { historyId: await profileHistoryId(context) }, events: [] };
+        const checkpoint = readCheckpoint(context.checkpoint);
+        const labels = await labelIds(context, config.labelNamesOrIds);
+        const budget = Math.min(config.maxMessagesPerPoll, maximumPollEventsPerPage);
+        const { candidates, lastPage } = await listMessages(context, checkpoint, labels, budget);
+        const offset = checkpoint.messageOffset ?? 0;
+        const end = Math.min(offset + budget, candidates.length);
+        // History pages count records, so consume all messages before advancing the page token.
+        const next = end < candidates.length
+            ? {
+                checkpoint: { historyId: checkpoint.historyId, pageToken: checkpoint.pageToken, messageOffset: end },
+                hasMore: true,
+            }
+            : nextCheckpoint(checkpoint.historyId, lastPage);
+        const events = [];
+        let filtered = 0;
+        for (const candidate of candidates.slice(offset, end)) {
+            const message = await messageMetadata(context, candidate.id);
+            if (message == null)
+                continue;
+            if (!(await matches(context, message, config, labels))) {
+                filtered += 1;
+                continue;
+            }
+            events.push(event(message));
+        }
+        return {
+            checkpoint: next.checkpoint,
+            events,
+            filtered,
+            ...(next.hasMore ? { hasMore: true } : {}),
+        };
+    },
+};
+function resolveConfig(value) {
+    return {
+        includeDrafts: value.includeDrafts,
+        includeSpamAndTrash: value.includeSpamAndTrash,
+        labelNamesOrIds: value.labelNamesOrIds,
+        maxMessagesPerPoll: value.maxMessagesPerPoll,
+        readStatus: value.readStatus,
+        search: value.search.trim(),
+        sender: value.sender.trim(),
+    };
+}
+async function profileHistoryId(context) {
+    const result = await get(context, "/users/me/profile");
+    success(result, "profile fetch");
+    const historyId = record(result.data)?.historyId;
+    if (typeof historyId != "string" || historyId.length == 0)
+        throw new TransientPollError("Gmail profile historyId is missing.");
+    return historyId;
+}
+function readCheckpoint(value) {
+    const checkpoint = record(value);
+    if (typeof checkpoint?.historyId != "string" || checkpoint.historyId.length == 0) {
+        throw new PermanentPollError("Gmail checkpoint historyId is missing; recreate the Trigger.");
+    }
+    if (checkpoint.messageOffset !== undefined &&
+        (!Number.isInteger(checkpoint.messageOffset) || checkpoint.messageOffset < 0)) {
+        throw new PermanentPollError("Gmail checkpoint messageOffset is invalid; recreate the Trigger.");
+    }
+    return {
+        historyId: checkpoint.historyId,
+        ...(typeof checkpoint.pageToken == "string" ? { pageToken: checkpoint.pageToken } : {}),
+        messageOffset: checkpoint.messageOffset,
+    };
+}
+async function labelIds(context, configured) {
+    if (configured.length == 0)
+        return [];
+    const result = await get(context, "/users/me/labels");
+    success(result, "labels list");
+    const labels = record(result.data)?.labels;
+    const byId = new Set();
+    const byName = new Map();
+    if (Array.isArray(labels)) {
+        for (const value of labels) {
+            const label = record(value);
+            if (typeof label?.id != "string" || label.id.length == 0)
+                continue;
+            byId.add(label.id);
+            if (typeof label.name == "string" && label.name.length > 0)
+                byName.set(label.name.toLowerCase(), label.id);
+        }
+    }
+    return [
+        ...new Set(configured.map((value) => {
+            const id = byId.has(value) ? value : byName.get(value.toLowerCase());
+            if (id == null)
+                throw new PermanentPollError(`Gmail label "${value}" does not exist.`);
+            return id;
+        })),
+    ];
+}
+async function listMessages(context, checkpoint, labels, maxMessages) {
+    const candidates = new Map();
+    const result = await get(context, "/users/me/history", {
+        historyTypes: "messageAdded",
+        labelId: labels[0],
+        maxResults: maxMessages,
+        pageToken: checkpoint.pageToken,
+        startHistoryId: checkpoint.historyId,
+    });
+    if (result.status == 404)
+        throw new PermanentPollError("Gmail history checkpoint expired; recreate the Trigger.");
+    success(result, "history list");
+    const lastPage = (record(result.data) ?? {});
+    for (const history of lastPage.history ?? []) {
+        for (const added of history.messagesAdded ?? []) {
+            const id = added.message?.id;
+            if (id != null && id.length > 0 && !candidates.has(id))
+                candidates.set(id, { id });
+        }
+    }
+    return { candidates: [...candidates.values()], lastPage };
+}
+function nextCheckpoint(historyId, page) {
+    if (page.nextPageToken)
+        return { checkpoint: { historyId, pageToken: page.nextPageToken }, hasMore: true };
+    if (!page.historyId)
+        throw new TransientPollError("Gmail history response historyId is missing.");
+    return { checkpoint: { historyId: page.historyId }, hasMore: false };
+}
+async function messageMetadata(context, id) {
+    const result = await get(context, `/users/me/messages/${encodeURIComponent(id)}`, {
+        format: "metadata",
+    });
+    if (result.status == 404)
+        return null;
+    success(result, "message metadata fetch");
+    return record(result.data) ?? null;
+}
+async function matches(context, message, config, requiredLabels) {
+    const labels = message.labelIds ?? [];
+    if (labels.includes("SENT") && !labels.includes("INBOX"))
+        return false;
+    if (!config.includeSpamAndTrash && (labels.includes("SPAM") || labels.includes("TRASH")))
+        return false;
+    if (!config.includeDrafts && labels.includes("DRAFT"))
+        return false;
+    if (config.readStatus == "Unread" && !labels.includes("UNREAD"))
+        return false;
+    if (config.readStatus == "Read" && labels.includes("UNREAD"))
+        return false;
+    if (!requiredLabels.every((label) => labels.includes(label)))
+        return false;
+    const query = searchQuery(config);
+    return query.length == 0 || (await matchesQuery(context, message, query, config.includeSpamAndTrash));
+}
+function searchQuery(config) {
+    const query = config.search.length == 0 ? [] : [config.search];
+    const sender = config.sender.replaceAll('"', "").trim();
+    if (sender.length > 0)
+        query.push(`from:${/\s/.test(sender) ? `"${sender}"` : sender}`);
+    return query.join(" ");
+}
+async function matchesQuery(context, message, query, includeSpamAndTrash) {
+    const messageId = header(message.payload?.headers ?? [], "Message-ID")
+        .replace(/^</, "")
+        .replace(/>$/, "");
+    if (messageId.length == 0)
+        return false;
+    const result = await get(context, "/users/me/messages", {
+        includeSpamTrash: includeSpamAndTrash ? "true" : undefined,
+        q: `${query} rfc822msgid:${messageId}`,
+    });
+    success(result, "query match");
+    const messages = record(result.data)?.messages;
+    return Array.isArray(messages) && messages.some((value) => record(value)?.id === message.id);
+}
+function event(message) {
+    const headers = message.payload?.headers ?? [];
+    return {
+        dedupeKey: message.id,
+        payload: {
+            historyId: message.historyId ?? null,
+            labelIds: message.labelIds ?? [],
+            messageId: message.id,
+            messageTimestamp: timestamp(message.internalDate, header(headers, "Date")),
+            sender: header(headers, "From"),
+            subject: header(headers, "Subject"),
+            threadId: message.threadId ?? "",
+            to: header(headers, "To"),
+        },
+    };
+}
+async function get(context, endpoint, query = {}) {
+    try {
+        return await context.connector.execute({
+            endpoint,
+            method: "GET",
+            query: Object.fromEntries(Object.entries(query).filter((entry) => entry[1] != null)),
+        }, context.signal);
+    }
+    catch (cause) {
+        throw new TransientPollError(`Gmail proxy request to ${endpoint} failed.`, { cause });
+    }
+}
+function success(result, operation) {
+    if (result.status >= 200 && result.status < 300)
+        return;
+    if (result.status == 401 || result.status == 403)
+        throw new PollConnectionError(`Gmail ${operation} rejected the Connection.`);
+    throw new TransientPollError(`Gmail ${operation} failed with status ${result.status}.`);
+}
+function header(headers, name) {
+    return headers.find((value) => value.name.toLowerCase() == name.toLowerCase())?.value ?? "";
+}
+function timestamp(internalDate, fallback) {
+    const epoch = internalDate == null ? Number.NaN : Number(internalDate);
+    if (Number.isFinite(epoch)) {
+        const date = new Date(epoch);
+        if (!Number.isNaN(date.getTime()))
+            return date.toISOString();
+    }
+    const parsed = Date.parse(fallback);
+    return Number.isNaN(parsed) ? "" : new Date(parsed).toISOString();
+}
+function record(value) {
+    return value != null && typeof value == "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}

package/src/providers/googlecalendar/executors.d.ts

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+import type { PollDefinition } from "../../triggers/common/poll.ts";
 import type { ProviderActionHandlers } from "../provider-runtime.ts";
 import type { OAuthProviderContext } from "../provider-runtime.ts";
 type GooglecalendarRuntimeDeps = OAuthProviderContext;
@@ -7,4 +9,5 @@ export declare const googlecalendarActionHandlers: ProviderActionHandlers<"googl
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];
 export {};

package/src/providers/googlecalendar/executors.js

@@ -4,6 +4,7 @@ import { combineProviderActionHandlers, defineProviderProxy, ProviderRequestErro
 import { googlecalendarEventActionHandlers } from "./runtime-events.js";
 import { googlecalendarApiBaseUrl, googlecalendarJsonRequest, googlecalendarRequest, resolveCalendarId, resolveRuleId, resolveSettingId, } from "./runtime-shared.js";
 import { googlecalendarOAuthScopes } from "./scopes.js";
+import { googleCalendarEventChanged } from "./trigger-on-event-changed.js";
 function asObject(value) {
     return requiredRecord(value, "object input", (message) => new ProviderRequestError(400, message));
 }
@@ -566,3 +567,4 @@ function asRecord(value) {
     }
     return value;
 }
+export const triggers = [googleCalendarEventChanged];

package/src/providers/googlecalendar/trigger-on-event-changed.d.ts

@@ -0,0 +1,2 @@
+import type { PollDefinition } from "../../triggers/common/poll.ts";
+export declare const googleCalendarEventChanged: PollDefinition;

package/src/providers/googlecalendar/trigger-on-event-changed.definition.d.ts

@@ -0,0 +1,4 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "poll";
+};

package/src/providers/googlecalendar/trigger-on-event-changed.definition.js

@@ -0,0 +1,74 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const changes = ["created", "updated", "cancelled"];
+const eventSchema = s.object({
+    attendeeEmails: s.array(s.string()),
+    calendarId: s.string(),
+    changeType: s.stringEnum(changes),
+    created: { type: ["string", "null"] },
+    creatorEmail: { type: ["string", "null"] },
+    description: { type: ["string", "null"] },
+    end: { type: ["object", "null"] },
+    eventId: s.string(),
+    eventType: { type: ["string", "null"] },
+    htmlLink: { type: ["string", "null"] },
+    isAllDay: s.boolean(),
+    location: { type: ["string", "null"] },
+    organizerEmail: { type: ["string", "null"] },
+    recurringEventId: { type: ["string", "null"] },
+    start: { type: ["object", "null"] },
+    status: s.string(),
+    summary: { type: ["string", "null"] },
+    updated: { type: ["string", "null"] },
+}, {
+    additionalProperties: false,
+    required: [
+        "changeType",
+        "calendarId",
+        "eventId",
+        "status",
+        "summary",
+        "description",
+        "location",
+        "htmlLink",
+        "start",
+        "end",
+        "isAllDay",
+        "organizerEmail",
+        "creatorEmail",
+        "attendeeEmails",
+        "recurringEventId",
+        "eventType",
+        "created",
+        "updated",
+    ],
+});
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "calendarId",
+            jsonSchema: s.string({ maxLength: 1024, minLength: 1 }),
+            nullable: false,
+        },
+        {
+            handle: "changes",
+            jsonSchema: s.array(s.stringEnum(changes), { minItems: 1, uniqueItems: true }),
+            nullable: false,
+            value: changes,
+        },
+        { handle: "matchTerm", jsonSchema: s.string(), nullable: false, value: "" },
+        {
+            handle: "maxEventsPerPoll",
+            jsonSchema: s.integer({ maximum: 500, minimum: 1 }),
+            nullable: false,
+            value: 100,
+        },
+    ],
+    definitionVersion: 2,
+    description: "Polls a Google Calendar and triggers when an event is created, updated or cancelled.",
+    displayName: "Event Changed",
+    key: "googlecalendar.on_event_changed",
+    name: "on_event_changed",
+    outputs: [{ handle: "events", jsonSchema: s.array(eventSchema), nullable: false }],
+    provider: "googlecalendar",
+    type: "poll",
+};