@zapier/zapier-sdk 0.77.0 → 0.77.2

package/dist/plugins/codeSubstrate/enableWorkflow/index.d.ts

@@ -1,76 +0,0 @@
-export declare const enableWorkflowPlugin: (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;
-} & {
-    listWorkflows: (options?: ({
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-    } & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        id: string;
-        name: string;
-        description: string | null;
-        trigger_url: string;
-        enabled: boolean;
-        is_private: boolean;
-        created_by_user_id: string | null;
-        current_version_id: string | null;
-        triggers: {
-            selected_api: string;
-            action: string;
-            status: "failed" | "pending" | "active" | "unclaimed" | "releasing" | "released";
-            authentication_id?: string | null | undefined;
-            params?: Record<string, unknown> | undefined;
-            error?: string | null | undefined;
-        }[];
-        created_at: string;
-        updated_at: string;
-        disabled_reason?: "trigger_claim_failed" | null | undefined;
-    }>;
-} & {
-    context: {
-        meta: {
-            listWorkflows: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    enableWorkflow: (options?: {
-        workflow: string;
-    } | undefined) => Promise<{
-        data: {
-            id: string;
-            enabled: boolean;
-        };
-    }>;
-} & {
-    context: {
-        meta: {
-            enableWorkflow: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type EnableWorkflowPluginProvides = ReturnType<typeof enableWorkflowPlugin>;
-//# sourceMappingURL=index.d.ts.map

package/dist/plugins/codeSubstrate/enableWorkflow/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/enableWorkflow/index.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BhC,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG,UAAU,CACnD,OAAO,oBAAoB,CAC5B,CAAC"}

package/dist/plugins/codeSubstrate/enableWorkflow/index.js

@@ -1,21 +0,0 @@
-import { definePlugin, createPluginMethod } from "kitcore";
-import { workflowIdResolver } from "../../../resolvers/workflowId";
-import { codeSubstrateDefaults } from "../shared";
-import { EnableWorkflowOptionsSchema, EnableWorkflowResponseSchema, } from "./schemas";
-export const enableWorkflowPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    ...codeSubstrateDefaults,
-    name: "enableWorkflow",
-    type: "update",
-    itemType: "Workflow",
-    inputSchema: EnableWorkflowOptionsSchema,
-    outputSchema: EnableWorkflowResponseSchema,
-    resolvers: { workflow: workflowIdResolver },
-    handler: async ({ sdk, options }) => {
-        const raw = await sdk.context.api.post(`/durableworkflowzaps/api/v0/workflows/${encodeURIComponent(options.workflow)}/enable`, undefined, {
-            authRequired: true,
-            resource: { type: "workflow", id: options.workflow },
-        });
-        const data = EnableWorkflowResponseSchema.parse(raw);
-        return { data };
-    },
-}));

package/dist/plugins/codeSubstrate/enableWorkflow/schemas.d.ts

@@ -1,11 +0,0 @@
-import { z } from "zod";
-export declare const EnableWorkflowOptionsSchema: z.ZodObject<{
-    workflow: z.ZodString;
-}, z.core.$strip>;
-export type EnableWorkflowOptions = z.infer<typeof EnableWorkflowOptionsSchema>;
-export declare const EnableWorkflowResponseSchema: z.ZodObject<{
-    id: z.ZodString;
-    enabled: z.ZodBoolean;
-}, z.core.$strip>;
-export type EnableWorkflowResponse = z.infer<typeof EnableWorkflowResponseSchema>;
-//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/codeSubstrate/enableWorkflow/schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/enableWorkflow/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,2BAA2B;;iBAIuB,CAAC;AAEhE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,4BAA4B;;;iBAKvC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC"}

package/dist/plugins/codeSubstrate/enableWorkflow/schemas.js

@@ -1,12 +0,0 @@
-import { z } from "zod";
-export const EnableWorkflowOptionsSchema = z
-    .object({
-    workflow: z.string().uuid().describe("Durable workflow ID"),
-})
-    .describe("Enable a durable workflow so it accepts triggers");
-export const EnableWorkflowResponseSchema = z.object({
-    id: z.string().describe("Workflow ID (UUID)"),
-    enabled: z
-        .boolean()
-        .describe("Workflow's enabled state after the operation (always true)"),
-});

package/dist/plugins/codeSubstrate/getDurableRun/index.d.ts

@@ -1,119 +0,0 @@
-export declare const getDurableRunPlugin: (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;
-} & {
-    listDurableRuns: (options?: ({
-        pageSize?: number | undefined;
-        cursor?: string | undefined;
-        maxItems?: number | undefined;
-    } & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        id: string;
-        status: string;
-        input: unknown;
-        output: unknown;
-        error: {
-            [x: string]: unknown;
-            code: string;
-            message: string;
-        } | null;
-        execution_id: string | null;
-        is_private: boolean;
-        created_at: string;
-        updated_at: string;
-    }>;
-} & {
-    context: {
-        meta: {
-            listDurableRuns: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    getDurableRun: (options?: {
-        run: string;
-    } | undefined) => Promise<{
-        data: {
-            id: string;
-            status: string;
-            input: unknown;
-            output: unknown;
-            error: {
-                [x: string]: unknown;
-                code: string;
-                message: string;
-            } | null;
-            execution: {
-                id: string;
-                name: string;
-                status: string;
-                input: unknown;
-                created_at: string;
-                output?: unknown;
-                error?: unknown;
-                metadata?: Record<string, unknown> | undefined;
-                summary?: {
-                    [x: string]: unknown;
-                    total_attempts: number;
-                    last_error?: {
-                        [x: string]: unknown;
-                        code: string;
-                        title: string;
-                        detail?: string | null | undefined;
-                    } | null | undefined;
-                } | null | undefined;
-                operations?: {
-                    id: string;
-                    execution_id: string;
-                    name: string;
-                    type: string;
-                    status: string;
-                    retry_count: number;
-                    created_at: string;
-                    result?: unknown;
-                    error?: unknown;
-                    max_attempts?: number | undefined;
-                    next_retry_at?: string | undefined;
-                    resume_at?: string | undefined;
-                    callback_token?: string | null | undefined;
-                    payload_schema?: unknown;
-                    payload?: unknown;
-                    expires_at?: string | undefined;
-                    completed_at?: string | undefined;
-                }[] | undefined;
-            } | null;
-            is_private: boolean;
-            created_at: string;
-            updated_at: string;
-        };
-    }>;
-} & {
-    context: {
-        meta: {
-            getDurableRun: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type GetDurableRunPluginProvides = ReturnType<typeof getDurableRunPlugin>;
-//# sourceMappingURL=index.d.ts.map

package/dist/plugins/codeSubstrate/getDurableRun/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/getDurableRun/index.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0B/B,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG,UAAU,CAClD,OAAO,mBAAmB,CAC3B,CAAC"}

package/dist/plugins/codeSubstrate/getDurableRun/index.js

@@ -1,21 +0,0 @@
-import { definePlugin, createPluginMethod } from "kitcore";
-import { durableRunIdResolver } from "../../../resolvers/durableRunId";
-import { codeSubstrateDefaults } from "../shared";
-import { GetDurableRunOptionsSchema, GetDurableRunResponseSchema, } from "./schemas";
-export const getDurableRunPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    ...codeSubstrateDefaults,
-    name: "getDurableRun",
-    type: "item",
-    itemType: "DurableRun",
-    inputSchema: GetDurableRunOptionsSchema,
-    outputSchema: GetDurableRunResponseSchema,
-    resolvers: { run: durableRunIdResolver },
-    handler: async ({ sdk, options }) => {
-        const raw = await sdk.context.api.get(`/sdkdurableapi/api/v0/runs/${encodeURIComponent(options.run)}`, {
-            authRequired: true,
-            resource: { type: "run", id: options.run },
-        });
-        const data = GetDurableRunResponseSchema.parse(raw);
-        return { data };
-    },
-}));

package/dist/plugins/codeSubstrate/getDurableRun/schemas.d.ts

@@ -1,178 +0,0 @@
-import { z } from "zod";
-export declare const OperationTypeSchema: z.ZodUnion<readonly [z.ZodEnum<{
-    step: "step";
-    wait: "wait";
-    callback: "callback";
-}>, z.ZodString]>;
-export type OperationType = z.infer<typeof OperationTypeSchema>;
-export declare const OperationStatusSchema: z.ZodUnion<readonly [z.ZodEnum<{
-    failed: "failed";
-    pending: "pending";
-    exhausted: "exhausted";
-    completed: "completed";
-}>, z.ZodString]>;
-export type OperationStatus = z.infer<typeof OperationStatusSchema>;
-export declare const OperationSchema: z.ZodObject<{
-    id: z.ZodString;
-    execution_id: z.ZodString;
-    name: z.ZodString;
-    type: z.ZodUnion<readonly [z.ZodEnum<{
-        step: "step";
-        wait: "wait";
-        callback: "callback";
-    }>, z.ZodString]>;
-    status: z.ZodUnion<readonly [z.ZodEnum<{
-        failed: "failed";
-        pending: "pending";
-        exhausted: "exhausted";
-        completed: "completed";
-    }>, z.ZodString]>;
-    result: z.ZodOptional<z.ZodUnknown>;
-    error: z.ZodOptional<z.ZodUnknown>;
-    retry_count: z.ZodNumber;
-    max_attempts: z.ZodOptional<z.ZodNumber>;
-    next_retry_at: z.ZodOptional<z.ZodString>;
-    resume_at: z.ZodOptional<z.ZodString>;
-    callback_token: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    payload_schema: z.ZodOptional<z.ZodUnknown>;
-    payload: z.ZodOptional<z.ZodUnknown>;
-    expires_at: z.ZodOptional<z.ZodString>;
-    completed_at: z.ZodOptional<z.ZodString>;
-    created_at: z.ZodString;
-}, z.core.$strip>;
-export type Operation = z.infer<typeof OperationSchema>;
-export declare const ExecutionStatusSchema: z.ZodUnion<readonly [z.ZodEnum<{
-    failed: "failed";
-    waiting: "waiting";
-    completed: "completed";
-    running: "running";
-}>, z.ZodString]>;
-export type ExecutionStatus = z.infer<typeof ExecutionStatusSchema>;
-export declare const ExecutionSummarySchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    status: z.ZodUnion<readonly [z.ZodEnum<{
-        failed: "failed";
-        waiting: "waiting";
-        completed: "completed";
-        running: "running";
-    }>, z.ZodString]>;
-    input: z.ZodUnknown;
-    output: z.ZodOptional<z.ZodUnknown>;
-    error: z.ZodOptional<z.ZodUnknown>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    created_at: z.ZodString;
-    summary: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        total_attempts: z.ZodNumber;
-        last_error: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-            code: z.ZodString;
-            title: z.ZodString;
-            detail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        }, z.core.$loose>>>;
-    }, z.core.$loose>>>;
-    operations: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        execution_id: z.ZodString;
-        name: z.ZodString;
-        type: z.ZodUnion<readonly [z.ZodEnum<{
-            step: "step";
-            wait: "wait";
-            callback: "callback";
-        }>, z.ZodString]>;
-        status: z.ZodUnion<readonly [z.ZodEnum<{
-            failed: "failed";
-            pending: "pending";
-            exhausted: "exhausted";
-            completed: "completed";
-        }>, z.ZodString]>;
-        result: z.ZodOptional<z.ZodUnknown>;
-        error: z.ZodOptional<z.ZodUnknown>;
-        retry_count: z.ZodNumber;
-        max_attempts: z.ZodOptional<z.ZodNumber>;
-        next_retry_at: z.ZodOptional<z.ZodString>;
-        resume_at: z.ZodOptional<z.ZodString>;
-        callback_token: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        payload_schema: z.ZodOptional<z.ZodUnknown>;
-        payload: z.ZodOptional<z.ZodUnknown>;
-        expires_at: z.ZodOptional<z.ZodString>;
-        completed_at: z.ZodOptional<z.ZodString>;
-        created_at: z.ZodString;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export type ExecutionSummary = z.infer<typeof ExecutionSummarySchema>;
-export declare const GetDurableRunOptionsSchema: z.ZodObject<{
-    run: z.ZodString;
-}, z.core.$strip>;
-export type GetDurableRunOptions = z.infer<typeof GetDurableRunOptionsSchema>;
-export declare const GetDurableRunResponseSchema: z.ZodObject<{
-    id: z.ZodString;
-    status: z.ZodUnion<readonly [z.ZodEnum<{
-        failed: "failed";
-        initialized: "initialized";
-        started: "started";
-        finished: "finished";
-        cancelled: "cancelled";
-    }>, z.ZodString]>;
-    input: z.ZodUnknown;
-    output: z.ZodNullable<z.ZodUnknown>;
-    error: z.ZodNullable<z.ZodObject<{
-        code: z.ZodString;
-        message: z.ZodString;
-    }, z.core.$loose>>;
-    execution: z.ZodNullable<z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodString;
-        status: z.ZodUnion<readonly [z.ZodEnum<{
-            failed: "failed";
-            waiting: "waiting";
-            completed: "completed";
-            running: "running";
-        }>, z.ZodString]>;
-        input: z.ZodUnknown;
-        output: z.ZodOptional<z.ZodUnknown>;
-        error: z.ZodOptional<z.ZodUnknown>;
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        created_at: z.ZodString;
-        summary: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-            total_attempts: z.ZodNumber;
-            last_error: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-                code: z.ZodString;
-                title: z.ZodString;
-                detail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            }, z.core.$loose>>>;
-        }, z.core.$loose>>>;
-        operations: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            execution_id: z.ZodString;
-            name: z.ZodString;
-            type: z.ZodUnion<readonly [z.ZodEnum<{
-                step: "step";
-                wait: "wait";
-                callback: "callback";
-            }>, z.ZodString]>;
-            status: z.ZodUnion<readonly [z.ZodEnum<{
-                failed: "failed";
-                pending: "pending";
-                exhausted: "exhausted";
-                completed: "completed";
-            }>, z.ZodString]>;
-            result: z.ZodOptional<z.ZodUnknown>;
-            error: z.ZodOptional<z.ZodUnknown>;
-            retry_count: z.ZodNumber;
-            max_attempts: z.ZodOptional<z.ZodNumber>;
-            next_retry_at: z.ZodOptional<z.ZodString>;
-            resume_at: z.ZodOptional<z.ZodString>;
-            callback_token: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            payload_schema: z.ZodOptional<z.ZodUnknown>;
-            payload: z.ZodOptional<z.ZodUnknown>;
-            expires_at: z.ZodOptional<z.ZodString>;
-            completed_at: z.ZodOptional<z.ZodString>;
-            created_at: z.ZodString;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>>;
-    is_private: z.ZodBoolean;
-    created_at: z.ZodString;
-    updated_at: z.ZodString;
-}, z.core.$strip>;
-export type GetDurableRunResponse = z.infer<typeof GetDurableRunResponseSchema>;
-//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/codeSubstrate/getDurableRun/schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/getDurableRun/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,mBAAmB;;;;iBAG/B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,qBAAqB;;;;;iBAGjC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyD1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,qBAAqB;;;;;iBAGjC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,0BAA0B;;iBAMpC,CAAC;AAEJ,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqBtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/plugins/codeSubstrate/getDurableRun/schemas.js

@@ -1,126 +0,0 @@
-import { z } from "zod";
-import { RunErrorSchema, RunStatusSchema } from "../listDurableRuns/schemas";
-import { openEnum } from "kitcore";
-export const OperationTypeSchema = openEnum(["step", "wait", "callback"], "Operation kind: `step` is a journaled function call; `wait` is a time-based suspension; `callback` is a wait on an external callback.");
-export const OperationStatusSchema = openEnum(["pending", "completed", "failed", "exhausted"], "Operation lifecycle status. `exhausted` means retries were exceeded.");
-export const OperationSchema = z.object({
-    id: z.string().describe("Operation ID (UUID)"),
-    execution_id: z.string().describe("Parent execution ID"),
-    name: z
-        .string()
-        .describe("Operation name as declared by the workflow author"),
-    type: OperationTypeSchema,
-    status: OperationStatusSchema,
-    result: z
-        .unknown()
-        .optional()
-        .describe("Result value when the operation completed"),
-    error: z
-        .unknown()
-        .optional()
-        .describe("Error payload when the operation failed"),
-    retry_count: z.number().describe("Number of retry attempts so far"),
-    max_attempts: z
-        .number()
-        .optional()
-        .describe("Cap on total attempts for this operation. Absent if no cap applies."),
-    next_retry_at: z
-        .string()
-        .optional()
-        .describe("When the next retry will be attempted (ISO-8601)"),
-    resume_at: z
-        .string()
-        .optional()
-        .describe("When a `wait` operation resumes (ISO-8601). Set only for type=wait."),
-    callback_token: z
-        .string()
-        .nullable()
-        .optional()
-        .describe("Token for delivering a callback. Set only for type=callback; null until the callback URL is materialized."),
-    payload_schema: z
-        .unknown()
-        .optional()
-        .describe("JSON Schema describing the expected callback payload"),
-    payload: z
-        .unknown()
-        .optional()
-        .describe("Payload delivered to a callback operation, when received"),
-    expires_at: z
-        .string()
-        .optional()
-        .describe("When a callback or wait operation expires (ISO-8601)"),
-    completed_at: z
-        .string()
-        .optional()
-        .describe("When the operation reached a terminal state (ISO-8601)"),
-    created_at: z.string().describe("When the operation was created (ISO-8601)"),
-});
-export const ExecutionStatusSchema = openEnum(["running", "waiting", "completed", "failed"], "Execution lifecycle status. `waiting` means blocked on a wait or callback operation.");
-export const ExecutionSummarySchema = z.object({
-    id: z.string().describe("Execution ID (UUID)"),
-    name: z.string().describe("Durable function name"),
-    status: ExecutionStatusSchema,
-    input: z.unknown().describe("Input passed when the execution was created"),
-    output: z
-        .unknown()
-        .optional()
-        .describe("Return value when status is `completed`"),
-    error: z
-        .unknown()
-        .optional()
-        .describe("Error details when status is `failed`"),
-    metadata: z
-        .record(z.string(), z.unknown())
-        .optional()
-        .describe("Caller-supplied tags (Zap ID, Step ID, Agent ID, etc.) carried alongside the execution"),
-    created_at: z.string().describe("When the execution was created (ISO-8601)"),
-    summary: z
-        .object({
-        total_attempts: z
-            .number()
-            .describe("Total ticks attempted against this execution across all retries"),
-        last_error: z
-            .object({
-            code: z.string().describe("Machine-readable error category"),
-            title: z.string().describe("Short error label"),
-            detail: z
-                .string()
-                .nullable()
-                .optional()
-                .describe("Longer-form error detail, when provided"),
-        })
-            .passthrough()
-            .nullable()
-            .optional()
-            .describe("The most recent error; null when the execution has not errored."),
-    })
-        .passthrough()
-        .nullable()
-        .optional()
-        .describe("Aggregate health summary. Null when no attempts have been recorded yet."),
-    operations: z
-        .array(OperationSchema)
-        .optional()
-        .describe("Operations journal — append-only record of every step/wait/callback the execution made"),
-});
-export const GetDurableRunOptionsSchema = z
-    .object({
-    run: z.string().uuid().describe("Durable run ID"),
-})
-    .describe("Get the full state of a run-once durable run, including its operations journal");
-export const GetDurableRunResponseSchema = z.object({
-    id: z.string().describe("Run ID (UUID)"),
-    status: RunStatusSchema,
-    input: z.unknown().describe("Input data passed to the run"),
-    output: z
-        .unknown()
-        .nullable()
-        .describe("Return value, present when status is `finished`"),
-    error: RunErrorSchema.nullable().describe("Structured error details when the run failed (null otherwise)"),
-    execution: ExecutionSummarySchema.nullable().describe("Linked execution, including the operations journal. Null while the run is still in `initialized` state."),
-    is_private: z
-        .boolean()
-        .describe("When true, the run is visible only to the creating user; otherwise visible across the account."),
-    created_at: z.string().describe("When the run was created (ISO-8601)"),
-    updated_at: z.string().describe("When the run was last updated (ISO-8601)"),
-});

package/dist/plugins/codeSubstrate/getTriggerRun/index.d.ts

@@ -1,47 +0,0 @@
-export declare const getTriggerRunPlugin: (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("kitcore").PluginMeta>;
-    };
-}) => {
-    getTriggerRun: (options?: {
-        trigger: string;
-    } | undefined) => Promise<{
-        data: {
-            id: string;
-            durable_run_id: string | null;
-            workflow_version_id: string | null;
-            status: string;
-            input: unknown;
-            output: unknown;
-            error: unknown;
-            created_at: string;
-            updated_at: string;
-        };
-    }>;
-} & {
-    context: {
-        meta: {
-            getTriggerRun: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type GetTriggerRunPluginProvides = ReturnType<typeof getTriggerRunPlugin>;
-//# sourceMappingURL=index.d.ts.map

package/dist/plugins/codeSubstrate/getTriggerRun/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/getTriggerRun/index.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyB/B,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG,UAAU,CAClD,OAAO,mBAAmB,CAC3B,CAAC"}

package/dist/plugins/codeSubstrate/getTriggerRun/index.js

@@ -1,23 +0,0 @@
-import { definePlugin, createPluginMethod } from "kitcore";
-import { codeSubstrateDefaults } from "../shared";
-import { GetTriggerRunOptionsSchema, GetTriggerRunResponseSchema, } from "./schemas";
-export const getTriggerRunPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    ...codeSubstrateDefaults,
-    name: "getTriggerRun",
-    type: "item",
-    itemType: "WorkflowRun",
-    inputSchema: GetTriggerRunOptionsSchema,
-    outputSchema: GetTriggerRunResponseSchema,
-    // No resolver for `trigger` — users typically have the trigger id
-    // from a recent trigger fire and pass it directly. Authoring a
-    // picker would require listing triggers across all workflows,
-    // which has no clean entry point today.
-    handler: async ({ sdk, options }) => {
-        const raw = await sdk.context.api.get(`/durableworkflowzaps/api/v0/workflows/triggers/${encodeURIComponent(options.trigger)}/run`, {
-            authRequired: true,
-            resource: { type: "workflow-trigger", id: options.trigger },
-        });
-        const data = GetTriggerRunResponseSchema.parse(raw);
-        return { data };
-    },
-}));