@zapier/zapier-sdk 0.64.0 → 0.67.0

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

@@ -0,0 +1,102 @@
+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;
+        current_version_id: string | null;
+        created_at: string;
+        updated_at: string;
+    }>;
+} & {
+    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;
+        output: 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

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

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

@@ -0,0 +1,26 @@
+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<{
+        initialized: "initialized";
+        started: "started";
+        finished: "finished";
+        failed: "failed";
+        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

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

@@ -0,0 +1,43 @@
+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)"),
+});

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

@@ -16,9 +16,58 @@ export declare const getWorkflowVersionPlugin: (sdk: {
     };
 } & {
     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;
+        current_version_id: string | null;
+        created_at: string;
+        updated_at: string;
+    }>;
+} & {
+    context: {
+        meta: {
+            listWorkflows: import("kitcore").PluginMeta<unknown>;
+        };
+    };
+} & {
+    listWorkflowVersions: (options?: ({
+        workflow: string;
+        pageSize?: number | undefined;
+        cursor?: string | undefined;
+        maxItems?: number | undefined;
+    } & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("kitcore").PaginatedSdkResult<{
+        id: string;
+        workflow_id: string;
+        zapier_durable_version: string;
+        dependencies: Record<string, string> | null;
+        created_by_user_id: string;
+        created_at: string;
+    }>;
+} & {
+    context: {
+        meta: {
+            listWorkflowVersions: import("kitcore").PluginMeta<unknown>;
+        };
+    };
 } & {
     context: {
-        meta: Record<string, import("../../..").PluginMeta>;
+        meta: Record<string, import("kitcore").PluginMeta>;
     };
 }) => {
     getWorkflowVersion: (options?: {
@@ -38,7 +87,7 @@ export declare const getWorkflowVersionPlugin: (sdk: {
 } & {
     context: {
         meta: {
-            getWorkflowVersion: import("../../..").PluginMeta;
+            getWorkflowVersion: import("kitcore").PluginMeta<unknown>;
         };
     };
 };

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/getWorkflowVersion/index.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBpC,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG,UAAU,CACvD,OAAO,wBAAwB,CAChC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/getWorkflowVersion/index.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BpC,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG,UAAU,CACvD,OAAO,wBAAwB,CAChC,CAAC"}

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

@@ -1,4 +1,4 @@
-import { definePlugin, createPluginMethod } from "../../../utils/plugin-utils";
+import { definePlugin, createPluginMethod } from "kitcore";
 import { workflowIdResolver } from "../../../resolvers/workflowId";
 import { workflowVersionIdResolver } from "../../../resolvers/workflowVersionId";
 import { codeSubstrateDefaults } from "../shared";

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

@@ -18,7 +18,7 @@ export declare const listDurableRunsPlugin: (sdk: {
     context: import("../../eventEmission").EventEmissionContext;
 } & {
     context: {
-        meta: Record<string, import("../../..").PluginMeta>;
+        meta: Record<string, import("kitcore").PluginMeta>;
     };
 }) => {
     listDurableRuns: (options?: ({
@@ -29,7 +29,7 @@ export declare const listDurableRunsPlugin: (sdk: {
         cursor?: string;
         pageSize?: number;
         maxItems?: number;
-    }) | undefined) => import("../../..").PaginatedSdkResult<{
+    }) | undefined) => import("kitcore").PaginatedSdkResult<{
         id: string;
         status: "initialized" | "started" | "finished" | "failed" | "cancelled";
         input: unknown;
@@ -47,7 +47,7 @@ export declare const listDurableRunsPlugin: (sdk: {
 } & {
     context: {
         meta: {
-            listDurableRuns: import("../../..").PluginMeta;
+            listDurableRuns: import("kitcore").PluginMeta<unknown>;
         };
     };
 };

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/listDurableRuns/index.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BjC,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG,UAAU,CACpD,OAAO,qBAAqB,CAC7B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/listDurableRuns/index.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BjC,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG,UAAU,CACpD,OAAO,qBAAqB,CAC7B,CAAC"}

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

@@ -1,4 +1,4 @@
-import { definePlugin, createPaginatedPluginMethod, } from "../../../utils/plugin-utils";
+import { definePlugin, createPaginatedPluginMethod } from "kitcore";
 import { DEFAULT_PAGE_SIZE } from "../../../constants";
 import { codeSubstrateDefaults } from "../shared";
 import { ListDurableRunsOptionsSchema, RunItemSchema, } from "./schemas";

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

@@ -0,0 +1,78 @@
+export declare const listWorkflowRunsPlugin: (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;
+        current_version_id: string | null;
+        created_at: string;
+        updated_at: string;
+    }>;
+} & {
+    context: {
+        meta: {
+            listWorkflows: import("kitcore").PluginMeta<unknown>;
+        };
+    };
+} & {
+    context: {
+        meta: Record<string, import("kitcore").PluginMeta>;
+    };
+}) => {
+    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;
+        output: unknown;
+        error: unknown;
+        created_at: string;
+        updated_at: string;
+    }>;
+} & {
+    context: {
+        meta: {
+            listWorkflowRuns: import("kitcore").PluginMeta<unknown>;
+        };
+    };
+};
+export type ListWorkflowRunsPluginProvides = ReturnType<typeof listWorkflowRunsPlugin>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/listWorkflowRuns/index.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsClC,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG,UAAU,CACrD,OAAO,sBAAsB,CAC9B,CAAC"}

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

@@ -0,0 +1,34 @@
+import { definePlugin, createPaginatedPluginMethod } from "kitcore";
+import { workflowIdResolver } from "../../../resolvers/workflowId";
+import { DEFAULT_PAGE_SIZE } from "../../../constants";
+import { codeSubstrateDefaults } from "../shared";
+import { ListWorkflowRunsApiResponseSchema, ListWorkflowRunsOptionsSchema, WorkflowRunListItemSchema, } from "./schemas";
+export const listWorkflowRunsPlugin = definePlugin((sdk) => createPaginatedPluginMethod(sdk, {
+    ...codeSubstrateDefaults,
+    name: "listWorkflowRuns",
+    type: "list",
+    itemType: "WorkflowRun",
+    inputSchema: ListWorkflowRunsOptionsSchema,
+    outputSchema: WorkflowRunListItemSchema,
+    defaultPageSize: DEFAULT_PAGE_SIZE,
+    resolvers: { workflow: workflowIdResolver },
+    handler: async ({ sdk, options }) => {
+        const searchParams = {};
+        if (options.pageSize !== undefined) {
+            searchParams.limit = options.pageSize.toString();
+        }
+        if (options.cursor) {
+            searchParams.cursor = options.cursor;
+        }
+        const raw = await sdk.context.api.get(`/durableworkflowzaps/api/v0/workflows/${encodeURIComponent(options.workflow)}/runs`, {
+            searchParams,
+            authRequired: true,
+            resource: { type: "workflow", id: options.workflow },
+        });
+        const response = ListWorkflowRunsApiResponseSchema.parse(raw);
+        return {
+            data: response.results,
+            nextCursor: response.meta.next_cursor ?? undefined,
+        };
+    },
+}));

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

@@ -0,0 +1,65 @@
+import { z } from "zod";
+export declare const WorkflowRunStatusSchema: z.ZodUnion<readonly [z.ZodEnum<{
+    initialized: "initialized";
+    started: "started";
+    finished: "finished";
+    failed: "failed";
+    cancelled: "cancelled";
+}>, z.ZodString]>;
+export type WorkflowRunStatus = z.infer<typeof WorkflowRunStatusSchema>;
+export declare const WorkflowRunListItemSchema: 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<{
+        initialized: "initialized";
+        started: "started";
+        finished: "finished";
+        failed: "failed";
+        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 WorkflowRunListItem = z.infer<typeof WorkflowRunListItemSchema>;
+export declare const ListWorkflowRunsOptionsSchema: z.ZodObject<{
+    workflow: z.ZodString;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ListWorkflowRunsOptions = z.infer<typeof ListWorkflowRunsOptionsSchema>;
+export declare const ListWorkflowRunsApiResponseSchema: z.ZodObject<{
+    results: z.ZodArray<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<{
+            initialized: "initialized";
+            started: "started";
+            finished: "finished";
+            failed: "failed";
+            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>>;
+    meta: z.ZodObject<{
+        limit: z.ZodNumber;
+        cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        next_cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    links: z.ZodOptional<z.ZodObject<{
+        next: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ListWorkflowRunsApiResponse = z.infer<typeof ListWorkflowRunsApiResponseSchema>;
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/listWorkflowRuns/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,uBAAuB;;;;;;iBAOjC,CAAC;AAEJ,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;iBA8BpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,6BAA6B;;;;;iBAoBvC,CAAC;AAEJ,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAY5C,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,iCAAiC,CACzC,CAAC"}

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

@@ -0,0 +1,69 @@
+import { z } from "zod";
+// Open enum: known values listed for docs / TS autocomplete; string
+// fallback lets new server-side states (e.g. "paused") flow through
+// without breaking .parse() on the response.
+export const WorkflowRunStatusSchema = z
+    .union([
+    z.enum(["initialized", "started", "finished", "failed", "cancelled"]),
+    z.string(),
+])
+    .describe("Workflow run lifecycle status. `finished` / `failed` / `cancelled` are terminal.");
+export const WorkflowRunListItemSchema = 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. Null for runs created without a trigger."),
+    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. Null in rare edge cases."),
+    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)"),
+});
+export const ListWorkflowRunsOptionsSchema = z
+    .object({
+    workflow: z.string().uuid().describe("Durable workflow ID"),
+    pageSize: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe("Number of runs per page (max 100)"),
+    cursor: z.string().optional().describe("Pagination cursor"),
+    maxItems: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("Maximum total runs to return across all pages"),
+})
+    .describe("List workflow runs (triggered executions) for a specific deployed workflow, newest first");
+export const ListWorkflowRunsApiResponseSchema = z.object({
+    results: z.array(WorkflowRunListItemSchema),
+    meta: z.object({
+        limit: z.number(),
+        cursor: z.string().nullable().optional(),
+        next_cursor: z.string().nullable().optional(),
+    }),
+    links: z
+        .object({
+        next: z.string().nullable().optional(),
+    })
+        .optional(),
+});

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

@@ -16,9 +16,34 @@ export declare const listWorkflowVersionsPlugin: (sdk: {
     };
 } & {
     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;
+        current_version_id: string | null;
+        created_at: string;
+        updated_at: string;
+    }>;
+} & {
+    context: {
+        meta: {
+            listWorkflows: import("kitcore").PluginMeta<unknown>;
+        };
+    };
 } & {
     context: {
-        meta: Record<string, import("../../..").PluginMeta>;
+        meta: Record<string, import("kitcore").PluginMeta>;
     };
 }) => {
     listWorkflowVersions: (options?: ({
@@ -30,7 +55,7 @@ export declare const listWorkflowVersionsPlugin: (sdk: {
         cursor?: string;
         pageSize?: number;
         maxItems?: number;
-    }) | undefined) => import("../../..").PaginatedSdkResult<{
+    }) | undefined) => import("kitcore").PaginatedSdkResult<{
         id: string;
         workflow_id: string;
         zapier_durable_version: string;
@@ -41,7 +66,7 @@ export declare const listWorkflowVersionsPlugin: (sdk: {
 } & {
     context: {
         meta: {
-            listWorkflowVersions: import("../../..").PluginMeta;
+            listWorkflowVersions: import("kitcore").PluginMeta<unknown>;
         };
     };
 };

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/listWorkflowVersions/index.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCtC,CAAC;AAEF,MAAM,MAAM,kCAAkC,GAAG,UAAU,CACzD,OAAO,0BAA0B,CAClC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/listWorkflowVersions/index.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCtC,CAAC;AAEF,MAAM,MAAM,kCAAkC,GAAG,UAAU,CACzD,OAAO,0BAA0B,CAClC,CAAC"}

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

@@ -1,4 +1,4 @@
-import { definePlugin, createPaginatedPluginMethod, } from "../../../utils/plugin-utils";
+import { definePlugin, createPaginatedPluginMethod } from "kitcore";
 import { workflowIdResolver } from "../../../resolvers/workflowId";
 import { DEFAULT_PAGE_SIZE } from "../../../constants";
 import { codeSubstrateDefaults } from "../shared";