@zapier/zapier-sdk 0.77.0 → 0.77.2

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

@@ -1,150 +0,0 @@
-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;
-} & {
-    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>;
-    };
-}) => {
-    publishWorkflowVersion: (options?: {
-        workflow: string;
-        sourceFiles: Record<string, string>;
-        dependencies?: Record<string, string> | undefined;
-        zapierDurableVersion?: string | undefined;
-        zapier_durable_version?: string | undefined;
-        enabled?: boolean | undefined;
-        connections?: Record<string, {
-            connectionId?: string | number | undefined;
-            connection_id?: string | number | undefined;
-        }> | null | undefined;
-        appVersions?: Record<string, {
-            implementationName?: string | undefined;
-            implementation_name?: string | undefined;
-            version?: string | undefined;
-        }> | null | undefined;
-        app_versions?: Record<string, {
-            implementationName?: string | undefined;
-            implementation_name?: string | undefined;
-            version?: string | undefined;
-        }> | null | undefined;
-        trigger?: {
-            action: string;
-            selectedApi?: string | undefined;
-            selected_api?: string | undefined;
-            authenticationId?: string | null | undefined;
-            authentication_id?: string | null | undefined;
-            params?: Record<string, unknown> | undefined;
-        } | undefined;
-    } | {
-        workflow: string;
-        source_files: Record<string, string>;
-        dependencies?: Record<string, string> | undefined;
-        zapierDurableVersion?: string | undefined;
-        zapier_durable_version?: string | undefined;
-        enabled?: boolean | undefined;
-        connections?: Record<string, {
-            connectionId?: string | number | undefined;
-            connection_id?: string | number | undefined;
-        }> | null | undefined;
-        appVersions?: Record<string, {
-            implementationName?: string | undefined;
-            implementation_name?: string | undefined;
-            version?: string | undefined;
-        }> | null | undefined;
-        app_versions?: Record<string, {
-            implementationName?: string | undefined;
-            implementation_name?: string | undefined;
-            version?: string | undefined;
-        }> | null | undefined;
-        trigger?: {
-            action: string;
-            selectedApi?: string | undefined;
-            selected_api?: string | undefined;
-            authenticationId?: string | null | undefined;
-            authentication_id?: string | null | undefined;
-            params?: Record<string, unknown> | undefined;
-        } | 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;
-            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;
-        };
-    }>;
-} & {
-    context: {
-        meta: {
-            publishWorkflowVersion: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type PublishWorkflowVersionPluginProvides = ReturnType<typeof publishWorkflowVersionPlugin>;
-//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,80 +0,0 @@
-import { definePlugin, createPluginMethod } from "kitcore";
-import { ZapierValidationError } from "../../../types/errors";
-import { workflowIdResolver } from "../../../resolvers/workflowId";
-import { codeSubstrateDefaults, toWireConnections, toWireAppVersions, } from "../shared";
-import { PublishWorkflowVersionOptionsSchema, PublishWorkflowVersionResponseSchema, } from "./schemas";
-/**
- * Reshape the trigger config onto the wire body. `selectedApi` is the
- * camelCase locator (with a deprecated snake_case alias) and is required
- * when a trigger is configured, so a missing one is a client-side
- * validation error.
- */
-function toWireTrigger(trigger) {
-    const selectedApi = trigger.selectedApi ?? trigger.selected_api;
-    if (selectedApi === undefined) {
-        throw new ZapierValidationError("trigger is missing selectedApi");
-    }
-    const wire = {
-        selected_api: selectedApi,
-        action: trigger.action,
-    };
-    // Read with `in` so an explicit `null` (a no-auth trigger) is forwarded
-    // rather than collapsed into "omitted" by `??`.
-    if ("authenticationId" in trigger) {
-        wire.authentication_id = trigger.authenticationId;
-    }
-    else if ("authentication_id" in trigger) {
-        wire.authentication_id = trigger.authentication_id;
-    }
-    if (trigger.params !== undefined) {
-        wire.params = trigger.params;
-    }
-    return wire;
-}
-export const publishWorkflowVersionPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    ...codeSubstrateDefaults,
-    name: "publishWorkflowVersion",
-    type: "create",
-    itemType: "WorkflowVersion",
-    inputSchema: PublishWorkflowVersionOptionsSchema,
-    outputSchema: PublishWorkflowVersionResponseSchema,
-    resolvers: { workflow: workflowIdResolver },
-    handler: async ({ sdk, options }) => {
-        const sourceFiles = "sourceFiles" in options ? options.sourceFiles : options.source_files;
-        const zapierDurableVersion = options.zapierDurableVersion ?? options.zapier_durable_version;
-        // Read with `in` rather than `??` so an explicit `null` (clear the
-        // binding) survives and isn't collapsed into the deprecated alias.
-        const appVersions = "appVersions" in options ? options.appVersions : options.app_versions;
-        const body = { source_files: sourceFiles };
-        if (options.dependencies !== undefined) {
-            body.dependencies = options.dependencies;
-        }
-        if (zapierDurableVersion !== undefined) {
-            body.zapier_durable_version = zapierDurableVersion;
-        }
-        if (options.enabled !== undefined) {
-            body.enabled = options.enabled;
-        }
-        if (options.connections === null) {
-            body.connections = null;
-        }
-        else if (options.connections !== undefined) {
-            body.connections = toWireConnections(options.connections);
-        }
-        if (appVersions === null) {
-            body.app_versions = null;
-        }
-        else if (appVersions !== undefined) {
-            body.app_versions = toWireAppVersions(appVersions);
-        }
-        if (options.trigger !== undefined) {
-            body.trigger = toWireTrigger(options.trigger);
-        }
-        const raw = await sdk.context.api.post(`/durableworkflowzaps/api/v0/workflows/${encodeURIComponent(options.workflow)}/versions`, body, {
-            authRequired: true,
-            resource: { type: "workflow", id: options.workflow },
-        });
-        const data = PublishWorkflowVersionResponseSchema.parse(raw);
-        return { data };
-    },
-}));

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

@@ -1,158 +0,0 @@
-import { z } from "zod";
-declare const TriggerConfigSchema: z.ZodObject<{
-    selectedApi: z.ZodOptional<z.ZodString>;
-    selected_api: z.ZodOptional<z.ZodString>;
-    action: z.ZodString;
-    authenticationId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    authentication_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
-export type TriggerConfig = z.infer<typeof TriggerConfigSchema>;
-export declare const PublishWorkflowVersionSchema: z.ZodObject<{
-    workflow: z.ZodString;
-    sourceFiles: z.ZodRecord<z.ZodString, z.ZodString>;
-    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    zapierDurableVersion: z.ZodOptional<z.ZodString>;
-    zapier_durable_version: z.ZodOptional<z.ZodString>;
-    enabled: z.ZodOptional<z.ZodBoolean>;
-    connections: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
-        connectionId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString, z.ZodNumber]>>;
-        connection_id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString, z.ZodNumber]>>;
-    }, z.core.$strip>>>>;
-    appVersions: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
-        implementationName: z.ZodOptional<z.ZodString>;
-        implementation_name: z.ZodOptional<z.ZodString>;
-        version: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>>;
-    app_versions: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
-        implementationName: z.ZodOptional<z.ZodString>;
-        implementation_name: z.ZodOptional<z.ZodString>;
-        version: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>>;
-    trigger: z.ZodOptional<z.ZodObject<{
-        selectedApi: z.ZodOptional<z.ZodString>;
-        selected_api: z.ZodOptional<z.ZodString>;
-        action: z.ZodString;
-        authenticationId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        authentication_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-declare const PublishWorkflowVersionSchemaDeprecated: z.ZodObject<{
-    workflow: z.ZodString;
-    source_files: z.ZodRecord<z.ZodString, z.ZodString>;
-    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    zapierDurableVersion: z.ZodOptional<z.ZodString>;
-    zapier_durable_version: z.ZodOptional<z.ZodString>;
-    enabled: z.ZodOptional<z.ZodBoolean>;
-    connections: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
-        connectionId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString, z.ZodNumber]>>;
-        connection_id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString, z.ZodNumber]>>;
-    }, z.core.$strip>>>>;
-    appVersions: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
-        implementationName: z.ZodOptional<z.ZodString>;
-        implementation_name: z.ZodOptional<z.ZodString>;
-        version: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>>;
-    app_versions: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
-        implementationName: z.ZodOptional<z.ZodString>;
-        implementation_name: z.ZodOptional<z.ZodString>;
-        version: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>>;
-    trigger: z.ZodOptional<z.ZodObject<{
-        selectedApi: z.ZodOptional<z.ZodString>;
-        selected_api: z.ZodOptional<z.ZodString>;
-        action: z.ZodString;
-        authenticationId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        authentication_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const PublishWorkflowVersionOptionsSchema: z.ZodUnion<readonly [z.ZodObject<{
-    workflow: z.ZodString;
-    sourceFiles: z.ZodRecord<z.ZodString, z.ZodString>;
-    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    zapierDurableVersion: z.ZodOptional<z.ZodString>;
-    zapier_durable_version: z.ZodOptional<z.ZodString>;
-    enabled: z.ZodOptional<z.ZodBoolean>;
-    connections: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
-        connectionId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString, z.ZodNumber]>>;
-        connection_id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString, z.ZodNumber]>>;
-    }, z.core.$strip>>>>;
-    appVersions: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
-        implementationName: z.ZodOptional<z.ZodString>;
-        implementation_name: z.ZodOptional<z.ZodString>;
-        version: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>>;
-    app_versions: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
-        implementationName: z.ZodOptional<z.ZodString>;
-        implementation_name: z.ZodOptional<z.ZodString>;
-        version: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>>;
-    trigger: z.ZodOptional<z.ZodObject<{
-        selectedApi: z.ZodOptional<z.ZodString>;
-        selected_api: z.ZodOptional<z.ZodString>;
-        action: z.ZodString;
-        authenticationId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        authentication_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    workflow: z.ZodString;
-    source_files: z.ZodRecord<z.ZodString, z.ZodString>;
-    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    zapierDurableVersion: z.ZodOptional<z.ZodString>;
-    zapier_durable_version: z.ZodOptional<z.ZodString>;
-    enabled: z.ZodOptional<z.ZodBoolean>;
-    connections: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
-        connectionId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString, z.ZodNumber]>>;
-        connection_id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString, z.ZodNumber]>>;
-    }, z.core.$strip>>>>;
-    appVersions: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
-        implementationName: z.ZodOptional<z.ZodString>;
-        implementation_name: z.ZodOptional<z.ZodString>;
-        version: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>>;
-    app_versions: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
-        implementationName: z.ZodOptional<z.ZodString>;
-        implementation_name: z.ZodOptional<z.ZodString>;
-        version: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>>;
-    trigger: z.ZodOptional<z.ZodObject<{
-        selectedApi: z.ZodOptional<z.ZodString>;
-        selected_api: z.ZodOptional<z.ZodString>;
-        action: z.ZodString;
-        authenticationId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        authentication_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>]>;
-export type PublishWorkflowVersionOptions = z.infer<typeof PublishWorkflowVersionSchema> | (Omit<z.infer<typeof PublishWorkflowVersionSchemaDeprecated>, "source_files"> & {
-    /** @deprecated Use `sourceFiles` instead. */
-    source_files: z.infer<typeof PublishWorkflowVersionSchemaDeprecated>["source_files"];
-});
-export declare const PublishWorkflowVersionResponseSchema: 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 PublishWorkflowVersionResponse = z.infer<typeof PublishWorkflowVersionResponseSchema>;
-export {};
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/publishWorkflowVersion/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAmBxB,QAAA,MAAM,mBAAmB;;;;;;;iBA0BtB,CAAC;AAEJ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAyDhE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAarC,CAAC;AAGL,QAAA,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKF,CAAC;AAG3C,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAEF,CAAC;AAE/C,MAAM,MAAM,6BAA6B,GACrC,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,GAC5C,CAAC,IAAI,CACH,CAAC,CAAC,KAAK,CAAC,OAAO,sCAAsC,CAAC,EACtD,cAAc,CACf,GAAG;IACF,6CAA6C;IAC7C,YAAY,EAAE,CAAC,CAAC,KAAK,CACnB,OAAO,sCAAsC,CAC9C,CAAC,cAAc,CAAC,CAAC;CACnB,CAAC,CAAC;AAEP,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;iBA8B/C,CAAC;AAEH,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,oCAAoC,CAC5C,CAAC"}

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

@@ -1,124 +0,0 @@
-import { z } from "zod";
-import { AppVersionBindingSchema as AppVersionBindingInputSchema, ConnectionBindingSchema as ConnectionBindingInputSchema, SourceFilesSchema, } from "../shared";
-import { AppVersionBindingSchema, ConnectionBindingSchema, WorkflowVersionTriggerConfigSchema, } from "../shared-schemas";
-// `selectedApi` is conceptually required when a trigger is configured, but it
-// coexists with its deprecated snake_case alias. AGENTS.md rule 9 prescribes a
-// union schema for a required renamed param; here we deliberately diverge —
-// a union nested inside `trigger` would drop `.shape`, which the docs
-// generator needs to render the trigger's fields. Instead both names are
-// optional (so `.shape` survives, snake_case stays hidden via `deprecated`)
-// and `toWireTrigger` enforces that one is present.
-const TriggerConfigSchema = z
-    .object({
-    selectedApi: z
-        .string()
-        .optional()
-        .describe("Zapier app/API identifier (e.g. 'GoogleSheetsAPI'). Required when a trigger is configured."),
-    /** @deprecated Use `selectedApi` instead. */
-    selected_api: z.string().optional().meta({ deprecated: true }),
-    action: z.string().describe("Trigger action key (e.g. 'new_row')"),
-    authenticationId: z
-        .string()
-        .nullish()
-        .describe("Connection ID for the trigger source. Omit or pass null for no-auth triggers (e.g. Schedule by Zapier)."),
-    /** @deprecated Use `authenticationId` instead. */
-    authentication_id: z.string().nullish().meta({ deprecated: true }),
-    params: z
-        .record(z.string(), z.unknown())
-        .optional()
-        .describe("Trigger parameters as a JSON object"),
-})
-    .describe("Zapier trigger configuration. When set, the workflow subscribes to trigger events.");
-const PublishWorkflowVersionDescription = "Publish a new version of a durable workflow. Enables the workflow by default.";
-// Shared, non-renamed properties for both the canonical and deprecated
-// `sourceFiles` variants. `workflow` and `sourceFiles` live on the variant
-// objects (not here) so they stay the leading keys — the CLI derives
-// positional args from key order, and the original order is
-// `<workflow> <source-files>`.
-const PublishWorkflowVersionBaseSchema = z.object({
-    dependencies: z
-        .record(z.string(), z.string())
-        .optional()
-        .describe("Optional npm package dependencies"),
-    zapierDurableVersion: z
-        .string()
-        .optional()
-        .describe('Exact semver of @zapier/zapier-durable to use (e.g. "1.2.3"). Defaults to server-configured version if omitted.'),
-    /** @deprecated Use `zapierDurableVersion` instead. */
-    zapier_durable_version: z.string().optional().meta({ deprecated: true }),
-    enabled: z
-        .boolean()
-        .optional()
-        .describe("Enable the workflow after publishing. Defaults to true; pass false to publish without enabling."),
-    connections: z
-        .record(z.string(), ConnectionBindingInputSchema)
-        .nullish()
-        .describe("Map of connection aliases to Zapier connections used by the workflow. Pass `null` to clear an existing binding."),
-    appVersions: z
-        .record(z.string(), AppVersionBindingInputSchema)
-        .nullish()
-        .describe("Map of app keys to pinned app implementation/version used by the workflow. Pass `null` to clear an existing binding."),
-    /** @deprecated Use `appVersions` instead. */
-    app_versions: z
-        .record(z.string(), AppVersionBindingInputSchema)
-        .nullish()
-        .meta({ deprecated: true }),
-    trigger: TriggerConfigSchema.optional().describe("Trigger configuration. When provided, the workflow subscribes to a Zapier trigger; omit for webhook-only workflows."),
-});
-const WorkflowPropertySchema = z
-    .string()
-    .uuid()
-    .describe("Durable workflow ID");
-// Canonical schema (new names only) — drives docs, CLI help, and the registry.
-export const PublishWorkflowVersionSchema = z
-    .object({
-    workflow: WorkflowPropertySchema,
-    sourceFiles: SourceFilesSchema,
-})
-    .merge(PublishWorkflowVersionBaseSchema)
-    .describe(PublishWorkflowVersionDescription)
-    .meta({
-    aliases: {
-        source_files: "sourceFiles",
-        zapier_durable_version: "zapierDurableVersion",
-        app_versions: "appVersions",
-    },
-});
-// Deprecated schema (backward compat) — keeps the old `source_files` name valid.
-const PublishWorkflowVersionSchemaDeprecated = z
-    .object({
-    workflow: WorkflowPropertySchema,
-    source_files: SourceFilesSchema,
-})
-    .merge(PublishWorkflowVersionBaseSchema);
-// Union for runtime validation: accepts either the canonical or the old name.
-export const PublishWorkflowVersionOptionsSchema = z
-    .union([PublishWorkflowVersionSchema, PublishWorkflowVersionSchemaDeprecated])
-    .describe(PublishWorkflowVersionDescription);
-export const PublishWorkflowVersionResponseSchema = 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)"),
-    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)."),
-});

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

@@ -1,94 +0,0 @@
-export declare const runDurablePlugin: (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>;
-    };
-}) => {
-    runDurable: (options?: {
-        sourceFiles: Record<string, string>;
-        input?: unknown;
-        dependencies?: Record<string, string> | undefined;
-        zapierDurableVersion?: string | undefined;
-        zapier_durable_version?: string | undefined;
-        connections?: Record<string, {
-            connectionId?: string | number | undefined;
-            connection_id?: string | number | undefined;
-        }> | undefined;
-        appVersions?: Record<string, {
-            implementationName?: string | undefined;
-            implementation_name?: string | undefined;
-            version?: string | undefined;
-        }> | undefined;
-        app_versions?: Record<string, {
-            implementationName?: string | undefined;
-            implementation_name?: string | undefined;
-            version?: string | undefined;
-        }> | undefined;
-        private?: boolean | undefined;
-        notifications?: {
-            url: string;
-            events: ("error" | "started" | "cancelled" | "completed" | "progress")[];
-            type?: "webhook" | undefined;
-            max_retries?: number | undefined;
-        }[] | undefined;
-    } | {
-        source_files: Record<string, string>;
-        input?: unknown;
-        dependencies?: Record<string, string> | undefined;
-        zapierDurableVersion?: string | undefined;
-        zapier_durable_version?: string | undefined;
-        connections?: Record<string, {
-            connectionId?: string | number | undefined;
-            connection_id?: string | number | undefined;
-        }> | undefined;
-        appVersions?: Record<string, {
-            implementationName?: string | undefined;
-            implementation_name?: string | undefined;
-            version?: string | undefined;
-        }> | undefined;
-        app_versions?: Record<string, {
-            implementationName?: string | undefined;
-            implementation_name?: string | undefined;
-            version?: string | undefined;
-        }> | undefined;
-        private?: boolean | undefined;
-        notifications?: {
-            url: string;
-            events: ("error" | "started" | "cancelled" | "completed" | "progress")[];
-            type?: "webhook" | undefined;
-            max_retries?: number | undefined;
-        }[] | undefined;
-    } | undefined) => Promise<{
-        data: {
-            id: string;
-            status: "initialized";
-            is_private: boolean;
-            created_at: string;
-        };
-    }>;
-} & {
-    context: {
-        meta: {
-            runDurable: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type RunDurablePluginProvides = ReturnType<typeof runDurablePlugin>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/runDurable/index.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgD5B,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

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

@@ -1,41 +0,0 @@
-import { definePlugin, createPluginMethod } from "kitcore";
-import { codeSubstrateDefaults, toWireConnections, toWireAppVersions, } from "../shared";
-import { RunDurableOptionsSchema, RunDurableResponseSchema } from "./schemas";
-export const runDurablePlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    ...codeSubstrateDefaults,
-    name: "runDurable",
-    type: "create",
-    itemType: "DurableRun",
-    inputSchema: RunDurableOptionsSchema,
-    outputSchema: RunDurableResponseSchema,
-    handler: async ({ sdk, options }) => {
-        const sourceFiles = "sourceFiles" in options ? options.sourceFiles : options.source_files;
-        const zapierDurableVersion = options.zapierDurableVersion ?? options.zapier_durable_version;
-        const appVersions = options.appVersions ?? options.app_versions;
-        const body = { source_files: sourceFiles };
-        if (options.input !== undefined) {
-            body.input = options.input;
-        }
-        if (options.dependencies !== undefined) {
-            body.dependencies = options.dependencies;
-        }
-        if (zapierDurableVersion !== undefined) {
-            body.zapier_durable_version = zapierDurableVersion;
-        }
-        if (options.connections !== undefined) {
-            body.connections = toWireConnections(options.connections);
-        }
-        if (appVersions !== undefined) {
-            body.app_versions = toWireAppVersions(appVersions);
-        }
-        if (options.private !== undefined) {
-            body.is_private = options.private;
-        }
-        if (options.notifications !== undefined) {
-            body.notifications = options.notifications;
-        }
-        const raw = await sdk.context.api.post("/sdkdurableapi/api/v0/runs", body, { authRequired: true });
-        const data = RunDurableResponseSchema.parse(raw);
-        return { data };
-    },
-}));