@zapier/zapier-sdk 0.48.0 → 0.49.0

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

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { type LeasedTriggerMessageItem } from "../../../schemas/TriggerMessage";
+export declare const LeaseTriggerInboxMessagesSchema: z.ZodObject<{
+    inbox: z.ZodString & {
+        _def: z.core.$ZodStringDef & import("../../..").PositionalMetadata;
+    };
+    leaseLimit: z.ZodOptional<z.ZodNumber>;
+    leaseSeconds: z.ZodOptional<z.ZodNumber>;
+    signal: z.ZodOptional<z.ZodCustom<AbortSignal, AbortSignal>>;
+}, z.core.$strip>;
+export type LeaseTriggerInboxMessagesOptions = z.infer<typeof LeaseTriggerInboxMessagesSchema>;
+export declare const LeaseTriggerInboxMessagesItemSchema: z.ZodObject<{
+    lease_id: z.ZodNullable<z.ZodString>;
+    leased_until: z.ZodNullable<z.ZodString>;
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        created_at: z.ZodString;
+        status: z.ZodUnion<readonly [z.ZodEnum<{
+            available: "available";
+            leased: "leased";
+            acked: "acked";
+            quarantined: "quarantined";
+        }>, z.ZodString]>;
+        message_attributes: z.ZodObject<{
+            lease_count: z.ZodNumber;
+            error_message: z.ZodNullable<z.ZodString>;
+            possible_duplicate_data: z.ZodBoolean;
+        }, z.core.$strip>;
+        payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+    inbox_attributes: z.ZodObject<{
+        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]>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type LeaseTriggerInboxMessagesItem = z.infer<typeof LeaseTriggerInboxMessagesItemSchema>;
+export interface LeaseTriggerInboxMessagesResult {
+    data: LeaseTriggerInboxMessagesItem;
+}
+export type LeasedMessage = LeasedTriggerMessageItem;
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/leaseTriggerInboxMessages/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,OAAO,EAEL,KAAK,wBAAwB,EAC9B,MAAM,iCAAiC,CAAC;AAEzC,eAAO,MAAM,+BAA+B;;;;;;;iBAczC,CAAC;AAEJ,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,+BAA+B,CACvC,CAAC;AAOF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK9C,CAAC;AAEH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CACjD,OAAO,mCAAmC,CAC3C,CAAC;AAEF,MAAM,WAAW,+BAA+B;IAC9C,IAAI,EAAE,6BAA6B,CAAC;CACrC;AAED,MAAM,MAAM,aAAa,GAAG,wBAAwB,CAAC"}

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

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { TriggerInboxPropertySchema, LeaseSecondsPropertySchema, LeaseLimitPropertySchema, } from "../../../types/properties";
+import { TriggerInboxStatusSchema, TriggerInboxPausedReasonSchema, } from "../../../schemas/TriggerInbox";
+import { LeasedTriggerMessageItemSchema, } from "../../../schemas/TriggerMessage";
+export const LeaseTriggerInboxMessagesSchema = z
+    .object({
+    inbox: TriggerInboxPropertySchema,
+    leaseLimit: LeaseLimitPropertySchema.optional(),
+    leaseSeconds: LeaseSecondsPropertySchema.optional(),
+    signal: z
+        .custom((v) => v instanceof AbortSignal)
+        .optional()
+        .describe("Abort signal forwarded to the lease HTTP request. Aborting causes the in-flight request to reject with AbortError."),
+})
+    .describe("Lease up to N messages from a trigger inbox. Returns messages plus a lease ID; ack within the lease window to remove from the inbox.");
+const InboxAttributesSchema = z.object({
+    status: TriggerInboxStatusSchema,
+    paused_reason: TriggerInboxPausedReasonSchema.nullable(),
+});
+export const LeaseTriggerInboxMessagesItemSchema = z.object({
+    lease_id: z.string().nullable(),
+    leased_until: z.string().nullable(),
+    results: z.array(LeasedTriggerMessageItemSchema),
+    inbox_attributes: InboxAttributesSchema,
+});

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

@@ -0,0 +1,51 @@
+export declare const listTriggerInboxMessagesPlugin: (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>;
+    };
+}) => {
+    listTriggerInboxMessages: (options?: ({
+        inbox: string;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    } & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("../../..").PaginatedSdkResult<{
+        id: string;
+        created_at: string;
+        status: string;
+        message_attributes: {
+            lease_count: number;
+            error_message: string | null;
+            possible_duplicate_data: boolean;
+        };
+    }>;
+} & {
+    context: {
+        meta: {
+            listTriggerInboxMessages: import("../../..").PluginMeta;
+        };
+    };
+};
+export type ListTriggerInboxMessagesPluginProvides = ReturnType<typeof listTriggerInboxMessagesPlugin>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/listTriggerInboxMessages/index.ts"],"names":[],"mappings":"AA0BA,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuC1C,CAAC;AAEF,MAAM,MAAM,sCAAsC,GAAG,UAAU,CAC7D,OAAO,8BAA8B,CACtC,CAAC"}

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

@@ -0,0 +1,48 @@
+import { definePlugin, createPaginatedPluginMethod, } from "../../../utils/plugin-utils";
+import { ListTriggerInboxMessagesSchema, ListTriggerInboxMessagesApiResponseSchema, TriggerMessageItemSchema, } from "./schemas";
+import { triggerInboxResolver } from "../../../resolvers";
+import { resolveTriggerInboxId } from "../utils";
+import { DEFAULT_PAGE_SIZE } from "../../../constants";
+import { triggersDefaults } from "../shared";
+function extractNextCursor(next) {
+    if (!next)
+        return undefined;
+    try {
+        const url = new URL(next);
+        return url.searchParams.get("cursor") ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export const listTriggerInboxMessagesPlugin = definePlugin((sdk) => createPaginatedPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "listTriggerInboxMessages",
+    type: "list",
+    itemType: "TriggerMessage",
+    inputSchema: ListTriggerInboxMessagesSchema,
+    outputSchema: TriggerMessageItemSchema,
+    defaultPageSize: DEFAULT_PAGE_SIZE,
+    resolvers: { inbox: triggerInboxResolver },
+    handler: async ({ sdk, options }) => {
+        const { inbox, cursor, pageSize } = options;
+        const inboxId = await resolveTriggerInboxId({
+            api: sdk.context.api,
+            inbox,
+        });
+        const searchParams = {};
+        if (pageSize !== undefined) {
+            searchParams.limit = pageSize.toString();
+        }
+        if (cursor) {
+            searchParams.cursor = cursor;
+        }
+        const rawResponse = await sdk.context.api.get(`/trigger-inbox/api/v1/inboxes/${encodeURIComponent(inboxId)}/messages`, { searchParams, authRequired: true });
+        const response = ListTriggerInboxMessagesApiResponseSchema.parse(rawResponse);
+        return {
+            data: response.results,
+            next: response.next ?? null,
+        };
+    },
+    extractCursor: (response) => extractNextCursor(response.next),
+}));

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

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { TriggerMessageItemSchema, type TriggerMessageItem } from "../../../schemas/TriggerMessage";
+export declare const ListTriggerInboxMessagesSchema: z.ZodObject<{
+    inbox: z.ZodString & {
+        _def: z.core.$ZodStringDef & import("../../..").PositionalMetadata;
+    };
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ListTriggerInboxMessagesOptions = z.infer<typeof ListTriggerInboxMessagesSchema>;
+export declare const ListTriggerInboxMessagesApiResponseSchema: z.ZodObject<{
+    next: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    previous: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        created_at: z.ZodString;
+        status: z.ZodUnion<readonly [z.ZodEnum<{
+            available: "available";
+            leased: "leased";
+            acked: "acked";
+            quarantined: "quarantined";
+        }>, z.ZodString]>;
+        message_attributes: z.ZodObject<{
+            lease_count: z.ZodNumber;
+            error_message: z.ZodNullable<z.ZodString>;
+            possible_duplicate_data: z.ZodBoolean;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ListTriggerInboxMessagesApiResponse = z.infer<typeof ListTriggerInboxMessagesApiResponseSchema>;
+export interface ListTriggerInboxMessagesPage {
+    data: TriggerMessageItem[];
+    nextCursor?: string;
+}
+export { TriggerMessageItemSchema };
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/listTriggerInboxMessages/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EACL,wBAAwB,EACxB,KAAK,kBAAkB,EACxB,MAAM,iCAAiC,CAAC;AAEzC,eAAO,MAAM,8BAA8B;;;;;;;iBAiB8B,CAAC;AAE1E,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CACnD,OAAO,8BAA8B,CACtC,CAAC;AAEF,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;iBAIpD,CAAC;AAEH,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAC;AAEF,MAAM,WAAW,4BAA4B;IAC3C,IAAI,EAAE,kBAAkB,EAAE,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

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

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { TriggerInboxPropertySchema } from "../../../types/properties";
+import { TriggerMessageItemSchema, } from "../../../schemas/TriggerMessage";
+export const ListTriggerInboxMessagesSchema = z
+    .object({
+    inbox: TriggerInboxPropertySchema,
+    pageSize: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("Number of messages per page"),
+    maxItems: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("Maximum total items to return across all pages"),
+    cursor: z.string().optional().describe("Pagination cursor"),
+})
+    .describe("List messages in a trigger inbox (no payload, status-only)");
+export const ListTriggerInboxMessagesApiResponseSchema = z.object({
+    next: z.string().nullable().optional(),
+    previous: z.string().nullable().optional(),
+    results: z.array(TriggerMessageItemSchema),
+});
+export { TriggerMessageItemSchema };

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

@@ -0,0 +1,56 @@
+export declare const listTriggerInboxesPlugin: (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>;
+    };
+}) => {
+    listTriggerInboxes: (options?: ({
+        name?: string | undefined;
+        status?: string | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    } & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("../../..").PaginatedSdkResult<{
+        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: {
+            listTriggerInboxes: import("../../..").PluginMeta;
+        };
+    };
+};
+export type ListTriggerInboxesPluginProvides = ReturnType<typeof listTriggerInboxesPlugin>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/listTriggerInboxes/index.ts"],"names":[],"mappings":"AAyBA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCpC,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG,UAAU,CACvD,OAAO,wBAAwB,CAChC,CAAC"}

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

@@ -0,0 +1,51 @@
+import { definePlugin, createPaginatedPluginMethod, } from "../../../utils/plugin-utils";
+import { ListTriggerInboxesSchema, ListTriggerInboxesApiResponseSchema, TriggerInboxItemSchema, } from "./schemas";
+import { DEFAULT_PAGE_SIZE } from "../../../constants";
+import { triggersDefaults } from "../shared";
+function extractNextOffset(next) {
+    if (!next)
+        return undefined;
+    try {
+        const url = new URL(next);
+        const offset = url.searchParams.get("offset");
+        return offset || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export const listTriggerInboxesPlugin = definePlugin((sdk) => createPaginatedPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "listTriggerInboxes",
+    type: "list",
+    itemType: "TriggerInbox",
+    inputSchema: ListTriggerInboxesSchema,
+    outputSchema: TriggerInboxItemSchema,
+    defaultPageSize: DEFAULT_PAGE_SIZE,
+    handler: async ({ sdk, options }) => {
+        const { api } = sdk.context;
+        const searchParams = {};
+        if (options.pageSize !== undefined) {
+            searchParams.limit = options.pageSize.toString();
+        }
+        if (options.cursor) {
+            searchParams.offset = options.cursor;
+        }
+        if (options.status) {
+            searchParams.status = options.status;
+        }
+        if (options.name) {
+            searchParams.name = options.name;
+        }
+        const rawResponse = await api.get("/trigger-inbox/api/v1/inboxes", {
+            searchParams,
+            authRequired: true,
+        });
+        const response = ListTriggerInboxesApiResponseSchema.parse(rawResponse);
+        return {
+            data: response.results,
+            next: response.next ?? null,
+        };
+    },
+    extractCursor: (response) => extractNextOffset(response.next),
+}));

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

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { TriggerInboxItemSchema, type TriggerInboxItem } from "../../../schemas/TriggerInbox";
+export declare const ListTriggerInboxesSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        initializing: "initializing";
+        active: "active";
+        paused: "paused";
+        deleting: "deleting";
+        initialization_failure: "initialization_failure";
+    }>, z.ZodString]>>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ListTriggerInboxesOptions = z.infer<typeof ListTriggerInboxesSchema>;
+export declare const ListTriggerInboxesApiResponseSchema: z.ZodObject<{
+    count: z.ZodNumber;
+    next: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    previous: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    results: z.ZodArray<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>>;
+}, z.core.$strip>;
+export type ListTriggerInboxesApiResponse = z.infer<typeof ListTriggerInboxesApiResponseSchema>;
+export interface ListTriggerInboxesPage {
+    data: TriggerInboxItem[];
+    nextCursor?: string;
+}
+export { TriggerInboxItemSchema };
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/listTriggerInboxes/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,sBAAsB,EAEtB,KAAK,gBAAgB,EACtB,MAAM,+BAA+B,CAAC;AAEvC,eAAO,MAAM,wBAAwB;;;;;;;;;;;;iBA6B6B,CAAC;AAEnE,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,wBAAwB,CAChC,CAAC;AAEF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK9C,CAAC;AAEH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CACjD,OAAO,mCAAmC,CAC3C,CAAC;AAEF,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,gBAAgB,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

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

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { TriggerInboxItemSchema, TriggerInboxStatusSchema, } from "../../../schemas/TriggerInbox";
+export const ListTriggerInboxesSchema = z
+    .object({
+    name: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Filter by inbox name (exact match). Names are unique per (user, account), so this returns at most one inbox."),
+    status: TriggerInboxStatusSchema.optional().describe("Filter by inbox status"),
+    pageSize: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("Number of inboxes per page"),
+    maxItems: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("Maximum total items to return across all pages"),
+    cursor: z
+        .string()
+        .optional()
+        .describe("Cursor (offset) to start from for pagination"),
+})
+    .describe("List all trigger inboxes for the authenticated user");
+export const ListTriggerInboxesApiResponseSchema = z.object({
+    count: z.number().int(),
+    next: z.string().nullable().optional(),
+    previous: z.string().nullable().optional(),
+    results: z.array(TriggerInboxItemSchema),
+});
+export { TriggerInboxItemSchema };

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

@@ -0,0 +1,77 @@
+export declare const listTriggerInputFieldChoicesPlugin: (sdk: {
+    listActionInputFieldChoices: (options?: (({
+        app: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        action: string;
+        inputField: string;
+        connection?: string | number | undefined;
+        connectionId?: string | number | null | undefined;
+        authenticationId?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        page?: number | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    } | {
+        appKey: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        actionKey: string;
+        inputFieldKey: string;
+        connection?: string | number | undefined;
+        connectionId?: string | number | null | undefined;
+        authenticationId?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        page?: number | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    }) & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("../../..").PaginatedSdkResult<{
+        key?: string | undefined;
+        label?: string | undefined;
+        sample?: string | undefined;
+        value?: string | undefined;
+    }>;
+} & {
+    context: {
+        meta: {
+            listActionInputFieldChoices: import("../../..").PluginMeta;
+        };
+    };
+} & {
+    context: {
+        meta: Record<string, import("../../..").PluginMeta>;
+    };
+}) => {
+    listTriggerInputFieldChoices: (options?: ({
+        app: string;
+        action: string;
+        inputField: string;
+        connection?: string | number | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        page?: number | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    } & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("../../..").PaginatedSdkResult<{
+        key?: string | undefined;
+        label?: string | undefined;
+        sample?: string | undefined;
+        value?: string | undefined;
+    }>;
+} & {
+    context: {
+        meta: {
+            listTriggerInputFieldChoices: import("../../..").PluginMeta;
+        };
+    };
+};
+export type ListTriggerInputFieldChoicesPluginProvides = ReturnType<typeof listTriggerInputFieldChoicesPlugin>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/listTriggerInputFieldChoices/index.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6B9C,CAAC;AAEF,MAAM,MAAM,0CAA0C,GAAG,UAAU,CACjE,OAAO,kCAAkC,CAC1C,CAAC"}

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

@@ -0,0 +1,30 @@
+import { definePlugin, createPaginatedPluginMethod, } from "../../../utils/plugin-utils";
+import { ListTriggerInputFieldChoicesSchema } from "./schemas";
+import { InputFieldChoiceItemSchema, } from "../../listActionInputFieldChoices/schemas";
+import { appKeyResolver, actionKeyResolver, connectionIdResolver, inputFieldKeyResolver, inputsAllOptionalResolver, } from "../../../resolvers";
+import { triggersDefaults } from "../shared";
+import { DEFAULT_PAGE_SIZE } from "../../../constants";
+export const listTriggerInputFieldChoicesPlugin = definePlugin((sdk) => createPaginatedPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "listTriggerInputFieldChoices",
+    type: "list",
+    itemType: "InputFieldChoice",
+    inputSchema: ListTriggerInputFieldChoicesSchema,
+    outputSchema: InputFieldChoiceItemSchema,
+    defaultPageSize: DEFAULT_PAGE_SIZE,
+    resolvers: {
+        app: appKeyResolver,
+        action: actionKeyResolver,
+        connection: connectionIdResolver,
+        inputField: inputFieldKeyResolver,
+        inputs: inputsAllOptionalResolver,
+        actionType: { type: "constant", value: "read" },
+    },
+    handler: async ({ sdk, options, }) => {
+        const result = await sdk.listActionInputFieldChoices({
+            ...options,
+            actionType: "read",
+        });
+        return { data: result.data, nextCursor: result.nextCursor };
+    },
+}));

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

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export declare const ListTriggerInputFieldChoicesSchema: z.ZodObject<{
+    app: z.ZodString & {
+        _def: z.core.$ZodStringDef & import("../../..").PositionalMetadata;
+    };
+    action: z.ZodString & {
+        _def: z.core.$ZodStringDef & import("../../..").PositionalMetadata;
+    };
+    inputField: 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>>;
+    page: z.ZodOptional<z.ZodNumber>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ListTriggerInputFieldChoicesOptions = z.infer<typeof ListTriggerInputFieldChoicesSchema>;
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/listTriggerInputFieldChoices/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;iBA+B5C,CAAC;AAEJ,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,kCAAkC,CAC1C,CAAC"}

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

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { AppPropertySchema, ActionPropertySchema, ConnectionPropertySchema, InputsPropertySchema, InputFieldPropertySchema, } from "../../../types/properties";
+export const ListTriggerInputFieldChoicesSchema = z
+    .object({
+    app: AppPropertySchema,
+    action: ActionPropertySchema,
+    inputField: InputFieldPropertySchema,
+    connection: ConnectionPropertySchema.optional().describe("Connection alias or connection ID. Required if the trigger needs a connection to populate dynamic dropdown options."),
+    inputs: InputsPropertySchema.optional().describe("Current input values that may affect available choices"),
+    page: z
+        .number()
+        .int()
+        .min(0)
+        .optional()
+        .describe("Page number for paginated results"),
+    pageSize: z
+        .number()
+        .min(1)
+        .optional()
+        .describe("Number of choices per page"),
+    maxItems: z
+        .number()
+        .min(1)
+        .optional()
+        .describe("Maximum total items to return across all pages"),
+    cursor: z.string().optional().describe("Cursor to start from"),
+})
+    .describe("Get the available choices for a dynamic dropdown input field on a trigger");