@zapier/zapier-sdk 0.48.0 → 0.49.0

package/dist/plugins/triggers/updateTriggerInbox/index.js

@@ -0,0 +1,30 @@
+import { definePlugin, createPluginMethod } from "../../../utils/plugin-utils";
+import { UpdateTriggerInboxSchema, TriggerInboxItemSchema } from "./schemas";
+import { triggerInboxResolver } from "../../../resolvers";
+import { resolveTriggerInboxId } from "../utils";
+import { triggersDefaults } from "../shared";
+export const updateTriggerInboxPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "updateTriggerInbox",
+    type: "update",
+    itemType: "TriggerInbox",
+    inputSchema: UpdateTriggerInboxSchema,
+    outputSchema: TriggerInboxItemSchema,
+    resolvers: { inbox: triggerInboxResolver },
+    handler: async ({ sdk, options }) => {
+        const { inbox, notificationUrl } = options;
+        const inboxId = await resolveTriggerInboxId({
+            api: sdk.context.api,
+            inbox,
+        });
+        const requestBody = {};
+        if (notificationUrl !== undefined) {
+            requestBody.notification_url = notificationUrl;
+        }
+        const rawResponse = await sdk.context.api.patch(`/trigger-inbox/api/v1/inboxes/${encodeURIComponent(inboxId)}`, requestBody, {
+            authRequired: true,
+            resource: { type: "trigger_inbox", id: inboxId },
+        });
+        return { data: TriggerInboxItemSchema.parse(rawResponse) };
+    },
+}));

package/dist/plugins/triggers/updateTriggerInbox/schemas.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import type { FunctionOptions } from "../../../types/functions";
+import { TriggerInboxItemSchema, type TriggerInboxItem } from "../../../schemas/TriggerInbox";
+export declare const UpdateTriggerInboxSchema: z.ZodObject<{
+    inbox: z.ZodString & {
+        _def: z.core.$ZodStringDef & import("../../..").PositionalMetadata;
+    };
+    notificationUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type UpdateTriggerInboxOptions = z.infer<typeof UpdateTriggerInboxSchema> & FunctionOptions;
+export interface UpdateTriggerInboxResult {
+    data: TriggerInboxItem;
+}
+export { TriggerInboxItemSchema };
+//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/triggers/updateTriggerInbox/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/updateTriggerInbox/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAEhE,OAAO,EACL,sBAAsB,EACtB,KAAK,gBAAgB,EACtB,MAAM,+BAA+B,CAAC;AAEvC,eAAO,MAAM,wBAAwB;;;;;iBAYsB,CAAC;AAE5D,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,wBAAwB,CAChC,GACC,eAAe,CAAC;AAElB,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,gBAAgB,CAAC;CACxB;AAED,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/plugins/triggers/updateTriggerInbox/schemas.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { TriggerInboxPropertySchema } from "../../../types/properties";
+import { TriggerInboxItemSchema, } from "../../../schemas/TriggerInbox";
+export const UpdateTriggerInboxSchema = z
+    .object({
+    inbox: TriggerInboxPropertySchema,
+    notificationUrl: z
+        .string()
+        .url()
+        .nullable()
+        .optional()
+        .describe("Webhook URL to POST to when new messages arrive. Pass null to clear."),
+})
+    .describe("Update settings on an existing trigger inbox");
+export { TriggerInboxItemSchema };

package/dist/plugins/triggers/utils.d.ts

@@ -0,0 +1,17 @@
+import type { ApiClient } from "../../api";
+/**
+ * Resolves an `inbox` locator (UUID or name) to a UUID.
+ *
+ * Per the locator rule, the value is loose: the API takes a UUID, but the
+ * SDK accepts either form. UUID-shaped inputs pass through unchanged;
+ * anything else is looked up by name via `GET /inboxes?name=...`.
+ *
+ * Edge case: if a user names an inbox with a UUID-shaped string, this
+ * method treats it as a UUID. To target a UUID-shaped name, use
+ * `listTriggerInboxes({ name })` to get the actual UUID, then pass that.
+ */
+export declare function resolveTriggerInboxId({ api, inbox, }: {
+    api: ApiClient;
+    inbox: string;
+}): Promise<string>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/plugins/triggers/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/plugins/triggers/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAM3C;;;;;;;;;;GAUG;AACH,wBAAsB,qBAAqB,CAAC,EAC1C,GAAG,EACH,KAAK,GACN,EAAE;IACD,GAAG,EAAE,SAAS,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAAC,MAAM,CAAC,CAiBlB"}

package/dist/plugins/triggers/utils.js

@@ -0,0 +1,28 @@
+import { ZapierResourceNotFoundError } from "../../types/errors";
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Resolves an `inbox` locator (UUID or name) to a UUID.
+ *
+ * Per the locator rule, the value is loose: the API takes a UUID, but the
+ * SDK accepts either form. UUID-shaped inputs pass through unchanged;
+ * anything else is looked up by name via `GET /inboxes?name=...`.
+ *
+ * Edge case: if a user names an inbox with a UUID-shaped string, this
+ * method treats it as a UUID. To target a UUID-shaped name, use
+ * `listTriggerInboxes({ name })` to get the actual UUID, then pass that.
+ */
+export async function resolveTriggerInboxId({ api, inbox, }) {
+    if (UUID_REGEX.test(inbox)) {
+        return inbox;
+    }
+    const rawResponse = await api.get("/trigger-inbox/api/v1/inboxes", {
+        searchParams: { name: inbox, limit: "1" },
+        authRequired: true,
+    });
+    const response = rawResponse;
+    const id = response.results?.[0]?.id;
+    if (!id) {
+        throw new ZapierResourceNotFoundError(`No trigger inbox named "${inbox}" found.`, { resourceType: "trigger_inbox", resourceId: inbox });
+    }
+    return id;
+}

package/dist/plugins/triggers/watchTriggerInbox/index.d.ts

@@ -0,0 +1,163 @@
+import { type WatchTriggerInboxOptions } from "../drainTriggerInbox/schemas";
+/**
+ * `watchTriggerInbox` is the continuous-consumption variant of
+ * `drainTriggerInbox`. Same options surface, same callback shape;
+ * the difference is that an empty lease triggers poll-and-wait
+ * (with backoff) rather than ending the command. Resolves cleanly
+ * on `signal` abort or when a callback throws
+ * `ZapierAbortDrainSignal`; rejects on a fatal error or a
+ * fail-fast handler error (when `continueOnError` is false).
+ */
+export declare const watchTriggerInboxPlugin: (sdk: {
+    context: {
+        api: import("../../..").ApiClient;
+        resolveCredentials: () => Promise<string | {
+            clientId: string;
+            clientSecret: string;
+            type?: "client_credentials" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | {
+            clientId: string;
+            type?: "pkce" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | undefined>;
+    };
+} & {
+    leaseTriggerInboxMessages: (options?: {
+        inbox: string;
+        leaseLimit?: number | undefined;
+        leaseSeconds?: number | undefined;
+        signal?: AbortSignal | undefined;
+    } | undefined) => Promise<{
+        data: {
+            lease_id: string | null;
+            leased_until: string | null;
+            results: {
+                id: string;
+                created_at: string;
+                status: string;
+                message_attributes: {
+                    lease_count: number;
+                    error_message: string | null;
+                    possible_duplicate_data: boolean;
+                };
+                payload: Record<string, unknown>;
+            }[];
+            inbox_attributes: {
+                status: string;
+                paused_reason: string | null;
+            };
+        };
+    }>;
+} & {
+    context: {
+        meta: {
+            leaseTriggerInboxMessages: import("../../..").PluginMeta;
+        };
+    };
+} & {
+    ackTriggerInboxMessages: (options?: {
+        inbox: string;
+        lease: string;
+        messages?: string[] | undefined;
+    } | undefined) => Promise<{
+        data: {
+            acked_id: string | null;
+            results: {
+                id: string;
+                created_at: string;
+                status: string;
+                message_attributes: {
+                    lease_count: number;
+                    error_message: string | null;
+                    possible_duplicate_data: boolean;
+                };
+            }[];
+        };
+    }>;
+} & {
+    context: {
+        meta: {
+            ackTriggerInboxMessages: import("../../..").PluginMeta;
+        };
+    };
+} & {
+    releaseTriggerInboxMessages: (options?: {
+        inbox: string;
+        lease: string;
+        messages?: string[] | undefined;
+    } | undefined) => Promise<{
+        data: {
+            released_id: string | null;
+            results: {
+                id: string;
+                created_at: string;
+                status: string;
+                message_attributes: {
+                    lease_count: number;
+                    error_message: string | null;
+                    possible_duplicate_data: boolean;
+                };
+            }[];
+        };
+    }>;
+} & {
+    context: {
+        meta: {
+            releaseTriggerInboxMessages: import("../../..").PluginMeta;
+        };
+    };
+} & {
+    context: {
+        meta: Record<string, import("../../..").PluginMeta>;
+    };
+}) => {
+    watchTriggerInbox: (options: WatchTriggerInboxOptions) => Promise<void>;
+    context: {
+        meta: {
+            watchTriggerInbox: {
+                type: "create";
+                description: string;
+                itemType: string;
+                returnType: string;
+                inputSchema: import("zod").ZodObject<{
+                    inbox: import("zod").ZodString & {
+                        _def: import("zod/v4/core").$ZodStringDef & import("../../..").PositionalMetadata;
+                    };
+                    onMessage: import("zod").ZodOptional<import("zod").ZodFunction<import("zod/v4/core").$ZodFunctionArgs, import("zod/v4/core").$ZodFunctionOut>>;
+                    concurrency: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    leaseLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    leaseSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    releaseOnError: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    continueOnError: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    onError: import("zod").ZodOptional<import("zod").ZodFunction<import("zod/v4/core").$ZodFunctionArgs, import("zod/v4/core").$ZodFunctionOut>>;
+                    signal: import("zod").ZodOptional<import("zod").ZodCustom<AbortSignal, AbortSignal>>;
+                    maxDrainIntervalSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
+                }, import("zod/v4/core").$strip>;
+                resolvers: {
+                    inbox: import("../../..").DynamicResolver<{
+                        id: string;
+                        created_at: string;
+                        name: string | null;
+                        status: string;
+                        paused_reason: string | null;
+                        notification_url: string | null;
+                        subscription: {
+                            connection_id: string | number | null;
+                            app_key: string;
+                            action_key: string;
+                            inputs: Record<string, unknown>;
+                        };
+                    }, {}>;
+                };
+                packages: readonly ["sdk"];
+                categories: string[];
+                experimental: true;
+            };
+        };
+    };
+};
+export type WatchTriggerInboxPluginProvides = ReturnType<typeof watchTriggerInboxPlugin>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/triggers/watchTriggerInbox/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/watchTriggerInbox/index.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,wBAAwB,EAC9B,MAAM,8BAA8B,CAAC;AAkDtC;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAQrB,wBAAwB,KAChC,OAAO,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0EnB,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG,UAAU,CACtD,OAAO,uBAAuB,CAC/B,CAAC"}

package/dist/plugins/triggers/watchTriggerInbox/index.js

@@ -0,0 +1,111 @@
+import { definePlugin } from "../../../utils/plugin-utils";
+import { WatchTriggerInboxSchema, } from "../drainTriggerInbox/schemas";
+import { requireOnMessage, resolveConcurrencyAndLease, runDrainPass, } from "../drainTriggerInbox";
+import { resolveTriggerInboxId } from "../utils";
+import { triggerInboxResolver } from "../../../resolvers";
+import { triggersDefaults } from "../shared";
+const POLL_STAGES = [
+    [125, 125],
+    [375, 250],
+    [875, 500],
+    [10000, 1000],
+    [30000, 2500],
+    [60000, 5000],
+    [180000, 10000],
+];
+const DEFAULT_MAX_DRAIN_INTERVAL_MS = 60000;
+function pickPollIntervalMs(elapsedMs, maxIntervalMs) {
+    const stage = POLL_STAGES.find(([threshold]) => elapsedMs < threshold);
+    const interval = stage ? stage[1] : maxIntervalMs;
+    return Math.min(interval, maxIntervalMs);
+}
+function sleepOrAbort(ms, signal) {
+    if (signal?.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        let settled = false;
+        const settle = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", settle);
+            resolve();
+        };
+        const timer = setTimeout(settle, ms);
+        signal?.addEventListener("abort", settle, { once: true });
+    });
+}
+/**
+ * `watchTriggerInbox` is the continuous-consumption variant of
+ * `drainTriggerInbox`. Same options surface, same callback shape;
+ * the difference is that an empty lease triggers poll-and-wait
+ * (with backoff) rather than ending the command. Resolves cleanly
+ * on `signal` abort or when a callback throws
+ * `ZapierAbortDrainSignal`; rejects on a fatal error or a
+ * fail-fast handler error (when `continueOnError` is false).
+ */
+export const watchTriggerInboxPlugin = definePlugin((sdk) => {
+    async function watchTriggerInbox(options) {
+        const onMessage = requireOnMessage(options.onMessage);
+        const { concurrency, leaseLimit } = resolveConcurrencyAndLease(options);
+        const inboxId = await resolveTriggerInboxId({
+            api: sdk.context.api,
+            inbox: options.inbox,
+        });
+        const maxDrainIntervalMs = options.maxDrainIntervalSeconds !== undefined
+            ? options.maxDrainIntervalSeconds * 1000
+            : DEFAULT_MAX_DRAIN_INTERVAL_MS;
+        let firstFetch = true;
+        let lastNonEmptyAt = Date.now();
+        while (!options.signal?.aborted) {
+            const outcome = await runDrainPass({
+                sdk,
+                inboxId,
+                onMessage,
+                concurrency,
+                leaseLimit,
+                leaseSeconds: options.leaseSeconds,
+                maxMessages: undefined,
+                releaseOnError: options.releaseOnError ?? false,
+                continueOnError: options.continueOnError ?? false,
+                onError: options.onError,
+                signal: options.signal,
+                firstFetch,
+            });
+            firstFetch = false;
+            if (options.signal?.aborted)
+                return;
+            if (outcome.abortedFromCallback)
+                return;
+            if (outcome.processed > 0) {
+                lastNonEmptyAt = Date.now();
+                continue;
+            }
+            const elapsedMs = Date.now() - lastNonEmptyAt;
+            await sleepOrAbort(pickPollIntervalMs(elapsedMs, maxDrainIntervalMs), options.signal);
+        }
+    }
+    return {
+        watchTriggerInbox,
+        context: {
+            meta: {
+                watchTriggerInbox: {
+                    ...triggersDefaults,
+                    type: "create",
+                    description: "Continuously consume a trigger inbox: drain currently-available messages via onMessage, then poll with backoff for new arrivals, until aborted. Resolves cleanly on signal abort or ZapierAbortDrainSignal from a handler; rejects on fatal SDK errors or fail-fast handler errors.",
+                    itemType: "void",
+                    // See drainTriggerInbox: override the doc generator's default
+                    // suffix so the rendered return type is Promise<void>, not
+                    // Promise<voidItem>.
+                    returnType: "void",
+                    inputSchema: WatchTriggerInboxSchema,
+                    resolvers: {
+                        inbox: triggerInboxResolver,
+                    },
+                    packages: ["sdk"],
+                },
+            },
+        },
+    };
+});

package/dist/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AA4CvD,wBAAgB,aAAa,CAAC,EAC5B,GAAG,EACH,IAAI,EACJ,aAAa,GACd,EAAE;IACD,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACjC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,cAAc,CAmEjB"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AA6CvD,wBAAgB,aAAa,CAAC,EAC5B,GAAG,EACH,IAAI,EACJ,aAAa,GACd,EAAE;IACD,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACjC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,cAAc,CAoEjB"}

package/dist/registry.js

@@ -28,6 +28,7 @@ const categoryDefinitions = {
         titlePlural: "Client Credentials",
     },
     table: { title: "Table" },
+    trigger: { title: "Trigger" },
     http: { title: "HTTP Request" },
     utility: { title: "Utility", titlePlural: "Utilities" },
     other: { title: "Other" },
@@ -57,6 +58,7 @@ export function buildRegistry({ sdk, meta, packageFilter, }) {
             categories: m.categories || [],
             resolvers: m.resolvers,
             formatter: m.formatter,
+            experimental: m.experimental,
             packages: m.packages,
             confirm: m.confirm ?? (m.type === "delete" ? "delete" : undefined),
             deprecation: m.deprecation,

package/dist/resolvers/actionKey.d.ts

@@ -6,6 +6,7 @@ export interface ActionItem {
     name?: string;
     description?: string;
     action_type: string;
+    is_hidden?: boolean;
 }
 export declare const actionKeyResolver: DynamicResolver<ActionItem, {
     app: string;

package/dist/resolvers/actionKey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"actionKey.d.ts","sourceRoot":"","sources":["../../src/resolvers/actionKey.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,iBAAiB,EAAE,eAAe,CAC7C,UAAU,EACV;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,kBAAkB,CAAA;CAAE,CAuBhD,CAAC"}
+{"version":3,"file":"actionKey.d.ts","sourceRoot":"","sources":["../../src/resolvers/actionKey.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,eAAO,MAAM,iBAAiB,EAAE,eAAe,CAC7C,UAAU,EACV;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,kBAAkB,CAAA;CAAE,CAwBhD,CAAC"}

package/dist/resolvers/actionKey.js

@@ -5,7 +5,7 @@ export const actionKeyResolver = {
         const actionsResponse = await sdk.listActions({
             app: resolvedParams.app,
         });
-        return actionsResponse.data.filter((action) => action.action_type === resolvedParams.actionType);
+        return actionsResponse.data.filter((action) => action.action_type === resolvedParams.actionType && !action.is_hidden);
     },
     prompt: (actions) => ({
         type: "list",

package/dist/resolvers/index.d.ts

@@ -6,12 +6,12 @@ export { connectionIdResolver, connectionIdGenericResolver, } from "./connection
 export { connectionIdResolver as authenticationIdResolver } from "./connectionId";
 /** @deprecated Use connectionIdGenericResolver instead */
 export { connectionIdGenericResolver as authenticationIdGenericResolver } from "./connectionId";
-export { inputsResolver } from "./inputs";
+export { inputsResolver, inputsAllOptionalResolver } from "./inputs";
 export { inputFieldKeyResolver } from "./inputFieldKey";
-export { inputsAllOptionalResolver } from "./inputs";
 export { clientCredentialsNameResolver } from "./clientCredentialsName";
 export { clientIdResolver } from "./clientId";
 export { tableIdResolver } from "./tableId";
+export { triggerInboxResolver } from "./triggerInbox";
 export { tableRecordIdResolver, tableRecordIdsResolver } from "./tableRecordId";
 export { tableFieldIdsResolver } from "./tableFieldIds";
 export { tableNameResolver } from "./tableName";

package/dist/resolvers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resolvers/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EACL,oBAAoB,EACpB,2BAA2B,GAC5B,MAAM,gBAAgB,CAAC;AAGxB,mDAAmD;AACnD,OAAO,EAAE,oBAAoB,IAAI,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAClF,0DAA0D;AAC1D,OAAO,EAAE,2BAA2B,IAAI,+BAA+B,EAAE,MAAM,gBAAgB,CAAC;AAChG,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AACrD,OAAO,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAChF,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EACL,oBAAoB,EACpB,0BAA0B,GAC3B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resolvers/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EACL,oBAAoB,EACpB,2BAA2B,GAC5B,MAAM,gBAAgB,CAAC;AAGxB,mDAAmD;AACnD,OAAO,EAAE,oBAAoB,IAAI,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAClF,0DAA0D;AAC1D,OAAO,EAAE,2BAA2B,IAAI,+BAA+B,EAAE,MAAM,gBAAgB,CAAC;AAChG,OAAO,EAAE,cAAc,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAChF,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EACL,oBAAoB,EACpB,0BAA0B,GAC3B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC"}

package/dist/resolvers/index.js

@@ -8,12 +8,12 @@ export { connectionIdResolver, connectionIdGenericResolver, } from "./connection
 export { connectionIdResolver as authenticationIdResolver } from "./connectionId";
 /** @deprecated Use connectionIdGenericResolver instead */
 export { connectionIdGenericResolver as authenticationIdGenericResolver } from "./connectionId";
-export { inputsResolver } from "./inputs";
+export { inputsResolver, inputsAllOptionalResolver } from "./inputs";
 export { inputFieldKeyResolver } from "./inputFieldKey";
-export { inputsAllOptionalResolver } from "./inputs";
 export { clientCredentialsNameResolver } from "./clientCredentialsName";
 export { clientIdResolver } from "./clientId";
 export { tableIdResolver } from "./tableId";
+export { triggerInboxResolver } from "./triggerInbox";
 export { tableRecordIdResolver, tableRecordIdsResolver } from "./tableRecordId";
 export { tableFieldIdsResolver } from "./tableFieldIds";
 export { tableNameResolver } from "./tableName";

package/dist/resolvers/triggerInbox.d.ts

@@ -0,0 +1,4 @@
+import type { DynamicResolver } from "../utils/schema-utils";
+import type { TriggerInboxItem } from "../schemas/TriggerInbox";
+export declare const triggerInboxResolver: DynamicResolver<TriggerInboxItem, {}>;
+//# sourceMappingURL=triggerInbox.d.ts.map

package/dist/resolvers/triggerInbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triggerInbox.d.ts","sourceRoot":"","sources":["../../src/resolvers/triggerInbox.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAchE,eAAO,MAAM,oBAAoB,EAAE,eAAe,CAAC,gBAAgB,EAAE,EAAE,CAiBtE,CAAC"}

package/dist/resolvers/triggerInbox.js

@@ -0,0 +1,18 @@
+import { toIterable } from "../utils/pagination-utils";
+export const triggerInboxResolver = {
+    type: "dynamic",
+    fetch: async (sdk) => toIterable(sdk.listTriggerInboxes()),
+    prompt: (inboxes) => ({
+        type: "list",
+        name: "inbox",
+        message: "Select a trigger inbox:",
+        // `deleting` inboxes are on their way out — no operation against them
+        // is useful (delete is a no-op, pause/resume/update are rejected).
+        choices: inboxes
+            .filter((inbox) => inbox.status !== "deleting")
+            .map((inbox) => ({
+            name: `${inbox.name ?? inbox.id} (${inbox.subscription.app_key} / ${inbox.subscription.action_key}, ${inbox.status})`,
+            value: inbox.id,
+        })),
+    }),
+};

package/dist/schemas/TriggerInbox.d.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+export declare const TriggerInboxStatusSchema: z.ZodUnion<readonly [z.ZodEnum<{
+    initializing: "initializing";
+    active: "active";
+    paused: "paused";
+    deleting: "deleting";
+    initialization_failure: "initialization_failure";
+}>, z.ZodString]>;
+export type TriggerInboxStatus = z.infer<typeof TriggerInboxStatusSchema>;
+export declare const TriggerInboxPausedReasonSchema: z.ZodUnion<readonly [z.ZodEnum<{
+    unknown: "unknown";
+    user: "user";
+    authentication: "authentication";
+    authentication_access_revoked: "authentication_access_revoked";
+    partner_revoked: "partner_revoked";
+    subscribe_failed: "subscribe_failed";
+    migrate_failed: "migrate_failed";
+    abandoned: "abandoned";
+    upstream_failures: "upstream_failures";
+}>, z.ZodString]>;
+export type TriggerInboxPausedReason = z.infer<typeof TriggerInboxPausedReasonSchema>;
+export declare const TriggerSubscriptionApiSchema: z.ZodObject<{
+    connection_id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+    app_key: z.ZodString;
+    action_key: z.ZodString;
+    inputs: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const TriggerInboxItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    created_at: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    status: z.ZodUnion<readonly [z.ZodEnum<{
+        initializing: "initializing";
+        active: "active";
+        paused: "paused";
+        deleting: "deleting";
+        initialization_failure: "initialization_failure";
+    }>, z.ZodString]>;
+    paused_reason: z.ZodNullable<z.ZodUnion<readonly [z.ZodEnum<{
+        unknown: "unknown";
+        user: "user";
+        authentication: "authentication";
+        authentication_access_revoked: "authentication_access_revoked";
+        partner_revoked: "partner_revoked";
+        subscribe_failed: "subscribe_failed";
+        migrate_failed: "migrate_failed";
+        abandoned: "abandoned";
+        upstream_failures: "upstream_failures";
+    }>, z.ZodString]>>;
+    notification_url: z.ZodNullable<z.ZodString>;
+    subscription: z.ZodObject<{
+        connection_id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+        app_key: z.ZodString;
+        action_key: z.ZodString;
+        inputs: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type TriggerInboxItem = z.infer<typeof TriggerInboxItemSchema>;
+//# sourceMappingURL=TriggerInbox.d.ts.map

package/dist/schemas/TriggerInbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TriggerInbox.d.ts","sourceRoot":"","sources":["../../src/schemas/TriggerInbox.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,wBAAwB;;;;;;iBAWA,CAAC;AAEtC,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAI1E,eAAO,MAAM,8BAA8B;;;;;;;;;;iBAeW,CAAC;AAEvD,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,8BAA8B,CACtC,CAAC;AAEF,eAAO,MAAM,4BAA4B;;;;;iBAKvC,CAAC;AAYH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuClC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}