@zapier/zapier-sdk 0.48.1 → 0.50.0

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

@@ -0,0 +1,102 @@
+import { z } from "zod";
+import { TriggerInboxPropertySchema, LeaseSecondsPropertySchema, } from "../../../types/properties";
+import { ZapierSignal } from "../../../types/signals";
+/**
+ * Signal an `onMessage` callback can throw to release the current
+ * message back to the inbox immediately (status returns to
+ * `available`) rather than leaving it leased until the lease
+ * timeout. The actual release call is deferred to the end of the
+ * drain so the same drain doesn't immediately re-lease it.
+ *
+ * Always triggers release regardless of `releaseOnError`.
+ */
+export class ZapierReleaseTriggerMessageSignal extends ZapierSignal {
+    constructor() {
+        super(...arguments);
+        this.name = "ZapierReleaseTriggerMessageSignal";
+        this.code = "ZAPIER_RELEASE_TRIGGER_MESSAGE_SIGNAL";
+    }
+}
+/**
+ * Signal an `onMessage` callback can throw to stop the drain after
+ * the current batch — no further leases, no further callbacks. The
+ * triggering message gets the same release-or-leave treatment as any
+ * thrown error (per `releaseOnError`). Other in-flight messages in
+ * the same batch finish normally before the command returns.
+ * Already-leased-but-not-yet-started messages are released so
+ * they're available for re-lease.
+ */
+export class ZapierAbortDrainSignal extends ZapierSignal {
+    constructor() {
+        super(...arguments);
+        this.name = "ZapierAbortDrainSignal";
+        this.code = "ZAPIER_ABORT_DRAIN_SIGNAL";
+    }
+}
+/**
+ * Source-level options shared by `drainTriggerInbox` and
+ * `watchTriggerInbox`. Both methods are eager commands that lease,
+ * process via `onMessage`, and return when done.
+ *
+ * `onMessage` is required. There's no identity default, since "lease
+ * and ack everything in this inbox" is a footgun that destroys data
+ * on a casual call. Subprocess-style handlers (spawn a binary per
+ * message, pipe message JSON to stdin) live as CLI-only flags
+ * (`--exec`, `--exec-shell`); the CLI wraps them into an `onMessage`
+ * before calling the SDK. Programmatic SDK callers that want the
+ * same behavior compose their own `onMessage` around `child_process`.
+ */
+const TriggerInboxCommandBaseSchema = z.object({
+    inbox: TriggerInboxPropertySchema,
+    onMessage: z
+        .function()
+        .optional()
+        .meta({ exampleRequired: true })
+        .describe("Per-message handler. Resolves to ack; rejects to release-or-leave per `releaseOnError`. Throw `ZapierReleaseTriggerMessageSignal` to release explicitly, or `ZapierAbortDrainSignal` to stop after the current batch."),
+    concurrency: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("Per-message handler workers running in parallel. Defaults to `leaseLimit`, or 1 if neither is set."),
+    leaseLimit: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe("Per-lease HTTP batch size. Defaults to `concurrency`, or 1 if neither is set."),
+    leaseSeconds: LeaseSecondsPropertySchema.optional(),
+    releaseOnError: z
+        .boolean()
+        .optional()
+        .describe("If true, errors immediately release the message. If false (default), errors leave it leased until the lease timeout. `ZapierReleaseTriggerMessageSignal` always releases regardless."),
+    continueOnError: z
+        .boolean()
+        .optional()
+        .describe("If false (default, fail-fast), the first handler error rejects and stops the drain. If true, handler errors are observed via `onError` and the drain continues. SDK-level errors (lease / ack / release) reject regardless."),
+    onError: z
+        .function()
+        .optional()
+        .describe("Per-message error observer for `continueOnError: true`. Called with the failure and the message; control-flow signals are filtered out. Throws from `onError` are swallowed."),
+    signal: z
+        .custom((v) => v instanceof AbortSignal)
+        .optional()
+        .describe("Abort signal. Aborting cancels in-flight HTTP, releases unprocessed messages, and resolves cleanly. Errors during shutdown still reject."),
+});
+export const DrainTriggerInboxSchema = TriggerInboxCommandBaseSchema.extend({
+    maxMessages: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("Cap total messages drained. Defaults to draining the inbox until empty."),
+}).describe("Drain an existing trigger inbox: lease currently-available messages and process them via onMessage. Returns when the inbox is empty, maxMessages is reached, the abort signal fires, or a fatal error rejects.");
+export const WatchTriggerInboxSchema = TriggerInboxCommandBaseSchema.extend({
+    maxDrainIntervalSeconds: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("Maximum seconds between empty-inbox poll attempts (default: 60). Caps the back-off cadence."),
+}).describe("Continuously consume a trigger inbox: drain currently-available messages, then poll with backoff for new arrivals, until aborted. Stop via the `signal` AbortSignal or by throwing `ZapierAbortDrainSignal` from a handler. Resolves cleanly on abort; rejects on a fatal error or a fail-fast handler error.");

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

@@ -0,0 +1,63 @@
+import { EnsureTriggerInboxSchema } from "./schemas";
+import type { GetVersionedImplementationId } from "../../manifest/schemas";
+import type { ConnectionsPluginProvides } from "../../connections";
+export declare const ensureTriggerInboxPlugin: (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>;
+    };
+} & {
+    context: import("../../eventEmission").EventEmissionContext;
+} & {
+    context: {
+        getVersionedImplementationId: GetVersionedImplementationId;
+    } & ConnectionsPluginProvides["context"];
+} & {
+    context: {
+        meta: Record<string, import("../../..").PluginMeta>;
+    };
+}) => {
+    ensureTriggerInbox: (options?: {
+        name: string;
+        app: string;
+        action: string;
+        connection?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        notificationUrl?: string | undefined;
+    } | undefined) => Promise<{
+        data: {
+            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>;
+            };
+        };
+    }>;
+} & {
+    context: {
+        meta: {
+            ensureTriggerInbox: import("../../..").PluginMeta;
+        };
+    };
+};
+export type EnsureTriggerInboxPluginProvides = ReturnType<typeof ensureTriggerInboxPlugin>;
+export { EnsureTriggerInboxSchema };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/ensureTriggerInbox/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAA0B,MAAM,WAAW,CAAC;AAa7E,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,wBAAwB,CAAC;AAC3E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAcnE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;aAIpB;QACP,4BAA4B,EAAE,4BAA4B,CAAC;KAC5D,GAAG,yBAAyB,CAAC,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgG/C,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG,UAAU,CACvD,OAAO,wBAAwB,CAChC,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

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

@@ -0,0 +1,77 @@
+import { definePlugin, createPluginMethod } from "../../../utils/plugin-utils";
+import { EnsureTriggerInboxSchema, TriggerInboxItemSchema } from "./schemas";
+import { ZapierConfigurationError, ZapierConflictError, } from "../../../types/errors";
+import { appKeyResolver, actionKeyResolver, connectionIdResolver, inputsResolver, } from "../../../resolvers";
+import { resolveConnectionId } from "../../../utils/domain-utils";
+import { triggersDefaults } from "../shared";
+function extractErrorDetail(data) {
+    if (typeof data !== "object" || data === null)
+        return undefined;
+    const errors = data.errors;
+    if (!Array.isArray(errors) || errors.length === 0)
+        return undefined;
+    const first = errors[0];
+    if (typeof first !== "object" || first === null)
+        return undefined;
+    const detail = first.detail;
+    return typeof detail === "string" ? detail : undefined;
+}
+export const ensureTriggerInboxPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "ensureTriggerInbox",
+    type: "create",
+    itemType: "TriggerInbox",
+    inputSchema: EnsureTriggerInboxSchema,
+    outputSchema: TriggerInboxItemSchema,
+    // actionKeyResolver and inputsResolver depend on actionType, which is
+    // always "read" for triggers. Pin it as a constant resolver so it's
+    // seeded into resolvedParams without polluting the user-facing schema.
+    resolvers: {
+        name: { type: "static", inputType: "text" },
+        app: appKeyResolver,
+        action: actionKeyResolver,
+        connection: connectionIdResolver,
+        inputs: inputsResolver,
+        actionType: { type: "constant", value: "read" },
+    },
+    handler: async ({ sdk, options }) => {
+        const { api } = sdk.context;
+        const { app: appKey, action: actionKey, connection, inputs = {}, name, notificationUrl, } = options;
+        const resolvedConnectionId = await resolveConnectionId({
+            connection,
+            resolveConnection: sdk.context.resolveConnection,
+        });
+        const selectedApi = await sdk.context.getVersionedImplementationId(appKey);
+        if (!selectedApi) {
+            throw new ZapierConfigurationError(`No current_implementation_id found for app "${appKey}"`, { configType: "current_implementation_id" });
+        }
+        const requestBody = {
+            name,
+            subscription: {
+                app_key: selectedApi,
+                action_key: actionKey,
+                inputs,
+            },
+        };
+        if (notificationUrl !== undefined) {
+            requestBody.notification_url = notificationUrl;
+        }
+        if (resolvedConnectionId !== undefined &&
+            resolvedConnectionId !== null) {
+            requestBody.subscription.connection_id = resolvedConnectionId;
+        }
+        const rawResponse = await api.post("/trigger-inbox/api/v1/inboxes", requestBody, {
+            authRequired: true,
+            customErrorHandler: ({ status, data }) => {
+                if (status === 409) {
+                    const detail = extractErrorDetail(data);
+                    return new ZapierConflictError(detail ??
+                        `An inbox named "${name}" already exists with a different subscription.`, { statusCode: status, resourceType: "trigger_inbox" });
+                }
+                return undefined;
+            },
+        });
+        return { data: TriggerInboxItemSchema.parse(rawResponse) };
+    },
+}));
+export { EnsureTriggerInboxSchema };

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

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import type { FunctionOptions } from "../../../types/functions";
+import { TriggerInboxItemSchema, type TriggerInboxItem } from "../../../schemas/TriggerInbox";
+export declare const EnsureTriggerInboxSchema: z.ZodObject<{
+    name: z.ZodString;
+    app: z.ZodString & {
+        _def: z.core.$ZodStringDef & import("../../..").PositionalMetadata;
+    };
+    action: z.ZodString & {
+        _def: z.core.$ZodStringDef & import("../../..").PositionalMetadata;
+    };
+    connection: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    notificationUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EnsureTriggerInboxOptions = z.infer<typeof EnsureTriggerInboxSchema> & FunctionOptions;
+export interface EnsureTriggerInboxResult {
+    data: TriggerInboxItem;
+}
+export { TriggerInboxItemSchema };
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/ensureTriggerInbox/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAQhE,OAAO,EACL,sBAAsB,EACtB,KAAK,gBAAgB,EACtB,MAAM,+BAA+B,CAAC;AAKvC,eAAO,MAAM,wBAAwB;;;;;;;;;;;iBAqBK,CAAC;AAE3C,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/ensureTriggerInbox/schemas.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { AppPropertySchema, ActionPropertySchema, ConnectionPropertySchema, InputsPropertySchema, TriggerInboxNamePropertySchema, } from "../../../types/properties";
+import { TriggerInboxItemSchema, } from "../../../schemas/TriggerInbox";
+const EnsureTriggerInboxDescription = "Get-or-create a trigger inbox by name. Idempotent on (user, account, name): returns the existing inbox if a matching subscription is registered, creates a new one otherwise. Throws ZapierConflictError if the name exists with a different subscription.";
+export const EnsureTriggerInboxSchema = z
+    .object({
+    name: TriggerInboxNamePropertySchema.describe("Inbox name; serves as the idempotency key. Required for ensureTriggerInbox — without one, the API mints a fresh inbox each call (use createTriggerInbox for that path)."),
+    app: AppPropertySchema,
+    action: ActionPropertySchema,
+    connection: ConnectionPropertySchema.nullable()
+        .optional()
+        .describe("Connection alias or connection ID. Optional for triggers that don't require auth."),
+    inputs: InputsPropertySchema.optional().describe("Input parameters for the trigger subscription"),
+    notificationUrl: z
+        .string()
+        .url()
+        .optional()
+        .describe("Webhook URL to POST to when new messages arrive"),
+})
+    .describe(EnsureTriggerInboxDescription);
+export { TriggerInboxItemSchema };

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

@@ -0,0 +1,50 @@
+export declare const getTriggerInboxPlugin: (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>;
+    };
+} & {
+    context: import("../../eventEmission").EventEmissionContext;
+} & {
+    context: {
+        meta: Record<string, import("../../..").PluginMeta>;
+    };
+}) => {
+    getTriggerInbox: (options?: {
+        inbox: string;
+    } | undefined) => Promise<{
+        data: {
+            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>;
+            };
+        };
+    }>;
+} & {
+    context: {
+        meta: {
+            getTriggerInbox: import("../../..").PluginMeta;
+        };
+    };
+};
+export type GetTriggerInboxPluginProvides = ReturnType<typeof getTriggerInboxPlugin>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/getTriggerInbox/index.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BjC,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG,UAAU,CACpD,OAAO,qBAAqB,CAC7B,CAAC"}

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

@@ -0,0 +1,26 @@
+import { definePlugin, createPluginMethod } from "../../../utils/plugin-utils";
+import { GetTriggerInboxSchema, TriggerInboxItemSchema } from "./schemas";
+import { triggerInboxResolver } from "../../../resolvers";
+import { resolveTriggerInboxId } from "../utils";
+import { triggersDefaults } from "../shared";
+export const getTriggerInboxPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "getTriggerInbox",
+    type: "item",
+    itemType: "TriggerInbox",
+    inputSchema: GetTriggerInboxSchema,
+    outputSchema: TriggerInboxItemSchema,
+    resolvers: { inbox: triggerInboxResolver },
+    handler: async ({ sdk, options }) => {
+        const { inbox } = options;
+        const inboxId = await resolveTriggerInboxId({
+            api: sdk.context.api,
+            inbox,
+        });
+        const rawResponse = await sdk.context.api.get(`/trigger-inbox/api/v1/inboxes/${encodeURIComponent(inboxId)}`, {
+            authRequired: true,
+            resource: { type: "trigger_inbox", id: inboxId },
+        });
+        return { data: TriggerInboxItemSchema.parse(rawResponse) };
+    },
+}));

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/getTriggerInbox/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,qBAAqB;;;;iBAIiB,CAAC;AAEpD,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,GACxE,eAAe,CAAC;AAElB,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,gBAAgB,CAAC;CACxB;AAED,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

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

@@ -0,0 +1,9 @@
+import { z } from "zod";
+import { TriggerInboxPropertySchema } from "../../../types/properties";
+import { TriggerInboxItemSchema, } from "../../../schemas/TriggerInbox";
+export const GetTriggerInboxSchema = z
+    .object({
+    inbox: TriggerInboxPropertySchema,
+})
+    .describe("Get details of a trigger inbox by ID");
+export { TriggerInboxItemSchema };

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

@@ -0,0 +1,48 @@
+export declare const getTriggerInputFieldsSchemaPlugin: (sdk: {
+    getActionInputFieldsSchema: (options?: {
+        app: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        action: string;
+        connection?: string | number | undefined;
+        connectionId?: string | number | null | undefined;
+        authenticationId?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+    } | {
+        appKey: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        actionKey: string;
+        connection?: string | number | undefined;
+        connectionId?: string | number | null | undefined;
+        authenticationId?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+    } | undefined) => Promise<{
+        data: Record<string, unknown>;
+    }>;
+} & {
+    context: {
+        meta: {
+            getActionInputFieldsSchema: import("../../..").PluginMeta;
+        };
+    };
+} & {
+    context: {
+        meta: Record<string, import("../../..").PluginMeta>;
+    };
+}) => {
+    getTriggerInputFieldsSchema: (options?: {
+        app: string;
+        action: string;
+        connection?: string | number | undefined;
+        inputs?: Record<string, unknown> | undefined;
+    } | undefined) => Promise<{
+        data: Record<string, unknown>;
+    }>;
+} & {
+    context: {
+        meta: {
+            getTriggerInputFieldsSchema: import("../../..").PluginMeta;
+        };
+    };
+};
+export type GetTriggerInputFieldsSchemaPluginProvides = ReturnType<typeof getTriggerInputFieldsSchemaPlugin>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/getTriggerInputFieldsSchema/index.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqB7C,CAAC;AAEF,MAAM,MAAM,yCAAyC,GAAG,UAAU,CAChE,OAAO,iCAAiC,CACzC,CAAC"}

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

@@ -0,0 +1,23 @@
+import { definePlugin, createPluginMethod } from "../../../utils/plugin-utils";
+import { GetTriggerInputFieldsSchemaSchema } from "./schemas";
+import { appKeyResolver, actionKeyResolver, connectionIdResolver, inputsAllOptionalResolver, } from "../../../resolvers";
+import { triggersDefaults } from "../shared";
+export const getTriggerInputFieldsSchemaPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "getTriggerInputFieldsSchema",
+    type: "function",
+    inputSchema: GetTriggerInputFieldsSchemaSchema,
+    resolvers: {
+        app: appKeyResolver,
+        action: actionKeyResolver,
+        connection: connectionIdResolver,
+        inputs: inputsAllOptionalResolver,
+        actionType: { type: "constant", value: "read" },
+    },
+    handler: async ({ sdk, options }) => {
+        return sdk.getActionInputFieldsSchema({
+            ...options,
+            actionType: "read",
+        });
+    },
+}));

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

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const GetTriggerInputFieldsSchemaSchema: z.ZodObject<{
+    app: z.ZodString & {
+        _def: z.core.$ZodStringDef & import("../../..").PositionalMetadata;
+    };
+    action: z.ZodString & {
+        _def: z.core.$ZodStringDef & import("../../..").PositionalMetadata;
+    };
+    connection: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type GetTriggerInputFieldsSchemaOptions = z.infer<typeof GetTriggerInputFieldsSchemaSchema>;
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/getTriggerInputFieldsSchema/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,iCAAiC;;;;;;;;;iBAiB3C,CAAC;AAEJ,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,iCAAiC,CACzC,CAAC"}

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

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { AppPropertySchema, ActionPropertySchema, ConnectionPropertySchema, InputsPropertySchema, } from "../../../types/properties";
+export const GetTriggerInputFieldsSchemaSchema = z
+    .object({
+    app: AppPropertySchema.describe("App key (e.g., 'SlackCLIAPI' or slug like 'github') to get the input schema for"),
+    action: ActionPropertySchema.describe("Trigger action key to get the input schema for"),
+    connection: ConnectionPropertySchema.optional().describe("Connection alias or connection ID. Required if the trigger needs a connection to determine available fields."),
+    inputs: InputsPropertySchema.optional().describe("Current input values that may affect the schema (e.g., when fields depend on other field values)"),
+})
+    .describe("Get the JSON Schema representation of input fields for a trigger. Returns a JSON Schema object describing the structure, types, and validation rules for the trigger's input parameters.");

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

@@ -0,0 +1,58 @@
+export declare const leaseTriggerInboxMessagesPlugin: (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>;
+    };
+} & {
+    context: import("../../eventEmission").EventEmissionContext;
+} & {
+    context: {
+        meta: Record<string, import("../../..").PluginMeta>;
+    };
+}) => {
+    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;
+        };
+    };
+};
+export type LeaseTriggerInboxMessagesPluginProvides = ReturnType<typeof leaseTriggerInboxMessagesPlugin>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/leaseTriggerInboxMessages/index.ts"],"names":[],"mappings":"AAqCA,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkD3C,CAAC;AAEF,MAAM,MAAM,uCAAuC,GAAG,UAAU,CAC9D,OAAO,+BAA+B,CACvC,CAAC"}

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

@@ -0,0 +1,70 @@
+import { definePlugin, createPluginMethod } from "../../../utils/plugin-utils";
+import { LeaseTriggerInboxMessagesSchema, LeaseTriggerInboxMessagesItemSchema, } from "./schemas";
+import { ZapierConflictError } from "../../../types/errors";
+import { triggerInboxResolver } from "../../../resolvers";
+import { resolveTriggerInboxId } from "../utils";
+import { triggersDefaults } from "../shared";
+// The trigger-inbox API returns 409 from /messages/lease when the inbox
+// is paused and fully drained, with the shape:
+//   { detail: "...", inbox_attributes: { status, paused_reason, paused_at } }
+// (note: top-level `detail`, NOT the standard `{ errors: [...] }`). The
+// SDK's generic error parser doesn't recognize this shape, so without a
+// customErrorHandler the user gets a vague "HTTP 409" with no reason.
+function parseLeaseConflict(data) {
+    if (typeof data !== "object" || data === null)
+        return {};
+    const detail = data.detail;
+    const inboxAttributes = data
+        .inbox_attributes;
+    let pausedReason;
+    if (typeof inboxAttributes === "object" && inboxAttributes !== null) {
+        const pr = inboxAttributes.paused_reason;
+        if (typeof pr === "string" && pr.length > 0)
+            pausedReason = pr;
+    }
+    return {
+        detail: typeof detail === "string" ? detail : undefined,
+        pausedReason,
+    };
+}
+export const leaseTriggerInboxMessagesPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "leaseTriggerInboxMessages",
+    type: "create",
+    itemType: "TriggerInboxLease",
+    inputSchema: LeaseTriggerInboxMessagesSchema,
+    outputSchema: LeaseTriggerInboxMessagesItemSchema,
+    resolvers: { inbox: triggerInboxResolver },
+    handler: async ({ sdk, options }) => {
+        const { inbox, leaseLimit, leaseSeconds, signal } = options;
+        const inboxId = await resolveTriggerInboxId({
+            api: sdk.context.api,
+            inbox,
+        });
+        const requestBody = {};
+        if (leaseLimit !== undefined) {
+            requestBody.lease_limit = leaseLimit;
+        }
+        if (leaseSeconds !== undefined) {
+            requestBody.lease_seconds = leaseSeconds;
+        }
+        const rawResponse = await sdk.context.api.post(`/trigger-inbox/api/v1/inboxes/${encodeURIComponent(inboxId)}/messages/lease`, requestBody, {
+            authRequired: true,
+            signal,
+            customErrorHandler: ({ status, data }) => {
+                if (status !== 409)
+                    return undefined;
+                const { detail, pausedReason } = parseLeaseConflict(data);
+                const baseMessage = detail ?? "Inbox is paused and fully drained";
+                const message = pausedReason
+                    ? `${baseMessage} (paused_reason: ${pausedReason})`
+                    : baseMessage;
+                return new ZapierConflictError(message, {
+                    statusCode: status,
+                    resourceType: "trigger_inbox",
+                });
+            },
+        });
+        return { data: LeaseTriggerInboxMessagesItemSchema.parse(rawResponse) };
+    },
+}));