@zapier/zapier-sdk 0.77.0 → 0.77.2

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

@@ -1,149 +0,0 @@
-import { z } from "zod";
-export declare const RunDurableSchema: z.ZodObject<{
-    sourceFiles: z.ZodRecord<z.ZodString, z.ZodString>;
-    input: z.ZodOptional<z.ZodUnknown>;
-    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    zapierDurableVersion: z.ZodOptional<z.ZodString>;
-    zapier_durable_version: z.ZodOptional<z.ZodString>;
-    connections: z.ZodOptional<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.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.ZodRecord<z.ZodString, z.ZodObject<{
-        implementationName: z.ZodOptional<z.ZodString>;
-        implementation_name: z.ZodOptional<z.ZodString>;
-        version: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    private: z.ZodOptional<z.ZodBoolean>;
-    notifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        type: z.ZodOptional<z.ZodLiteral<"webhook">>;
-        url: z.ZodString;
-        max_retries: z.ZodOptional<z.ZodNumber>;
-        events: z.ZodArray<z.ZodEnum<{
-            error: "error";
-            started: "started";
-            cancelled: "cancelled";
-            completed: "completed";
-            progress: "progress";
-        }>>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-declare const RunDurableSchemaDeprecated: z.ZodObject<{
-    source_files: z.ZodRecord<z.ZodString, z.ZodString>;
-    input: z.ZodOptional<z.ZodUnknown>;
-    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    zapierDurableVersion: z.ZodOptional<z.ZodString>;
-    zapier_durable_version: z.ZodOptional<z.ZodString>;
-    connections: z.ZodOptional<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.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.ZodRecord<z.ZodString, z.ZodObject<{
-        implementationName: z.ZodOptional<z.ZodString>;
-        implementation_name: z.ZodOptional<z.ZodString>;
-        version: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    private: z.ZodOptional<z.ZodBoolean>;
-    notifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        type: z.ZodOptional<z.ZodLiteral<"webhook">>;
-        url: z.ZodString;
-        max_retries: z.ZodOptional<z.ZodNumber>;
-        events: z.ZodArray<z.ZodEnum<{
-            error: "error";
-            started: "started";
-            cancelled: "cancelled";
-            completed: "completed";
-            progress: "progress";
-        }>>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export declare const RunDurableOptionsSchema: z.ZodUnion<readonly [z.ZodObject<{
-    sourceFiles: z.ZodRecord<z.ZodString, z.ZodString>;
-    input: z.ZodOptional<z.ZodUnknown>;
-    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    zapierDurableVersion: z.ZodOptional<z.ZodString>;
-    zapier_durable_version: z.ZodOptional<z.ZodString>;
-    connections: z.ZodOptional<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.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.ZodRecord<z.ZodString, z.ZodObject<{
-        implementationName: z.ZodOptional<z.ZodString>;
-        implementation_name: z.ZodOptional<z.ZodString>;
-        version: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    private: z.ZodOptional<z.ZodBoolean>;
-    notifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        type: z.ZodOptional<z.ZodLiteral<"webhook">>;
-        url: z.ZodString;
-        max_retries: z.ZodOptional<z.ZodNumber>;
-        events: z.ZodArray<z.ZodEnum<{
-            error: "error";
-            started: "started";
-            cancelled: "cancelled";
-            completed: "completed";
-            progress: "progress";
-        }>>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>, z.ZodObject<{
-    source_files: z.ZodRecord<z.ZodString, z.ZodString>;
-    input: z.ZodOptional<z.ZodUnknown>;
-    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    zapierDurableVersion: z.ZodOptional<z.ZodString>;
-    zapier_durable_version: z.ZodOptional<z.ZodString>;
-    connections: z.ZodOptional<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.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.ZodRecord<z.ZodString, z.ZodObject<{
-        implementationName: z.ZodOptional<z.ZodString>;
-        implementation_name: z.ZodOptional<z.ZodString>;
-        version: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    private: z.ZodOptional<z.ZodBoolean>;
-    notifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        type: z.ZodOptional<z.ZodLiteral<"webhook">>;
-        url: z.ZodString;
-        max_retries: z.ZodOptional<z.ZodNumber>;
-        events: z.ZodArray<z.ZodEnum<{
-            error: "error";
-            started: "started";
-            cancelled: "cancelled";
-            completed: "completed";
-            progress: "progress";
-        }>>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>]>;
-export type RunDurableOptions = z.infer<typeof RunDurableSchema> | (Omit<z.infer<typeof RunDurableSchemaDeprecated>, "source_files"> & {
-    /** @deprecated Use `sourceFiles` instead. */
-    source_files: z.infer<typeof RunDurableSchemaDeprecated>["source_files"];
-});
-export declare const RunDurableResponseSchema: z.ZodObject<{
-    id: z.ZodString;
-    status: z.ZodLiteral<"initialized">;
-    is_private: z.ZodBoolean;
-    created_at: z.ZodString;
-}, z.core.$strip>;
-export type RunDurableResponse = z.infer<typeof RunDurableResponseSchema>;
-export {};
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/runDurable/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA0FxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUzB,CAAC;AAGL,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEF,CAAC;AAG/B,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAEF,CAAC;AAEnC,MAAM,MAAM,iBAAiB,GACzB,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,GAChC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,EAAE,cAAc,CAAC,GAAG;IAClE,6CAA6C;IAC7C,YAAY,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC,cAAc,CAAC,CAAC;CAC1E,CAAC,CAAC;AAEP,eAAO,MAAM,wBAAwB;;;;;iBAanC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

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

@@ -1,95 +0,0 @@
-import { z } from "zod";
-import { AppVersionBindingSchema, ConnectionBindingSchema, SourceFilesSchema, } from "../shared";
-const RunNotificationEventSchema = z
-    .enum(["started", "progress", "completed", "error", "cancelled"])
-    .describe("Run lifecycle event this notification subscribes to");
-const RunNotificationSchema = z
-    .object({
-    type: z
-        .literal("webhook")
-        .optional()
-        .describe("Notification transport. Webhook is the only supported type."),
-    url: z
-        .string()
-        .url()
-        .describe("URL to POST event notifications to. Payload is `{run_id, event}`."),
-    max_retries: z
-        .number()
-        .int()
-        .min(0)
-        .max(10)
-        .optional()
-        .describe("Max delivery attempts with exponential backoff. Defaults to 3 server-side."),
-    events: z
-        .array(RunNotificationEventSchema)
-        .min(1)
-        .describe("One or more lifecycle events to subscribe this URL to."),
-})
-    .describe("Webhook subscriber for run lifecycle events. Server POSTs `{run_id, event}` on each subscribed transition.");
-// Shared, non-renamed properties. Lives in its own object so the canonical
-// and deprecated `sourceFiles` variants can merge it without repetition.
-const RunDurableBaseSchema = z.object({
-    input: z.unknown().optional().describe("Input data passed to the run"),
-    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 }),
-    connections: z
-        .record(z.string(), ConnectionBindingSchema)
-        .optional()
-        .describe('Named connection aliases. Maps each alias to an object holding its Zapier connection ID, e.g. `{ "slack": { "connectionId": "123" } }`.'),
-    appVersions: z
-        .record(z.string(), AppVersionBindingSchema)
-        .optional()
-        .describe("Pinned app versions. Maps app keys (slugs) to implementation names and versions."),
-    /** @deprecated Use `appVersions` instead. */
-    app_versions: z
-        .record(z.string(), AppVersionBindingSchema)
-        .optional()
-        .meta({ deprecated: true }),
-    private: z
-        .boolean()
-        .optional()
-        .describe("Only the creating user can see the run (default false)"),
-    notifications: z
-        .array(RunNotificationSchema)
-        .optional()
-        .describe("Webhook subscribers for run lifecycle events. Each entry specifies a URL and the events it subscribes to."),
-});
-const RunDurableDescription = "Run a workflow source file as a run-once durable run on sdkdurableapi (no deployed workflow required). Returns the run ID immediately; poll via getDurableRun for terminal status.";
-// Canonical schema (new names only) — drives docs, CLI help, and the registry.
-export const RunDurableSchema = z
-    .object({ sourceFiles: SourceFilesSchema })
-    .merge(RunDurableBaseSchema)
-    .describe(RunDurableDescription)
-    .meta({
-    aliases: {
-        source_files: "sourceFiles",
-        zapier_durable_version: "zapierDurableVersion",
-        app_versions: "appVersions",
-    },
-});
-// Deprecated schema (backward compat) — keeps the old `source_files` name valid.
-const RunDurableSchemaDeprecated = z
-    .object({ source_files: SourceFilesSchema })
-    .merge(RunDurableBaseSchema);
-// Union for runtime validation: accepts either the canonical or the old name.
-export const RunDurableOptionsSchema = z
-    .union([RunDurableSchema, RunDurableSchemaDeprecated])
-    .describe(RunDurableDescription);
-export const RunDurableResponseSchema = z.object({
-    id: z.string().describe("Run ID (UUID) — server-generated, time-sortable"),
-    status: z
-        .literal("initialized")
-        .describe("Always `initialized` on creation. Poll via getDurableRun to observe the run advancing to `started` / `finished` / `failed` / `cancelled`."),
-    is_private: z
-        .boolean()
-        .describe("When true, the run is visible only to the creating user; otherwise visible across the account."),
-    created_at: z.string().describe("When the run was created (ISO-8601)"),
-});

package/dist/plugins/codeSubstrate/shared-schemas.d.ts

@@ -1,41 +0,0 @@
-import { z } from "zod";
-export declare const ConnectionBindingSchema: z.ZodObject<{
-    connection_id: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodString]>;
-}, z.core.$strip>;
-export declare const AppVersionBindingSchema: z.ZodObject<{
-    implementation_name: z.ZodString;
-    version: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const WorkflowVersionTriggerConfigSchema: 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>;
-export declare const WorkflowTriggerStatusSchema: z.ZodEnum<{
-    failed: "failed";
-    pending: "pending";
-    active: "active";
-    unclaimed: "unclaimed";
-    releasing: "releasing";
-    released: "released";
-}>;
-export declare const WorkflowDisabledReasonSchema: z.ZodEnum<{
-    trigger_claim_failed: "trigger_claim_failed";
-}>;
-export declare const WorkflowTriggerSchema: 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>;
-//# sourceMappingURL=shared-schemas.d.ts.map

package/dist/plugins/codeSubstrate/shared-schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shared-schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/codeSubstrate/shared-schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,uBAAuB;;iBAcjC,CAAC;AAEJ,eAAO,MAAM,uBAAuB;;;iBAUsC,CAAC;AAK3E,eAAO,MAAM,kCAAkC;;;;;iBAiBsB,CAAC;AAItE,eAAO,MAAM,2BAA2B;;;;;;;EAOtC,CAAC;AAOH,eAAO,MAAM,4BAA4B;;EAAmC,CAAC;AAE7E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;iBAgC/B,CAAC"}

package/dist/plugins/codeSubstrate/shared-schemas.js

@@ -1,83 +0,0 @@
-import { z } from "zod";
-export const ConnectionBindingSchema = z
-    .object({
-    connection_id: z
-        .union([
-        z.number().int().positive(),
-        z.string().regex(/^[1-9][0-9]*$/, "must be a positive integer string"),
-        z.string().uuid("must be a UUID"),
-    ])
-        .describe("Zapier connection ID. Positive integer (legacy) or UUID string (newer)."),
-})
-    .describe("Connection binding: maps a single alias to a concrete connection.");
-export const AppVersionBindingSchema = z
-    .object({
-    implementation_name: z
-        .string()
-        .describe("App implementation identifier (e.g. 'SlackCLIAPI')"),
-    version: z
-        .string()
-        .optional()
-        .describe("App implementation version (e.g. '1.27.1')"),
-})
-    .describe("App-version binding: maps a single alias to an app version.");
-// Workflow-version trigger config. Same shape on the request and response
-// sides (CreateWorkflowVersionRequest.trigger and
-// WorkflowVersion.trigger / WorkflowVersionSummary.trigger).
-export const WorkflowVersionTriggerConfigSchema = z
-    .object({
-    selected_api: z
-        .string()
-        .describe("Zapier app/API identifier (e.g. 'GoogleSheetsAPI')"),
-    action: z.string().describe("Trigger action key (e.g. 'new_row')"),
-    authentication_id: z
-        .string()
-        .nullish()
-        .describe("Connection ID for the trigger source. Omit or pass null for no-auth triggers (e.g. Schedule by Zapier)."),
-    params: z
-        .record(z.string(), z.unknown())
-        .optional()
-        .describe("Trigger parameters as a JSON object"),
-})
-    .describe("Trigger configuration persisted on a workflow version.");
-// Workflow.triggers[] entries. Carries everything the version trigger
-// does plus a live claim-status enum.
-export const WorkflowTriggerStatusSchema = z.enum([
-    "unclaimed",
-    "pending",
-    "active",
-    "releasing",
-    "released",
-    "failed",
-]);
-// Why a workflow is currently off. `trigger_claim_failed` is a system
-// auto-disable; null/absent means the workflow was not system-disabled.
-// Independent of the per-trigger claim status+error: a post-active claim
-// failure (e.g. auth) leaves the workflow enabled with disabled_reason null
-// but its trigger status=failed, so the two signals must not be collapsed.
-export const WorkflowDisabledReasonSchema = z.enum(["trigger_claim_failed"]);
-export const WorkflowTriggerSchema = z
-    .object({
-    selected_api: z
-        .string()
-        .describe("Zapier app/API identifier (e.g. 'GoogleSheetsAPI')"),
-    action: z.string().describe("Trigger action key (e.g. 'new_row')"),
-    authentication_id: z
-        .string()
-        .nullish()
-        .describe("Connection ID for the trigger source. Null for no-auth triggers."),
-    params: z
-        .record(z.string(), z.unknown())
-        .optional()
-        .describe("Trigger parameters as a JSON object"),
-    status: WorkflowTriggerStatusSchema.describe("Live trigger claim status — whether the trigger is currently subscribed to its source."),
-    // Optional until COSUB-630 ships the field server-side; afterwards the API
-    // always sends it (null unless status=failed). Already sanitized at write
-    // time — surface verbatim.
-    error: z
-        .string()
-        .nullable()
-        .optional()
-        .describe("Failure reason for the latest claim. Present (non-null) only when status is 'failed'."),
-})
-    .describe("Trigger from a workflow's current version, combined with the live claim status.");

package/dist/plugins/codeSubstrate/shared.d.ts

@@ -1,72 +0,0 @@
-import { z } from "zod";
-/**
- * Method-meta defaults shared across every workflow plugin. Each plugin
- * spreads `...codeSubstrateDefaults` into its `createPluginMethod` /
- * `createPaginatedPluginMethod` config so we declare these once instead
- * of per plugin.
- *
- * `experimental: true` keeps every workflow method out of the stable SDK
- * factory — they're registered only by the experimental subpath
- * (`@zapier/zapier-sdk/experimental`) — and badges them in generated docs
- * and CLI help.
- */
-export declare const codeSubstrateDefaults: {
-    categories: string[];
-    experimental: true;
-};
-/**
- * Source files map, shared by `runDurable` and `publishWorkflowVersion`.
- * Both require at least one file.
- */
-export declare const SourceFilesSchema: z.ZodRecord<z.ZodString, z.ZodString>;
-/**
- * A Zapier connection ID accepted on the wire: a positive integer (legacy)
- * or a UUID string (newer connections). Split into three union members so a
- * bad value produces a precise message at the input boundary.
- */
-export declare const ConnectionIdValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodString, z.ZodNumber]>;
-/**
- * Connection binding: maps a single alias to a concrete connection. The
- * locator is camelCase (`connectionId`) per SDK convention; the snake_case
- * `connection_id` is a deprecated alias. Both are optional in the schema so
- * `.shape` stays introspectable for docs — the wire mapper enforces that one
- * is present (see {@link toWireConnections}).
- */
-export declare const ConnectionBindingSchema: 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>;
-/**
- * App-version binding: maps an app key to a pinned implementation/version.
- * `implementationName` is the camelCase locator; `implementation_name` is a
- * deprecated alias. Required-ness of the name is enforced by the wire mapper
- * (see {@link toWireAppVersions}).
- */
-export declare const AppVersionBindingSchema: z.ZodObject<{
-    implementationName: z.ZodOptional<z.ZodString>;
-    implementation_name: z.ZodOptional<z.ZodString>;
-    version: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type ConnectionEntryInput = z.infer<typeof ConnectionBindingSchema>;
-type AppVersionEntryInput = z.infer<typeof AppVersionBindingSchema>;
-/**
- * Reshape a caller's `connections` map into the wire body. The nested
- * locator is camelCase (`connectionId`) per SDK convention but the API
- * expects `connection_id`; the deprecated snake_case alias is still
- * accepted. The connection ID itself is required, so a missing one is a
- * client-side validation error rather than a malformed request.
- */
-export declare function toWireConnections(connections: Record<string, ConnectionEntryInput>): Record<string, {
-    connection_id: string | number;
-}>;
-/**
- * Reshape a caller's `appVersions` map into the wire body, mapping the
- * camelCase `implementationName` locator (and its deprecated snake_case
- * alias) onto the API's `implementation_name`.
- */
-export declare function toWireAppVersions(appVersions: Record<string, AppVersionEntryInput>): Record<string, {
-    implementation_name: string;
-    version?: string;
-}>;
-export {};
-//# sourceMappingURL=shared.d.ts.map

package/dist/plugins/codeSubstrate/shared.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/plugins/codeSubstrate/shared.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB;;;CAGH,CAAC;AAEhC;;;GAGG;AACH,eAAO,MAAM,iBAAiB,uCAK0B,CAAC;AAYzD;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,8DAQjC,CAAC;AAEJ;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB;;;iBAIlC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;iBAYlC,CAAC;AAEH,KAAK,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACpE,KAAK,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAEpE;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,GAChD,MAAM,CAAC,MAAM,EAAE;IAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC,CAYpD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,GAChD,MAAM,CAAC,MAAM,EAAE;IAAE,mBAAmB,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAmBnE"}

package/dist/plugins/codeSubstrate/shared.js

@@ -1,115 +0,0 @@
-import { z } from "zod";
-import { ZapierValidationError } from "../../types/errors";
-/**
- * Method-meta defaults shared across every workflow plugin. Each plugin
- * spreads `...codeSubstrateDefaults` into its `createPluginMethod` /
- * `createPaginatedPluginMethod` config so we declare these once instead
- * of per plugin.
- *
- * `experimental: true` keeps every workflow method out of the stable SDK
- * factory — they're registered only by the experimental subpath
- * (`@zapier/zapier-sdk/experimental`) — and badges them in generated docs
- * and CLI help.
- */
-export const codeSubstrateDefaults = {
-    categories: ["code-workflow"],
-    experimental: true,
-};
-/**
- * Source files map, shared by `runDurable` and `publishWorkflowVersion`.
- * Both require at least one file.
- */
-export const SourceFilesSchema = z
-    .record(z.string(), z.string())
-    .refine((files) => Object.keys(files).length > 0, {
-    message: "sourceFiles must contain at least one file",
-})
-    .describe("Source files keyed by filename → contents");
-// Structural UUID match (8-4-4-4-12 hex), not `z.uuid()`. Both backends
-// validate `connection_id` with this same structural regex and intentionally
-// do NOT enforce RFC version/variant nibbles:
-//   - durableworkflowzaps `CreateWorkflowVersionRequest` (publishWorkflowVersion)
-//   - sdkdurableapi `StartRunRequest` (runDurable)
-// `z.uuid()` is stricter — it rejects non-RFC variants — so it would reject IDs
-// these backends accept. The SDK boundary must not be stricter than the wire.
-const UUID_PATTERN = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
-/**
- * A Zapier connection ID accepted on the wire: a positive integer (legacy)
- * or a UUID string (newer connections). Split into three union members so a
- * bad value produces a precise message at the input boundary.
- */
-export const ConnectionIdValueSchema = z
-    .union([
-    z.string().regex(/^[1-9][0-9]*$/, "must be a positive integer string"),
-    z.string().regex(UUID_PATTERN, "must be a UUID"),
-    z.number().int().positive(),
-])
-    .describe("Zapier connection ID. Accepts a positive integer (legacy) or a UUID string (newer connections).");
-/**
- * Connection binding: maps a single alias to a concrete connection. The
- * locator is camelCase (`connectionId`) per SDK convention; the snake_case
- * `connection_id` is a deprecated alias. Both are optional in the schema so
- * `.shape` stays introspectable for docs — the wire mapper enforces that one
- * is present (see {@link toWireConnections}).
- */
-export const ConnectionBindingSchema = z.object({
-    connectionId: ConnectionIdValueSchema.optional(),
-    /** @deprecated Use `connectionId` instead. */
-    connection_id: ConnectionIdValueSchema.optional().meta({ deprecated: true }),
-});
-/**
- * App-version binding: maps an app key to a pinned implementation/version.
- * `implementationName` is the camelCase locator; `implementation_name` is a
- * deprecated alias. Required-ness of the name is enforced by the wire mapper
- * (see {@link toWireAppVersions}).
- */
-export const AppVersionBindingSchema = z.object({
-    implementationName: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("Zapier app implementation name (e.g. `SlackCLIAPI`)"),
-    /** @deprecated Use `implementationName` instead. */
-    implementation_name: z.string().min(1).optional().meta({ deprecated: true }),
-    version: z
-        .string()
-        .optional()
-        .describe("Pinned app version (e.g. `1.27.1`). Latest if omitted."),
-});
-/**
- * Reshape a caller's `connections` map into the wire body. The nested
- * locator is camelCase (`connectionId`) per SDK convention but the API
- * expects `connection_id`; the deprecated snake_case alias is still
- * accepted. The connection ID itself is required, so a missing one is a
- * client-side validation error rather than a malformed request.
- */
-export function toWireConnections(connections) {
-    const wire = {};
-    for (const [alias, entry] of Object.entries(connections)) {
-        const connectionId = entry.connectionId ?? entry.connection_id;
-        if (connectionId === undefined) {
-            throw new ZapierValidationError(`connections["${alias}"] is missing connectionId`);
-        }
-        wire[alias] = { connection_id: connectionId };
-    }
-    return wire;
-}
-/**
- * Reshape a caller's `appVersions` map into the wire body, mapping the
- * camelCase `implementationName` locator (and its deprecated snake_case
- * alias) onto the API's `implementation_name`.
- */
-export function toWireAppVersions(appVersions) {
-    const wire = {};
-    for (const [key, entry] of Object.entries(appVersions)) {
-        const implementationName = entry.implementationName ?? entry.implementation_name;
-        if (implementationName === undefined) {
-            throw new ZapierValidationError(`appVersions["${key}"] is missing implementationName`);
-        }
-        wire[key] = {
-            implementation_name: implementationName,
-            ...(entry.version !== undefined ? { version: entry.version } : {}),
-        };
-    }
-    return wire;
-}

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

@@ -1,78 +0,0 @@
-export declare const triggerWorkflowPlugin: (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>;
-    };
-}) => {
-    triggerWorkflow: (options?: {
-        workflow: string;
-        input?: unknown;
-    } | undefined) => Promise<{
-        data: {
-            id: string;
-            workflow_id: string;
-            created_at: string;
-        };
-    }>;
-} & {
-    context: {
-        meta: {
-            triggerWorkflow: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type TriggerWorkflowPluginProvides = ReturnType<typeof triggerWorkflowPlugin>;
-//# sourceMappingURL=index.d.ts.map

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

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