@oomol-lab/open-connector 1.7.0 → 1.8.0

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

@@ -0,0 +1,93 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const defaultFolder = "inbox";
+const defaultPageSize = 25;
+const eventSchema = s.object({
+    bodyPreview: s.string(),
+    categories: s.array(s.string()),
+    conversationId: s.string(),
+    from: s.string(),
+    fromName: s.string(),
+    hasAttachments: s.boolean(),
+    importance: s.string(),
+    internetMessageId: s.string(),
+    isDraft: s.boolean(),
+    isRead: s.boolean(),
+    messageId: s.string(),
+    parentFolderId: s.string(),
+    receivedDateTime: s.string(),
+    subject: s.string(),
+    to: s.array(s.string()),
+    webLink: s.string(),
+}, {
+    additionalProperties: false,
+    required: [
+        "messageId",
+        "internetMessageId",
+        "conversationId",
+        "subject",
+        "bodyPreview",
+        "from",
+        "fromName",
+        "to",
+        "receivedDateTime",
+        "hasAttachments",
+        "isRead",
+        "isDraft",
+        "importance",
+        "categories",
+        "parentFolderId",
+        "webLink",
+    ],
+});
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "folder",
+            jsonSchema: s.string({ pattern: "^[A-Za-z0-9_=-]*$" }),
+            nullable: false,
+            value: defaultFolder,
+            description: "A well-known mail folder name, folder ID, or an empty string for the whole mailbox.",
+        },
+        { handle: "includeDrafts", jsonSchema: s.boolean(), nullable: false, value: false },
+        {
+            handle: "maxMessagesPerPoll",
+            jsonSchema: s.integer({ maximum: 100, minimum: 1 }),
+            nullable: false,
+            value: defaultPageSize,
+        },
+        {
+            handle: "readStatus",
+            jsonSchema: s.stringEnum(["All", "Read", "Unread"]),
+            nullable: false,
+            value: "All",
+        },
+        {
+            handle: "senderAddress",
+            jsonSchema: s.string(),
+            nullable: false,
+            value: "",
+            description: "Exact sender address, or empty for any sender.",
+        },
+        {
+            handle: "subjectContains",
+            jsonSchema: s.string(),
+            nullable: false,
+            value: "",
+            description: "Case-insensitive subject text.",
+        },
+        {
+            handle: "withAttachmentsOnly",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: false,
+        },
+    ],
+    definitionVersion: 2,
+    description: "Polls a Microsoft Outlook mail folder and triggers when a new message arrives.",
+    displayName: "New Message Received",
+    key: "outlook.on_message_received",
+    name: "on_message_received",
+    outputs: [{ handle: "events", jsonSchema: s.array(eventSchema), nullable: false }],
+    provider: "outlook",
+    type: "poll",
+};

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

@@ -0,0 +1,226 @@
+import { eventsPollOutputs, PermanentPollError, PollConnectionError, TransientPollError, } from "../../triggers/common/poll.js";
+import { snapshot } from "./trigger-on-message-received.definition.js";
+const markerPageSize = 100;
+const seedAnchor = "1970-01-01T00:00:00Z";
+const select = "id,internetMessageId,conversationId,subject,bodyPreview,from,toRecipients,receivedDateTime,hasAttachments,isRead,isDraft,importance,categories,parentFolderId,webLink";
+export const outlookMessageReceived = {
+    buildOutputs: eventsPollOutputs,
+    snapshot,
+    async poll(context) {
+        const config = resolveConfig(context.config);
+        if (context.checkpoint === null)
+            return { checkpoint: (await seed(context, config)), events: [] };
+        const checkpoint = readCheckpoint(context.checkpoint);
+        const result = await get(context, endpoint(config.folder), {
+            $filter: filter(config, checkpoint.lastReceivedDateTime),
+            $orderby: "receivedDateTime asc",
+            $select: select,
+            $top: config.maxMessagesPerPoll,
+        });
+        success(result, "message list");
+        const rows = messages(result.data);
+        if (rows.length == 0)
+            return { checkpoint: checkpoint, events: [] };
+        const previousMs = Date.parse(checkpoint.lastReceivedDateTime);
+        let watermarkMs = previousMs;
+        let watermark = checkpoint.lastReceivedDateTime;
+        for (const row of rows) {
+            const ms = isoMs(row.receivedDateTime);
+            if (row.receivedDateTime != null && ms != null && ms > watermarkMs) {
+                watermarkMs = ms;
+                watermark = row.receivedDateTime;
+            }
+        }
+        const moved = watermarkMs > previousMs;
+        const processed = new Set(checkpoint.boundaryMessageIds);
+        const full = rows.length >= config.maxMessagesPerPoll;
+        if (full && !moved && rows.every((row) => typeof row.id == "string" && processed.has(row.id))) {
+            throw new PermanentPollError("Outlook cursor is stuck on a full timestamp boundary; increase maxMessagesPerPoll and resume the Trigger.");
+        }
+        const boundary = new Set(moved ? [] : checkpoint.boundaryMessageIds);
+        const events = [];
+        let filtered = 0;
+        for (const row of rows) {
+            if (row.id == null || row.id.length == 0)
+                continue;
+            if (isoMs(row.receivedDateTime) == watermarkMs)
+                boundary.add(row.id);
+            if (processed.has(row.id))
+                continue;
+            if (!matches(row, config)) {
+                filtered += 1;
+                continue;
+            }
+            events.push(event(row, row.id));
+        }
+        const hasMore = full && (moved || events.length > 0);
+        return {
+            checkpoint: { boundaryMessageIds: [...boundary], lastReceivedDateTime: watermark },
+            events,
+            filtered,
+            ...(hasMore ? { hasMore: true } : {}),
+        };
+    },
+};
+function resolveConfig(value) {
+    return {
+        folder: value.folder,
+        includeDrafts: value.includeDrafts,
+        maxMessagesPerPoll: value.maxMessagesPerPoll,
+        readStatus: value.readStatus,
+        senderAddress: value.senderAddress.trim(),
+        subjectContains: value.subjectContains.trim(),
+        withAttachmentsOnly: value.withAttachmentsOnly,
+    };
+}
+async function seed(context, config) {
+    const marker = await get(context, endpoint(config.folder), {
+        $orderby: "receivedDateTime desc",
+        $select: "id,receivedDateTime",
+        $top: markerPageSize,
+    });
+    success(marker, "seed marker fetch");
+    const shape = await get(context, endpoint(config.folder), {
+        $filter: filter(config, seedAnchor),
+        $orderby: "receivedDateTime desc",
+        $top: 1,
+    });
+    success(shape, "seed filter shape check");
+    const newest = newestMessage(messages(marker.data));
+    if (newest == null)
+        return { boundaryMessageIds: [], lastReceivedDateTime: context.now.toISOString() };
+    const boundary = messages(marker.data).filter((row) => isoMs(row.receivedDateTime) == newest.ms);
+    if (boundary.length >= config.maxMessagesPerPoll) {
+        return {
+            boundaryMessageIds: [],
+            lastReceivedDateTime: new Date(newest.ms + 1_000).toISOString(),
+        };
+    }
+    return {
+        boundaryMessageIds: boundary.flatMap((row) => (row.id == null || row.id.length == 0 ? [] : [row.id])),
+        lastReceivedDateTime: newest.iso,
+    };
+}
+function readCheckpoint(value) {
+    const checkpoint = record(value);
+    const watermark = checkpoint?.lastReceivedDateTime;
+    if (typeof watermark != "string" || isoMs(watermark) == null) {
+        throw new PermanentPollError("Outlook checkpoint is invalid; recreate the Trigger.");
+    }
+    const boundary = checkpoint?.boundaryMessageIds;
+    return {
+        boundaryMessageIds: Array.isArray(boundary)
+            ? boundary.filter((id) => typeof id == "string" && id.length > 0)
+            : [],
+        lastReceivedDateTime: watermark,
+    };
+}
+function endpoint(folder) {
+    return folder.length == 0 ? "/me/messages" : `/me/mailFolders/${encodeURIComponent(folder)}/messages`;
+}
+function filter(config, watermark) {
+    const clauses = [`receivedDateTime ge ${watermark}`];
+    if (config.readStatus == "Unread")
+        clauses.push("isRead eq false");
+    if (config.readStatus == "Read")
+        clauses.push("isRead eq true");
+    if (config.withAttachmentsOnly)
+        clauses.push("hasAttachments eq true");
+    if (config.senderAddress.length > 0)
+        clauses.push(`from/emailAddress/address eq '${config.senderAddress.replaceAll("'", "''")}'`);
+    return clauses.join(" and ");
+}
+function matches(message, config) {
+    if (message.isDraft === true && !config.includeDrafts)
+        return false;
+    return (config.subjectContains.length == 0 ||
+        (message.subject ?? "").toLowerCase().includes(config.subjectContains.toLowerCase()));
+}
+function event(message, id) {
+    return {
+        dedupeKey: id,
+        payload: {
+            bodyPreview: message.bodyPreview ?? "",
+            categories: message.categories ?? [],
+            conversationId: message.conversationId ?? "",
+            from: message.from?.emailAddress?.address ?? "",
+            fromName: message.from?.emailAddress?.name ?? "",
+            hasAttachments: message.hasAttachments ?? false,
+            importance: message.importance ?? "",
+            internetMessageId: message.internetMessageId ?? "",
+            isDraft: message.isDraft ?? false,
+            isRead: message.isRead ?? false,
+            messageId: id,
+            parentFolderId: message.parentFolderId ?? "",
+            receivedDateTime: message.receivedDateTime ?? "",
+            subject: message.subject ?? "",
+            to: (message.toRecipients ?? []).flatMap(({ emailAddress }) => emailAddress?.address == null ? [] : [emailAddress.address]),
+            webLink: message.webLink ?? "",
+        },
+    };
+}
+async function get(context, path, query) {
+    try {
+        return await context.connector.execute({ endpoint: path, headers: { Prefer: 'IdType="ImmutableId"' }, method: "GET", query }, context.signal);
+    }
+    catch (cause) {
+        throw new TransientPollError(`Outlook proxy request to ${path} failed.`, { cause });
+    }
+}
+function success(result, operation) {
+    if (result.status >= 200 && result.status < 300)
+        return;
+    const codes = errorCodes(result.data);
+    if (result.status == 401)
+        throw new PollConnectionError(`Outlook ${operation} rejected the Connection.`);
+    if (result.status == 403 && codes.has("mailboxnotenabledforrestapi")) {
+        throw new PermanentPollError("The Outlook mailbox is not reachable through the Graph mail APIs.");
+    }
+    if (result.status == 403 && (codes.has("accessdenied") || codes.has("erroraccessdenied"))) {
+        throw new PollConnectionError(`Outlook ${operation} rejected the Connection.`);
+    }
+    if (result.status == 404 && (codes.has("erroritemnotfound") || codes.has("itemnotfound"))) {
+        throw new PermanentPollError("The configured Outlook folder does not exist.");
+    }
+    if (result.status == 400 && (codes.has("errorinvalididmalformed") || codes.has("inefficientfilter"))) {
+        throw new PermanentPollError("Outlook rejected the configured folder or filters.");
+    }
+    throw new TransientPollError(`Outlook ${operation} failed with status ${result.status}.`);
+}
+function errorCodes(data) {
+    const codes = new Set();
+    let value = record(data)?.error;
+    for (let depth = 0; depth < 4; depth += 1) {
+        const error = record(value);
+        if (error == null)
+            break;
+        if (typeof error.code == "string" && error.code.length > 0)
+            codes.add(error.code.toLowerCase());
+        value = error.innerError ?? error.innererror;
+    }
+    return codes;
+}
+function messages(data) {
+    const value = record(data)?.value;
+    return Array.isArray(value) ? value : [];
+}
+function newestMessage(rows) {
+    let newest = null;
+    for (const row of rows) {
+        const ms = isoMs(row.receivedDateTime);
+        if (row.receivedDateTime != null && ms != null && (newest == null || ms > newest.ms))
+            newest = { iso: row.receivedDateTime, ms };
+    }
+    return newest;
+}
+function isoMs(value) {
+    if (value == null || value.length == 0)
+        return null;
+    const milliseconds = Date.parse(value);
+    return Number.isNaN(milliseconds) ? null : milliseconds;
+}
+function record(value) {
+    return value != null && typeof value == "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}

package/src/providers/outlook_calendar/executors.js

@@ -1,6 +1,7 @@
 import { compactObject, looseArray, optionalBoolean, optionalNumber, optionalRawString, optionalRecord, optionalString, requiredString, } from "../../core/cast.js";
 import { compactJson, encodePathSegment } from "../../core/request.js";
 import { microsoftGraphJson, microsoftGraphRequest } from "../outlook/microsoft-graph.js";
+import { providerInputError } from "../provider-runtime.js";
 import { defineOAuthProviderExecutors, defineProviderProxy, requiredInputString } from "../provider-runtime.js";
 const service = "outlook_calendar";
 const graphBaseUrl = "https://graph.microsoft.com/v1.0";
@@ -102,6 +103,11 @@ async function listEvents(input, context, calendarView) {
     // a deltaLink starts the next one.
     const followUpLink = optionalString(input.nextLink) ?? (calendarView ? optionalString(input.deltaLink) : undefined);
     const delta = calendarView && input.delta === true;
+    if (delta &&
+        !followUpLink &&
+        [input.select, input.filter, input.orderby, input.expand].some((value) => value !== undefined)) {
+        throw providerInputError("Calendar view delta does not support select, filter, orderby or expand.");
+    }
     const calendar = optionalString(input.calendarId);
     const collection = calendarView ? "calendarView" : "events";
     const path = `${calendar ? `me/calendars/${encodePathSegment(calendar)}/${collection}` : `me/${collection}`}${delta ? "/delta" : ""}`;

package/src/providers/provider-loader.d.ts

@@ -1,6 +1,9 @@
 import type { ActionExecutor, CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../core/types.ts";
 import type { ProviderOAuthRuntime } from "../oauth/oauth-token.ts";
+import type { IntegrationDefinition } from "../triggers/common/integration.ts";
+import type { PollDefinition } from "../triggers/common/poll.ts";
 export interface ExecutorModule {
+    triggers?: readonly (IntegrationDefinition | PollDefinition)[];
     credentialValidators?: CredentialValidators;
     executors: ProviderExecutors;
     oauth?: ProviderOAuthRuntime;
@@ -30,6 +33,7 @@ export interface IProviderLoader {
      * Load a provider credential validator only when a connection is created.
      */
     loadCredentialValidators(service: string): Promise<CredentialValidators | undefined>;
+    loadTriggerDefinitions?(service: string): Promise<readonly (IntegrationDefinition | PollDefinition)[]>;
     /** Load provider-specific OAuth operations when the provider defines them. */
     loadProviderOAuthRuntime?(service: string): Promise<ProviderOAuthRuntime | undefined>;
 }
@@ -43,5 +47,6 @@ export declare class ProviderLoader implements IProviderLoader {
     loadProxyExecutor(service: string, _providerDisplayName?: string): Promise<ProviderProxyExecutor | undefined>;
     loadCredentialValidators(service: string): Promise<CredentialValidators | undefined>;
     loadProviderOAuthRuntime(service: string): Promise<ProviderOAuthRuntime | undefined>;
+    loadTriggerDefinitions(service: string): Promise<readonly (IntegrationDefinition | PollDefinition)[]>;
     private _findActionExecutor;
 }

package/src/providers/provider-loader.js

@@ -39,6 +39,10 @@ export class ProviderLoader {
         }
         return (await loadRuntime()).oauth;
     }
+    async loadTriggerDefinitions(service) {
+        const load = this.executorModules[service];
+        return load ? ((await load()).triggers ?? []) : [];
+    }
     _findActionExecutor(service, actionId, executors) {
         if (!actionId.startsWith(`${service}.`)) {
             return undefined;

package/src/providers/registry.generated.js

@@ -439,6 +439,7 @@ export const executorModules = {
     encodian: () => import("./encodian/executors.js"),
     energy_performance_certificates: () => import("./energy_performance_certificates/executors.js"),
     enigma: () => import("./enigma/executors.js"),
+    enormail: () => import("./enormail/executors.js"),
     envoy: () => import("./envoy/executors.js"),
     eodhd_apis: () => import("./eodhd_apis/executors.js"),
     eraser: () => import("./eraser/executors.js"),
@@ -661,6 +662,7 @@ export const executorModules = {
     imgix: () => import("./imgix/executors.js"),
     incident_io: () => import("./incident_io/executors.js"),
     indeed: () => import("./indeed/executors.js"),
+    indexed: () => import("./indexed/executors.js"),
     indiegogo: () => import("./indiegogo/executors.js"),
     influxdb_cloud: () => import("./influxdb_cloud/executors.js"),
     infolobby: () => import("./infolobby/executors.js"),

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

@@ -1,4 +1,7 @@
 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";
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];

package/src/providers/shopify/executors.js

@@ -2,6 +2,7 @@ import { optionalRecord, optionalString } from "../../core/cast.js";
 import { defineProviderExecutors, defineProviderProxy, ProviderRequestError } from "../provider-runtime.js";
 import { buildShopifyRestApiBaseUrl, normalizeShopDomain, shopifyActionHandlers, validateShopifyCredential, } from "./runtime.js";
 import { shopifyReadContentScope } from "./scopes.js";
+import { shopifyShopEvent } from "./trigger-on-shop-event.js";
 const service = "shopify";
 export const executors = defineProviderExecutors({
     service,
@@ -62,3 +63,4 @@ function parseShopifyScopes(value) {
         .map((scope) => scope.trim())
         .filter(Boolean);
 }
+export const triggers = [shopifyShopEvent];

package/src/providers/shopify/trigger-on-shop-event.d.ts

@@ -0,0 +1,2 @@
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+export declare const shopifyShopEvent: IntegrationDefinition;

package/src/providers/shopify/trigger-on-shop-event.definition.d.ts

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

package/src/providers/shopify/trigger-on-shop-event.definition.js

@@ -0,0 +1,214 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const topics = [
+    "app/scopes_update",
+    "app/uninstalled",
+    "app_purchases_one_time/update",
+    "app_subscriptions/approaching_capped_amount",
+    "app_subscriptions/update",
+    "bulk_operations/finish",
+    "carts/create",
+    "carts/update",
+    "channels/delete",
+    "checkout_and_accounts_configurations/update",
+    "checkouts/create",
+    "checkouts/delete",
+    "checkouts/update",
+    "collection_listings/add",
+    "collection_listings/remove",
+    "collection_listings/update",
+    "collection_publications/create",
+    "collection_publications/delete",
+    "collection_publications/update",
+    "collections/create",
+    "collections/delete",
+    "collections/update",
+    "companies/create",
+    "companies/delete",
+    "companies/update",
+    "company_contact_roles/assign",
+    "company_contact_roles/revoke",
+    "company_contacts/create",
+    "company_contacts/delete",
+    "company_contacts/update",
+    "company_locations/create",
+    "company_locations/delete",
+    "company_locations/update",
+    "customer.joined_segment",
+    "customer.left_segment",
+    "customer.tags_added",
+    "customer.tags_removed",
+    "customer_account_settings/update",
+    "customer_groups/create",
+    "customer_groups/delete",
+    "customer_groups/update",
+    "customers/create",
+    "customers/delete",
+    "customers/disable",
+    "customers/enable",
+    "customers/purchasing_summary",
+    "customers/update",
+    "customers_email_marketing_consent/update",
+    "customers_marketing_consent/update",
+    "delivery_promise_settings/update",
+    "disputes/create",
+    "disputes/update",
+    "domains/create",
+    "domains/destroy",
+    "domains/update",
+    "draft_orders/create",
+    "draft_orders/delete",
+    "draft_orders/update",
+    "fulfillment_events/create",
+    "fulfillment_events/delete",
+    "fulfillment_holds/added",
+    "fulfillment_holds/released",
+    "fulfillment_orders/cancellation_request_accepted",
+    "fulfillment_orders/cancellation_request_rejected",
+    "fulfillment_orders/cancellation_request_submitted",
+    "fulfillment_orders/cancelled",
+    "fulfillment_orders/fulfillment_request_accepted",
+    "fulfillment_orders/fulfillment_request_rejected",
+    "fulfillment_orders/fulfillment_request_submitted",
+    "fulfillment_orders/fulfillment_service_failed_to_complete",
+    "fulfillment_orders/hold_released",
+    "fulfillment_orders/line_items_prepared_for_local_delivery",
+    "fulfillment_orders/line_items_prepared_for_pickup",
+    "fulfillment_orders/manually_reported_progress_stopped",
+    "fulfillment_orders/merged",
+    "fulfillment_orders/moved",
+    "fulfillment_orders/order_routing_complete",
+    "fulfillment_orders/placed_on_hold",
+    "fulfillment_orders/progress_reported",
+    "fulfillment_orders/rescheduled",
+    "fulfillment_orders/scheduled_fulfillment_order_ready",
+    "fulfillment_orders/split",
+    "fulfillments/create",
+    "fulfillments/update",
+    "inventory_items/create",
+    "inventory_items/delete",
+    "inventory_items/update",
+    "inventory_levels/connect",
+    "inventory_levels/disconnect",
+    "inventory_levels/update",
+    "locales/create",
+    "locales/destroy",
+    "locales/update",
+    "locations/activate",
+    "locations/create",
+    "locations/deactivate",
+    "locations/delete",
+    "locations/update",
+    "machine_translation_batch/completed",
+    "metafield_definitions/create",
+    "metafield_definitions/delete",
+    "metafield_definitions/update",
+    "order_transactions/create",
+    "orders/cancelled",
+    "orders/create",
+    "orders/delete",
+    "orders/edited",
+    "orders/fulfilled",
+    "orders/link_requested",
+    "orders/paid",
+    "orders/partially_fulfilled",
+    "orders/risk_assessment_changed",
+    "orders/shopify_protect_eligibility_changed",
+    "orders/updated",
+    "payment_schedules/due",
+    "payment_terms/create",
+    "payment_terms/delete",
+    "payment_terms/update",
+    "product_feeds/create",
+    "product_feeds/full_sync",
+    "product_feeds/full_sync_finish",
+    "product_feeds/incremental_sync",
+    "product_feeds/update",
+    "product_listings/add",
+    "product_listings/remove",
+    "product_listings/update",
+    "product_publications/create",
+    "product_publications/delete",
+    "product_publications/update",
+    "products/create",
+    "products/delete",
+    "products/update",
+    "profiles/create",
+    "profiles/delete",
+    "profiles/update",
+    "publications/delete",
+    "refunds/create",
+    "returns/approve",
+    "returns/cancel",
+    "returns/close",
+    "returns/decline",
+    "returns/process",
+    "returns/reopen",
+    "returns/request",
+    "returns/update",
+    "reverse_deliveries/attach_deliverable",
+    "reverse_fulfillment_orders/dispose",
+    "scheduled_product_listings/add",
+    "scheduled_product_listings/remove",
+    "scheduled_product_listings/update",
+    "segments/create",
+    "segments/delete",
+    "segments/update",
+    "selling_plan_groups/create",
+    "selling_plan_groups/delete",
+    "selling_plan_groups/update",
+    "shop/update",
+    "subscription_billing_attempts/challenged",
+    "subscription_billing_attempts/failure",
+    "subscription_billing_attempts/success",
+    "subscription_billing_cycle_edits/create",
+    "subscription_billing_cycle_edits/delete",
+    "subscription_billing_cycle_edits/update",
+    "subscription_billing_cycles/skip",
+    "subscription_billing_cycles/unskip",
+    "subscription_contracts/activate",
+    "subscription_contracts/cancel",
+    "subscription_contracts/create",
+    "subscription_contracts/expire",
+    "subscription_contracts/fail",
+    "subscription_contracts/pause",
+    "subscription_contracts/update",
+    "tax_partners/update",
+    "tax_summaries/create",
+    "tender_transactions/create",
+    "themes/create",
+    "themes/delete",
+    "themes/publish",
+    "themes/update",
+    "variants/in_stock",
+    "variants/out_of_stock",
+];
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "topics",
+            jsonSchema: s.array(s.stringEnum(topics), { maxItems: 20, minItems: 1, uniqueItems: true }),
+            nullable: false,
+        },
+    ],
+    definitionVersion: 2,
+    description: "Triggers when selected Shopify webhook topics occur in the connected store.",
+    displayName: "Store Event",
+    endpoint: {
+        body: { allowArray: false, allowEmpty: false, formats: ["json"] },
+        methods: ["POST"],
+        successStatus: 202,
+    },
+    key: "shopify.on_shop_event",
+    name: "on_shop_event",
+    outputs: [
+        { handle: "apiVersion", jsonSchema: s.string(), nullable: false },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+        { handle: "eventId", jsonSchema: s.string(), nullable: false },
+        { handle: "shopDomain", jsonSchema: s.string(), nullable: false },
+        { handle: "topic", jsonSchema: s.string(), nullable: false },
+        { handle: "triggeredAt", jsonSchema: s.string(), nullable: false },
+        { handle: "webhookId", jsonSchema: s.string(), nullable: false },
+    ],
+    provider: "shopify",
+    type: "integration",
+};