@zapier/zapier-sdk 0.77.0 → 0.77.2

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

@@ -1,24 +0,0 @@
-import { z } from "zod";
-export declare const GetTriggerRunOptionsSchema: z.ZodObject<{
-    trigger: z.ZodString;
-}, z.core.$strip>;
-export type GetTriggerRunOptions = z.infer<typeof GetTriggerRunOptionsSchema>;
-export declare const GetTriggerRunResponseSchema: z.ZodObject<{
-    id: z.ZodString;
-    durable_run_id: z.ZodNullable<z.ZodString>;
-    workflow_version_id: z.ZodNullable<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.ZodUnknown>;
-    created_at: z.ZodString;
-    updated_at: z.ZodString;
-}, z.core.$strip>;
-export type GetTriggerRunResponse = z.infer<typeof GetTriggerRunResponseSchema>;
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/getTriggerRun/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,0BAA0B;;iBAMpC,CAAC;AAEJ,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;iBAwBtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

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

@@ -1,30 +0,0 @@
-import { z } from "zod";
-import { WorkflowRunStatusSchema } from "../listWorkflowRuns/schemas";
-export const GetTriggerRunOptionsSchema = z
-    .object({
-    trigger: z.string().uuid().describe("Workflow trigger ID"),
-})
-    .describe("Get the workflow run associated with a deployed workflow's trigger. Useful immediately after firing a trigger, when you have the trigger ID but not yet the run ID.");
-export const GetTriggerRunResponseSchema = z.object({
-    id: z.string().describe("Workflow run ID (UUID)"),
-    durable_run_id: z
-        .string()
-        .nullable()
-        .describe("Linked sdkdurableapi run ID. Null until the durable run is created."),
-    workflow_version_id: z
-        .string()
-        .nullable()
-        .describe("Workflow version the run is bound to"),
-    status: WorkflowRunStatusSchema,
-    input: z.unknown().describe("Input passed to the run"),
-    output: z
-        .unknown()
-        .nullable()
-        .describe("Return value, present when status is `finished`"),
-    error: z
-        .unknown()
-        .nullable()
-        .describe("Error payload when status is `failed` (null otherwise)"),
-    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/getWorkflow/index.d.ts

@@ -1,114 +0,0 @@
-export declare const getWorkflowPlugin: (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>;
-    };
-}) => {
-    getWorkflow: (options?: {
-        workflow: string;
-    } | undefined) => Promise<{
-        data: {
-            id: string;
-            name: string;
-            description: string | null;
-            trigger_url: string;
-            enabled: boolean;
-            is_private: boolean;
-            created_by_user_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;
-            current_version?: {
-                id: string;
-                workflow_id: string;
-                source_files: Record<string, string>;
-                zapier_durable_version: string;
-                dependencies: Record<string, string> | null;
-                created_by_user_id: string;
-                created_at: string;
-                trigger: {
-                    selected_api: string;
-                    action: string;
-                    authentication_id?: string | null | undefined;
-                    params?: Record<string, unknown> | undefined;
-                } | null;
-                connections: Record<string, {
-                    connection_id: string | number;
-                }> | null;
-                app_versions: Record<string, {
-                    implementation_name: string;
-                    version?: string | undefined;
-                }> | null;
-            } | undefined;
-        };
-    }>;
-} & {
-    context: {
-        meta: {
-            getWorkflow: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type GetWorkflowPluginProvides = ReturnType<typeof getWorkflowPlugin>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/getWorkflow/index.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0B7B,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

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

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

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

@@ -1,81 +0,0 @@
-import { z } from "zod";
-export declare const WorkflowVersionSchema: z.ZodObject<{
-    id: z.ZodString;
-    workflow_id: z.ZodString;
-    source_files: z.ZodRecord<z.ZodString, z.ZodString>;
-    zapier_durable_version: z.ZodString;
-    dependencies: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
-    created_by_user_id: z.ZodString;
-    created_at: z.ZodString;
-    trigger: z.ZodNullable<z.ZodObject<{
-        selected_api: z.ZodString;
-        action: z.ZodString;
-        authentication_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>>;
-    connections: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
-        connection_id: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodString]>;
-    }, z.core.$strip>>>;
-    app_versions: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
-        implementation_name: z.ZodString;
-        version: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export type WorkflowVersion = z.infer<typeof WorkflowVersionSchema>;
-export declare const GetWorkflowOptionsSchema: z.ZodObject<{
-    workflow: z.ZodString;
-}, z.core.$strip>;
-export type GetWorkflowOptions = z.infer<typeof GetWorkflowOptionsSchema>;
-export declare const GetWorkflowResponseSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    description: z.ZodNullable<z.ZodString>;
-    trigger_url: z.ZodString;
-    enabled: z.ZodBoolean;
-    disabled_reason: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-        trigger_claim_failed: "trigger_claim_failed";
-    }>>>;
-    is_private: z.ZodBoolean;
-    created_by_user_id: z.ZodNullable<z.ZodString>;
-    current_version: z.ZodOptional<z.ZodObject<{
-        id: z.ZodString;
-        workflow_id: z.ZodString;
-        source_files: z.ZodRecord<z.ZodString, z.ZodString>;
-        zapier_durable_version: z.ZodString;
-        dependencies: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
-        created_by_user_id: z.ZodString;
-        created_at: z.ZodString;
-        trigger: z.ZodNullable<z.ZodObject<{
-            selected_api: z.ZodString;
-            action: z.ZodString;
-            authentication_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        }, z.core.$strip>>;
-        connections: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
-            connection_id: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodString]>;
-        }, z.core.$strip>>>;
-        app_versions: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
-            implementation_name: z.ZodString;
-            version: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>>;
-    triggers: z.ZodArray<z.ZodObject<{
-        selected_api: z.ZodString;
-        action: z.ZodString;
-        authentication_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        status: z.ZodEnum<{
-            failed: "failed";
-            pending: "pending";
-            active: "active";
-            unclaimed: "unclaimed";
-            releasing: "releasing";
-            released: "released";
-        }>;
-        error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strip>>;
-    created_at: z.ZodString;
-    updated_at: z.ZodString;
-}, z.core.$strip>;
-export type GetWorkflowResponse = z.infer<typeof GetWorkflowResponseSchema>;
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/getWorkflow/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;iBAgChC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,wBAAwB;;iBAMlC,CAAC;AAEJ,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4CpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

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

@@ -1,71 +0,0 @@
-import { z } from "zod";
-import { AppVersionBindingSchema, ConnectionBindingSchema, WorkflowDisabledReasonSchema, WorkflowTriggerSchema, WorkflowVersionTriggerConfigSchema, } from "../shared-schemas";
-export const WorkflowVersionSchema = z.object({
-    id: z.string().describe("Workflow version ID (UUID)"),
-    workflow_id: z.string().describe("Parent workflow ID"),
-    source_files: z
-        .record(z.string(), z.string())
-        .describe("Source files keyed by filename → contents"),
-    zapier_durable_version: z
-        .string()
-        .describe("Pinned semver of @zapier/zapier-durable used by this version's runs"),
-    dependencies: z
-        .record(z.string(), z.string())
-        .nullable()
-        .describe("Additional npm dependencies pinned for this version (or null)"),
-    // Backend column is NOT NULL (see durableworkflowzaps prisma schema:
-    // workflow_versions.created_by_user_id), so this is always emitted.
-    created_by_user_id: z
-        .string()
-        .describe("ID of the user who published this version"),
-    created_at: z.string().describe("When the version was published (ISO-8601)"),
-    trigger: WorkflowVersionTriggerConfigSchema.nullable().describe("Trigger configuration persisted on this version, or null for webhook-only workflows."),
-    connections: z
-        .record(z.string(), ConnectionBindingSchema)
-        .nullable()
-        .describe("Connection aliases bound on this version (or null)."),
-    app_versions: z
-        .record(z.string(), AppVersionBindingSchema)
-        .nullable()
-        .describe("App-version pins bound on this version (or null)."),
-});
-export const GetWorkflowOptionsSchema = z
-    .object({
-    workflow: z.string().uuid().describe("Durable workflow ID"),
-})
-    .describe("Get a durable workflow with its current version details and trigger claim status");
-export const GetWorkflowResponseSchema = z.object({
-    id: z.string().describe("Workflow ID (UUID)"),
-    name: z.string().describe("Workflow name"),
-    description: z
-        .string()
-        .nullable()
-        .describe("Optional workflow description (null if unset)"),
-    trigger_url: z
-        .string()
-        .describe("Public webhook URL that fires this workflow when POSTed to. Embeds a secret trigger token in the path — treat as sensitive."),
-    enabled: z
-        .boolean()
-        .describe("Whether the workflow currently accepts triggers"),
-    // Optional until COSUB-630 ships the field server-side; afterwards the API
-    // always sends it (null unless the workflow was system-disabled). Kept
-    // independent of per-trigger status+error — see WorkflowDisabledReasonSchema.
-    disabled_reason: WorkflowDisabledReasonSchema.nullable()
-        .optional()
-        .describe("Why the workflow is off, when system-disabled. Null when not system-disabled. Independent of per-trigger claim status: an enabled workflow can still have a failed trigger."),
-    is_private: z
-        .boolean()
-        .describe("Whether the workflow is private to the creating user. False means account-visible."),
-    created_by_user_id: z
-        .string()
-        .nullable()
-        .describe("User ID of the workflow creator (null in legacy data)"),
-    current_version: WorkflowVersionSchema.optional().describe("The currently published version, if any. Absent for workflows with no version published yet."),
-    triggers: z
-        .array(WorkflowTriggerSchema)
-        .describe("Trigger configurations from the current version, with live claim status. Empty array when the workflow has no triggers."),
-    created_at: z.string().describe("When the workflow was created (ISO-8601)"),
-    updated_at: z
-        .string()
-        .describe("When the workflow was last modified (ISO-8601)"),
-});

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

@@ -1,112 +0,0 @@
-export declare const getWorkflowRunPlugin: (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>;
-        };
-    };
-} & {
-    listWorkflowRuns: (options?: ({
-        workflow: string;
-        pageSize?: number | undefined;
-        cursor?: string | undefined;
-        maxItems?: number | undefined;
-    } & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        id: string;
-        trigger_id: string | null;
-        durable_run_id: string | null;
-        workflow_version_id: string | null;
-        status: string;
-        input: unknown;
-        error: unknown;
-        created_at: string;
-        updated_at: string;
-    }>;
-} & {
-    context: {
-        meta: {
-            listWorkflowRuns: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    getWorkflowRun: (options?: {
-        run: string;
-        workflow?: string | undefined;
-    } | undefined) => Promise<{
-        data: {
-            id: string;
-            trigger_id: string | null;
-            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: {
-            getWorkflowRun: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type GetWorkflowRunPluginProvides = ReturnType<typeof getWorkflowRunPlugin>;
-//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,25 +0,0 @@
-import { definePlugin, createPluginMethod } from "kitcore";
-import { workflowIdResolver } from "../../../resolvers/workflowId";
-import { workflowRunIdResolver } from "../../../resolvers/workflowRunId";
-import { codeSubstrateDefaults } from "../shared";
-import { GetWorkflowRunOptionsSchema, GetWorkflowRunResponseSchema, } from "./schemas";
-export const getWorkflowRunPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    ...codeSubstrateDefaults,
-    name: "getWorkflowRun",
-    type: "item",
-    itemType: "WorkflowRun",
-    inputSchema: GetWorkflowRunOptionsSchema,
-    outputSchema: GetWorkflowRunResponseSchema,
-    resolvers: {
-        workflow: workflowIdResolver,
-        run: workflowRunIdResolver,
-    },
-    handler: async ({ sdk, options }) => {
-        const raw = await sdk.context.api.get(`/durableworkflowzaps/api/v0/workflows/runs/${encodeURIComponent(options.run)}`, {
-            authRequired: true,
-            resource: { type: "workflow-run", id: options.run },
-        });
-        const data = GetWorkflowRunResponseSchema.parse(raw);
-        return { data };
-    },
-}));

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

@@ -1,26 +0,0 @@
-import { z } from "zod";
-export declare const GetWorkflowRunOptionsSchema: z.ZodObject<{
-    workflow: z.ZodOptional<z.ZodString>;
-    run: z.ZodString;
-}, z.core.$strip>;
-export type GetWorkflowRunOptions = z.infer<typeof GetWorkflowRunOptionsSchema>;
-export declare const GetWorkflowRunResponseSchema: z.ZodObject<{
-    id: z.ZodString;
-    trigger_id: z.ZodNullable<z.ZodString>;
-    durable_run_id: z.ZodNullable<z.ZodString>;
-    workflow_version_id: z.ZodNullable<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.ZodUnknown>;
-    created_at: z.ZodString;
-    updated_at: z.ZodString;
-}, z.core.$strip>;
-export type GetWorkflowRunResponse = z.infer<typeof GetWorkflowRunResponseSchema>;
-//# sourceMappingURL=schemas.d.ts.map

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

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

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

@@ -1,43 +0,0 @@
-import { z } from "zod";
-import { WorkflowRunStatusSchema } from "../listWorkflowRuns/schemas";
-export const GetWorkflowRunOptionsSchema = z
-    .object({
-    // Picker-only field — the API endpoint is /workflows/runs/:id and
-    // does not take a workflow id, but the run-id picker is scoped to a
-    // parent workflow so the user can browse runs without enumerating
-    // every run across every workflow on the account.
-    workflow: z
-        .string()
-        .uuid()
-        .optional()
-        .describe("Parent workflow ID — used only to scope the CLI run-id picker; ignored by the API call."),
-    run: z.string().uuid().describe("Workflow run ID"),
-})
-    .describe("Get the current state of a workflow run (a triggered execution of a deployed workflow)");
-export const GetWorkflowRunResponseSchema = z.object({
-    id: z.string().describe("Workflow run ID (UUID)"),
-    trigger_id: z
-        .string()
-        .nullable()
-        .describe("ID of the trigger that fired this run, if any"),
-    durable_run_id: z
-        .string()
-        .nullable()
-        .describe("Linked sdkdurableapi run ID. Null until the durable run is created."),
-    workflow_version_id: z
-        .string()
-        .nullable()
-        .describe("Workflow version the run is bound to"),
-    status: WorkflowRunStatusSchema,
-    input: z.unknown().describe("Input passed to the run"),
-    output: z
-        .unknown()
-        .nullable()
-        .describe("Return value, present when status is `finished`"),
-    error: z
-        .unknown()
-        .nullable()
-        .describe("Error payload when status is `failed` (null otherwise)"),
-    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)"),
-});