@zapier/zapier-sdk 0.63.0 → 0.65.0

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

@@ -0,0 +1,46 @@
+export declare const getWorkflowVersionPlugin: (sdk: {
+    context: {
+        api: import("../../..").ApiClient;
+        resolveCredentials: () => Promise<string | {
+            clientId: string;
+            clientSecret: string;
+            type?: "client_credentials" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | {
+            clientId: string;
+            type?: "pkce" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | undefined>;
+    };
+} & {
+    context: import("../../eventEmission").EventEmissionContext;
+} & {
+    context: {
+        meta: Record<string, import("../../..").PluginMeta>;
+    };
+}) => {
+    getWorkflowVersion: (options?: {
+        workflow: string;
+        version: string;
+    } | undefined) => Promise<{
+        data: {
+            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;
+        };
+    }>;
+} & {
+    context: {
+        meta: {
+            getWorkflowVersion: import("../../..").PluginMeta;
+        };
+    };
+};
+export type GetWorkflowVersionPluginProvides = ReturnType<typeof getWorkflowVersionPlugin>;
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,25 @@
+import { definePlugin, createPluginMethod } from "../../../utils/plugin-utils";
+import { workflowIdResolver } from "../../../resolvers/workflowId";
+import { workflowVersionIdResolver } from "../../../resolvers/workflowVersionId";
+import { codeSubstrateDefaults } from "../shared";
+import { GetWorkflowVersionOptionsSchema, GetWorkflowVersionResponseSchema, } from "./schemas";
+export const getWorkflowVersionPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
+    ...codeSubstrateDefaults,
+    name: "getWorkflowVersion",
+    type: "item",
+    itemType: "WorkflowVersion",
+    inputSchema: GetWorkflowVersionOptionsSchema,
+    outputSchema: GetWorkflowVersionResponseSchema,
+    resolvers: {
+        workflow: workflowIdResolver,
+        version: workflowVersionIdResolver,
+    },
+    handler: async ({ sdk, options }) => {
+        const raw = await sdk.context.api.get(`/durableworkflowzaps/api/v0/workflows/${encodeURIComponent(options.workflow)}/versions/${encodeURIComponent(options.version)}`, {
+            authRequired: true,
+            resource: { type: "workflow-version", id: options.version },
+        });
+        const data = GetWorkflowVersionResponseSchema.parse(raw);
+        return { data };
+    },
+}));

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

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export declare const GetWorkflowVersionOptionsSchema: z.ZodObject<{
+    workflow: z.ZodString;
+    version: z.ZodString;
+}, z.core.$strip>;
+export type GetWorkflowVersionOptions = z.infer<typeof GetWorkflowVersionOptionsSchema>;
+export declare const GetWorkflowVersionResponseSchema: 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;
+}, z.core.$strip>;
+export type GetWorkflowVersionResponse = z.infer<typeof GetWorkflowVersionResponseSchema>;
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/getWorkflowVersion/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,+BAA+B;;;iBAKgC,CAAC;AAE7E,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;iBAmB3C,CAAC;AAEH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC"}

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

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export const GetWorkflowVersionOptionsSchema = z
+    .object({
+    workflow: z.string().uuid().describe("Durable workflow ID"),
+    version: z.string().uuid().describe("Workflow version ID"),
+})
+    .describe("Get full details of a workflow version including source files");
+export const GetWorkflowVersionResponseSchema = z.object({
+    id: z.string().describe("Workflow version ID (UUID)"),
+    workflow_id: z.string().describe("Parent workflow ID (UUID)"),
+    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)"),
+    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)"),
+});

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

@@ -0,0 +1,53 @@
+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;
+} & {
+    context: {
+        meta: Record<string, import("../../..").PluginMeta>;
+    };
+}) => {
+    listWorkflowRuns: (options?: ({
+        workflow: string;
+        pageSize?: number | undefined;
+        cursor?: string | undefined;
+        maxItems?: number | undefined;
+    } & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("../../..").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("../../..").PluginMeta;
+        };
+    };
+};
+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":"AAeA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkClC,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 "../../../utils/plugin-utils";
+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

@@ -0,0 +1,49 @@
+export declare const listWorkflowVersionsPlugin: (sdk: {
+    context: {
+        api: import("../../..").ApiClient;
+        resolveCredentials: () => Promise<string | {
+            clientId: string;
+            clientSecret: string;
+            type?: "client_credentials" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | {
+            clientId: string;
+            type?: "pkce" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | undefined>;
+    };
+} & {
+    context: import("../../eventEmission").EventEmissionContext;
+} & {
+    context: {
+        meta: Record<string, import("../../..").PluginMeta>;
+    };
+}) => {
+    listWorkflowVersions: (options?: ({
+        workflow: string;
+        pageSize?: number | undefined;
+        cursor?: string | undefined;
+        maxItems?: number | undefined;
+    } & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("../../..").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("../../..").PluginMeta;
+        };
+    };
+};
+export type ListWorkflowVersionsPluginProvides = ReturnType<typeof listWorkflowVersionsPlugin>;
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,34 @@
+import { definePlugin, createPaginatedPluginMethod, } from "../../../utils/plugin-utils";
+import { workflowIdResolver } from "../../../resolvers/workflowId";
+import { DEFAULT_PAGE_SIZE } from "../../../constants";
+import { codeSubstrateDefaults } from "../shared";
+import { ListWorkflowVersionsApiResponseSchema, ListWorkflowVersionsOptionsSchema, WorkflowVersionListItemSchema, } from "./schemas";
+export const listWorkflowVersionsPlugin = definePlugin((sdk) => createPaginatedPluginMethod(sdk, {
+    ...codeSubstrateDefaults,
+    name: "listWorkflowVersions",
+    type: "list",
+    itemType: "WorkflowVersion",
+    inputSchema: ListWorkflowVersionsOptionsSchema,
+    outputSchema: WorkflowVersionListItemSchema,
+    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)}/versions`, {
+            searchParams,
+            authRequired: true,
+            resource: { type: "workflow", id: options.workflow },
+        });
+        const response = ListWorkflowVersionsApiResponseSchema.parse(raw);
+        return {
+            data: response.results,
+            nextCursor: response.meta.next_cursor ?? undefined,
+        };
+    },
+}));

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

@@ -0,0 +1,37 @@
+import { z } from "zod";
+export declare const WorkflowVersionListItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    workflow_id: 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;
+}, z.core.$strip>;
+export type WorkflowVersionListItem = z.infer<typeof WorkflowVersionListItemSchema>;
+export declare const ListWorkflowVersionsOptionsSchema: 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 ListWorkflowVersionsOptions = z.infer<typeof ListWorkflowVersionsOptionsSchema>;
+export declare const ListWorkflowVersionsApiResponseSchema: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        workflow_id: 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;
+    }, 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 ListWorkflowVersionsApiResponse = z.infer<typeof ListWorkflowVersionsApiResponseSchema>;
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/listWorkflowVersions/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,6BAA6B;;;;;;;iBAgBxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;;;iBAkBqB,CAAC;AAEpE,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,iCAAiC,CACzC,CAAC;AAEF,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;iBAYhD,CAAC;AAEH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CACnD,OAAO,qCAAqC,CAC7C,CAAC"}

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

@@ -0,0 +1,48 @@
+import { z } from "zod";
+export const WorkflowVersionListItemSchema = z.object({
+    id: z.string().describe("Workflow version ID (UUID)"),
+    workflow_id: z.string().describe("Parent workflow ID (UUID)"),
+    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)"),
+    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)"),
+});
+export const ListWorkflowVersionsOptionsSchema = z
+    .object({
+    workflow: z.string().uuid().describe("Durable workflow ID"),
+    pageSize: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe("Number of versions per page (max 100)"),
+    cursor: z.string().optional().describe("Pagination cursor"),
+    maxItems: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("Maximum total versions to return across all pages"),
+})
+    .describe("List published versions for a workflow, newest first");
+export const ListWorkflowVersionsApiResponseSchema = z.object({
+    results: z.array(WorkflowVersionListItemSchema),
+    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/publishWorkflowVersion/index.d.ts

@@ -0,0 +1,49 @@
+export declare const publishWorkflowVersionPlugin: (sdk: {
+    context: {
+        api: import("../../..").ApiClient;
+        resolveCredentials: () => Promise<string | {
+            clientId: string;
+            clientSecret: string;
+            type?: "client_credentials" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | {
+            clientId: string;
+            type?: "pkce" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | undefined>;
+    };
+} & {
+    context: import("../../eventEmission").EventEmissionContext;
+} & {
+    context: {
+        meta: Record<string, import("../../..").PluginMeta>;
+    };
+}) => {
+    publishWorkflowVersion: (options?: {
+        workflow: string;
+        source_files: Record<string, string>;
+        dependencies?: Record<string, string> | undefined;
+        zapier_durable_version?: string | undefined;
+        enabled?: boolean | undefined;
+    } | undefined) => Promise<{
+        data: {
+            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;
+        };
+    }>;
+} & {
+    context: {
+        meta: {
+            publishWorkflowVersion: import("../../..").PluginMeta;
+        };
+    };
+};
+export type PublishWorkflowVersionPluginProvides = ReturnType<typeof publishWorkflowVersionPlugin>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/publishWorkflowVersion/index.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCxC,CAAC;AAEF,MAAM,MAAM,oCAAoC,GAAG,UAAU,CAC3D,OAAO,4BAA4B,CACpC,CAAC"}