@zapier/zapier-sdk 0.77.1 → 0.77.2

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

@@ -1,102 +0,0 @@
-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 release the message when the drain finishes. 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 safety drain attempts (default: 300). The watcher subscribes to SSE notifications for near-real-time wake-ups; this interval is the backstop that guarantees forward progress if SSE events are missed or the connection drops undetected."),
-}).describe("Continuously consume a trigger inbox: drain currently-available messages, then subscribe to SSE notifications 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

@@ -1,292 +0,0 @@
-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;
-} & {
-    getApp: (options?: {
-        app: string;
-    } | {
-        appKey: string;
-    } | undefined) => Promise<{
-        data: {
-            slug: string;
-            title: string;
-            key: string;
-            implementation_id: string;
-            description?: string | undefined;
-            is_hidden?: boolean | undefined;
-            auth_type?: string | undefined;
-            actions?: {
-                read?: number | undefined;
-                read_bulk?: number | undefined;
-                write?: number | undefined;
-                search?: number | undefined;
-                search_or_write?: number | undefined;
-                search_and_write?: number | undefined;
-                filter?: number | undefined;
-            } | undefined;
-            is_deprecated?: boolean | undefined;
-            is_beta?: boolean | undefined;
-            is_premium?: boolean | undefined;
-            age_in_days?: number | undefined;
-            banner?: string | undefined;
-            categories?: {
-                id: number;
-                name: string;
-                slug: string;
-            }[] | undefined;
-            images?: {
-                url_16x16?: string | undefined;
-                url_32x32?: string | undefined;
-                url_64x64?: string | undefined;
-                url_128x128?: string | undefined;
-            } | undefined;
-            popularity?: number | undefined;
-            has_filters?: boolean | undefined;
-            has_reads?: boolean | undefined;
-            has_searches?: boolean | undefined;
-            has_searches_or_writes?: boolean | undefined;
-            has_upfront_fields?: boolean | undefined;
-            has_writes?: boolean | undefined;
-            is_built_in?: boolean | undefined;
-            is_featured?: boolean | undefined;
-            is_invite?: boolean | undefined;
-            is_public?: boolean | undefined;
-            is_upcoming?: boolean | undefined;
-            visibility?: string | undefined;
-            primary_color?: string | undefined;
-            secondary_color?: string | undefined;
-            classification?: string | undefined;
-            api_docs_url?: string | undefined;
-            image?: string | undefined;
-            version?: string | undefined;
-        };
-    }>;
-} & {
-    context: {
-        meta: {
-            getApp: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    listApps: (options?: ({
-        search?: string | undefined;
-        apps?: string[] | undefined;
-        appKeys?: string[] | undefined;
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-    } & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        slug: string;
-        title: string;
-        key: string;
-        implementation_id: string;
-        description?: string | undefined;
-        is_hidden?: boolean | undefined;
-        auth_type?: string | undefined;
-        actions?: {
-            read?: number | undefined;
-            read_bulk?: number | undefined;
-            write?: number | undefined;
-            search?: number | undefined;
-            search_or_write?: number | undefined;
-            search_and_write?: number | undefined;
-            filter?: number | undefined;
-        } | undefined;
-        is_deprecated?: boolean | undefined;
-        is_beta?: boolean | undefined;
-        is_premium?: boolean | undefined;
-        age_in_days?: number | undefined;
-        banner?: string | undefined;
-        categories?: {
-            id: number;
-            name: string;
-            slug: string;
-        }[] | undefined;
-        images?: {
-            url_16x16?: string | undefined;
-            url_32x32?: string | undefined;
-            url_64x64?: string | undefined;
-            url_128x128?: string | undefined;
-        } | undefined;
-        popularity?: number | undefined;
-        has_filters?: boolean | undefined;
-        has_reads?: boolean | undefined;
-        has_searches?: boolean | undefined;
-        has_searches_or_writes?: boolean | undefined;
-        has_upfront_fields?: boolean | undefined;
-        has_writes?: boolean | undefined;
-        is_built_in?: boolean | undefined;
-        is_featured?: boolean | undefined;
-        is_invite?: boolean | undefined;
-        is_public?: boolean | undefined;
-        is_upcoming?: boolean | undefined;
-        visibility?: string | undefined;
-        primary_color?: string | undefined;
-        secondary_color?: string | undefined;
-        classification?: string | undefined;
-        api_docs_url?: string | undefined;
-        image?: string | undefined;
-        version?: string | undefined;
-    }>;
-} & {
-    context: {
-        meta: {
-            listApps: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    listActions: (options?: (({
-        app: string;
-        actionType?: "filter" | "write" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | undefined;
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-    } | {
-        appKey: string;
-        actionType?: "filter" | "write" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | undefined;
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-    }) & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        description: string;
-        key: string;
-        app_key: string;
-        action_type: "filter" | "write" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write";
-        title: string;
-        type: "action";
-        id?: string | undefined;
-        is_important?: boolean | undefined;
-        is_hidden?: boolean | undefined;
-        app_version?: string | undefined;
-    }>;
-} & {
-    context: {
-        meta: {
-            listActions: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    listConnections: (options?: ({
-        title?: string | undefined;
-        search?: string | undefined;
-        owner?: string | undefined;
-        app?: string | undefined;
-        appKey?: string | undefined;
-        connections?: string[] | undefined;
-        connectionIds?: string[] | undefined;
-        authenticationIds?: string[] | undefined;
-        account?: string | undefined;
-        accountId?: string | undefined;
-        includeShared?: boolean | undefined;
-        isExpired?: boolean | undefined;
-        expired?: boolean | undefined;
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-    } & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        date: string;
-        is_invite_only: boolean;
-        is_private: boolean;
-        shared_with_all: boolean;
-        id: string;
-        account_id: string;
-        title?: string | null | undefined;
-        lastchanged?: string | undefined;
-        destination_selected_api?: string | null | undefined;
-        is_stale?: string | undefined;
-        is_shared?: string | undefined;
-        marked_stale_at?: string | null | undefined;
-        label?: string | null | undefined;
-        identifier?: string | null | undefined;
-        url?: string | undefined;
-        groups?: Record<string, unknown>[] | undefined;
-        members?: string | undefined;
-        permissions?: Record<string, boolean> | undefined;
-        public_id?: string | undefined;
-        account_public_id?: string | undefined;
-        customuser_public_id?: string | undefined;
-        implementation_id?: string | undefined;
-        profile_id?: string | undefined;
-        is_expired?: string | undefined;
-        expired_at?: string | null | undefined;
-        app_key?: string | undefined;
-        app_version?: string | undefined;
-    }>;
-} & {
-    context: {
-        meta: {
-            listConnections: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    context: {
-        getVersionedImplementationId: GetVersionedImplementationId;
-    } & ConnectionsPluginProvides["context"];
-} & {
-    context: {
-        meta: Record<string, import("kitcore").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("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type EnsureTriggerInboxPluginProvides = ReturnType<typeof ensureTriggerInboxPlugin>;
-export { EnsureTriggerInboxSchema };
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/ensureTriggerInbox/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAA0B,MAAM,WAAW,CAAC;AAc7E,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,wBAAwB,CAAC;AAC3E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AASnE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAQpB;QACP,4BAA4B,EAAE,4BAA4B,CAAC;KAC5D,GAAG,yBAAyB,CAAC,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4F/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

@@ -1,65 +0,0 @@
-import { definePlugin, createPluginMethod } from "kitcore";
-import { EnsureTriggerInboxSchema, TriggerInboxItemSchema } from "./schemas";
-import { triggerInboxItemFormatter } from "../../../formatters/triggerInbox";
-import { ZapierConfigurationError, ZapierConflictError, } from "../../../types/errors";
-import { appKeyResolver, actionKeyResolver, connectionIdResolver, inputsResolver, } from "../../../resolvers";
-import { resolveConnectionId } from "../../../utils/domain-utils";
-import { triggersDefaults } from "../shared";
-import { extractErrorDetail } from "../utils";
-export const ensureTriggerInboxPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    ...triggersDefaults,
-    name: "ensureTriggerInbox",
-    type: "create",
-    itemType: "TriggerInbox",
-    inputSchema: EnsureTriggerInboxSchema,
-    outputSchema: TriggerInboxItemSchema,
-    formatter: triggerInboxItemFormatter,
-    // 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,
-                connection_id: resolvedConnectionId ?? null,
-            },
-        };
-        if (notificationUrl !== undefined) {
-            requestBody.notification_url = notificationUrl;
-        }
-        const rawResponse = await api.put("/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

@@ -1,20 +0,0 @@
-import { z } from "zod";
-import { TriggerInboxItemSchema, type TriggerInboxItem } from "../../../schemas/TriggerInbox";
-export declare const EnsureTriggerInboxSchema: z.ZodObject<{
-    name: z.ZodString;
-    app: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
-    };
-    action: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("kitcore").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>;
-export interface EnsureTriggerInboxResult {
-    data: TriggerInboxItem;
-}
-export { TriggerInboxItemSchema };
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/ensureTriggerInbox/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,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,CAAC;AAEF,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,gBAAgB,CAAC;CACxB;AAED,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

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

@@ -1,21 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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;
-} & {
-    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("kitcore").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("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    context: {
-        meta: Record<string, import("kitcore").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("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type GetTriggerInboxPluginProvides = ReturnType<typeof getTriggerInboxPlugin>;
-//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,28 +0,0 @@
-import { definePlugin, createPluginMethod } from "kitcore";
-import { GetTriggerInboxSchema, TriggerInboxItemSchema } from "./schemas";
-import { triggerInboxItemFormatter } from "../../../formatters/triggerInbox";
-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,
-    formatter: triggerInboxItemFormatter,
-    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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/getTriggerInbox/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,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,CAAC;AAE3E,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,gBAAgB,CAAC;CACxB;AAED,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

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

@@ -1,9 +0,0 @@
-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 };