@zapier/zapier-sdk 0.73.0 → 0.73.1

package/dist/experimental.mjs

@@ -3285,7 +3285,7 @@ function parseApprovalReviewStreamPayload(parsed, toolNames) {
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.73.0" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.73.1" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -11754,13 +11754,62 @@ var getTriggerInputFieldsSchemaPlugin = definePlugin(
     }
   })
 );
-
-// src/plugins/codeSubstrate/shared.ts
 var codeSubstrateDefaults = {
   categories: ["code-workflow"],
   experimental: true
 };
+var 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 \u2192 contents");
+var 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}$/;
+var 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)."
+);
 var ConnectionBindingSchema = z.object({
+  connectionId: ConnectionIdValueSchema.optional(),
+  /** @deprecated Use `connectionId` instead. */
+  connection_id: ConnectionIdValueSchema.optional().meta({ deprecated: true })
+});
+var 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.")
+});
+function toWireConnections(connections) {
+  const wire = {};
+  for (const [alias, entry] of Object.entries(connections)) {
+    const connectionId = entry.connectionId ?? entry.connection_id;
+    if (connectionId === void 0) {
+      throw new ZapierValidationError(
+        `connections["${alias}"] is missing connectionId`
+      );
+    }
+    wire[alias] = { connection_id: connectionId };
+  }
+  return wire;
+}
+function toWireAppVersions(appVersions) {
+  const wire = {};
+  for (const [key, entry] of Object.entries(appVersions)) {
+    const implementationName = entry.implementationName ?? entry.implementation_name;
+    if (implementationName === void 0) {
+      throw new ZapierValidationError(
+        `appVersions["${key}"] is missing implementationName`
+      );
+    }
+    wire[key] = {
+      implementation_name: implementationName,
+      ...entry.version !== void 0 ? { version: entry.version } : {}
+    };
+  }
+  return wire;
+}
+var ConnectionBindingSchema2 = z.object({
   connection_id: z.union([
     z.number().int().positive(),
     z.string().regex(/^[1-9][0-9]*$/, "must be a positive integer string"),
@@ -11771,7 +11820,7 @@ var ConnectionBindingSchema = z.object({
 }).describe(
   "Connection binding: maps a single alias to a concrete connection."
 );
-var AppVersionBindingSchema = z.object({
+var AppVersionBindingSchema2 = 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.");
@@ -11889,8 +11938,8 @@ var WorkflowVersionSchema = z.object({
   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).")
+  connections: z.record(z.string(), ConnectionBindingSchema2).nullable().describe("Connection aliases bound on this version (or null)."),
+  app_versions: z.record(z.string(), AppVersionBindingSchema2).nullable().describe("App-version pins bound on this version (or null).")
 });
 var GetWorkflowOptionsSchema = z.object({
   workflow: z.string().uuid().describe("Durable workflow ID")
@@ -12341,19 +12390,6 @@ var getDurableRunPlugin = definePlugin(
     }
   })
 );
-var ConnectionMapEntrySchema = z.object({
-  connection_id: z.union([
-    z.string().regex(/^[1-9][0-9]*$/, "must be a positive integer string"),
-    z.string().uuid("must be a UUID"),
-    z.number().int().positive()
-  ]).describe(
-    "Zapier connection ID. Accepts a positive integer (legacy) or a UUID string (newer connections)."
-  )
-});
-var AppVersionMapEntrySchema = z.object({
-  implementation_name: z.string().min(1).describe("Zapier app implementation name (e.g. `SlackCLIAPI`)"),
-  version: z.string().optional().describe("Pinned app version (e.g. `1.27.1`). Latest if omitted.")
-});
 var RunNotificationEventSchema = z.enum(["started", "progress", "completed", "error", "cancelled"]).describe("Run lifecycle event this notification subscribes to");
 var RunNotificationSchema = z.object({
   type: z.literal("webhook").optional().describe("Notification transport. Webhook is the only supported type."),
@@ -12367,28 +12403,37 @@ var RunNotificationSchema = z.object({
 }).describe(
   "Webhook subscriber for run lifecycle events. Server POSTs `{run_id, event}` on each subscribed transition."
 );
-var RunDurableOptionsSchema = z.object({
-  source_files: z.record(z.string(), z.string()).refine((files) => Object.keys(files).length > 0, {
-    message: "source_files must contain at least one file"
-  }).describe("Source files keyed by filename \u2192 contents"),
+var 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"),
-  zapier_durable_version: z.string().optional().describe(
+  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.'
   ),
-  connections: z.record(z.string(), ConnectionMapEntrySchema).optional().describe(
-    'Named connection aliases. Maps each alias to an object holding its Zapier connection ID, e.g. `{ "slack": { "connection_id": "123" } }`.'
+  /** @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" } }`.'
   ),
-  app_versions: z.record(z.string(), AppVersionMapEntrySchema).optional().describe(
+  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."
   )
-}).describe(
-  "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."
-);
+});
+var 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.";
+var RunDurableSchema = z.object({ sourceFiles: SourceFilesSchema }).merge(RunDurableBaseSchema).describe(RunDurableDescription).meta({
+  aliases: {
+    source_files: "sourceFiles",
+    zapier_durable_version: "zapierDurableVersion",
+    app_versions: "appVersions"
+  }
+});
+var RunDurableSchemaDeprecated = z.object({ source_files: SourceFilesSchema }).merge(RunDurableBaseSchema);
+var RunDurableOptionsSchema = z.union([RunDurableSchema, RunDurableSchemaDeprecated]).describe(RunDurableDescription);
 var RunDurableResponseSchema = z.object({
   id: z.string().describe("Run ID (UUID) \u2014 server-generated, time-sortable"),
   status: z.literal("initialized").describe(
@@ -12410,23 +12455,24 @@ var runDurablePlugin = definePlugin(
     inputSchema: RunDurableOptionsSchema,
     outputSchema: RunDurableResponseSchema,
     handler: async ({ sdk: sdk2, options }) => {
-      const body = {
-        source_files: options.source_files
-      };
+      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 !== void 0) {
         body.input = options.input;
       }
       if (options.dependencies !== void 0) {
         body.dependencies = options.dependencies;
       }
-      if (options.zapier_durable_version !== void 0) {
-        body.zapier_durable_version = options.zapier_durable_version;
+      if (zapierDurableVersion !== void 0) {
+        body.zapier_durable_version = zapierDurableVersion;
       }
       if (options.connections !== void 0) {
-        body.connections = options.connections;
+        body.connections = toWireConnections(options.connections);
       }
-      if (options.app_versions !== void 0) {
-        body.app_versions = options.app_versions;
+      if (appVersions !== void 0) {
+        body.app_versions = toWireAppVersions(appVersions);
       }
       if (options.private !== void 0) {
         body.is_private = options.private;
@@ -12481,30 +12527,61 @@ var cancelDurableRunPlugin = definePlugin(
     }
   })
 );
-var PublishWorkflowVersionOptionsSchema = z.object({
-  workflow: z.string().uuid().describe("Durable workflow ID"),
-  source_files: z.record(z.string(), z.string()).refine((files) => Object.keys(files).length > 0, {
-    message: "source_files must contain at least one file"
-  }).describe("Source files keyed by filename \u2192 contents"),
+var 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."
+);
+var PublishWorkflowVersionDescription = "Publish a new version of a durable workflow. Enables the workflow by default.";
+var PublishWorkflowVersionBaseSchema = z.object({
   dependencies: z.record(z.string(), z.string()).optional().describe("Optional npm package dependencies"),
-  zapier_durable_version: z.string().optional().describe(
+  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(), ConnectionBindingSchema).nullish().describe(
     "Map of connection aliases to Zapier connections used by the workflow. Pass `null` to clear an existing binding."
   ),
-  app_versions: z.record(z.string(), AppVersionBindingSchema).nullish().describe(
+  appVersions: z.record(z.string(), AppVersionBindingSchema).nullish().describe(
     "Map of app keys to pinned app implementation/version used by the workflow. Pass `null` to clear an existing binding."
   ),
-  trigger: WorkflowVersionTriggerConfigSchema.optional().describe(
+  /** @deprecated Use `appVersions` instead. */
+  app_versions: z.record(z.string(), AppVersionBindingSchema).nullish().meta({ deprecated: true }),
+  trigger: TriggerConfigSchema.optional().describe(
     "Trigger configuration. When provided, the workflow subscribes to a Zapier trigger; omit for webhook-only workflows."
   )
-}).describe(
-  "Publish a new version of a durable workflow. Enables the workflow by default."
-);
+});
+var WorkflowPropertySchema = z.string().uuid().describe("Durable workflow ID");
+var PublishWorkflowVersionSchema = z.object({
+  workflow: WorkflowPropertySchema,
+  sourceFiles: SourceFilesSchema
+}).merge(PublishWorkflowVersionBaseSchema).describe(PublishWorkflowVersionDescription).meta({
+  aliases: {
+    source_files: "sourceFiles",
+    zapier_durable_version: "zapierDurableVersion",
+    app_versions: "appVersions"
+  }
+});
+var PublishWorkflowVersionSchemaDeprecated = z.object({
+  workflow: WorkflowPropertySchema,
+  source_files: SourceFilesSchema
+}).merge(PublishWorkflowVersionBaseSchema);
+var PublishWorkflowVersionOptionsSchema = z.union([PublishWorkflowVersionSchema, PublishWorkflowVersionSchemaDeprecated]).describe(PublishWorkflowVersionDescription);
 var PublishWorkflowVersionResponseSchema = z.object({
   id: z.string().describe("Workflow version ID (UUID)"),
   workflow_id: z.string().describe("Parent workflow ID (UUID)"),
@@ -12518,11 +12595,30 @@ var PublishWorkflowVersionResponseSchema = z.object({
   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).")
+  connections: z.record(z.string(), ConnectionBindingSchema2).nullable().describe("Connection aliases bound on this version (or null)."),
+  app_versions: z.record(z.string(), AppVersionBindingSchema2).nullable().describe("App-version pins bound on this version (or null).")
 });
 
 // src/plugins/codeSubstrate/publishWorkflowVersion/index.ts
+function toWireTrigger(trigger) {
+  const selectedApi = trigger.selectedApi ?? trigger.selected_api;
+  if (selectedApi === void 0) {
+    throw new ZapierValidationError("trigger is missing selectedApi");
+  }
+  const wire = {
+    selected_api: selectedApi,
+    action: trigger.action
+  };
+  if ("authenticationId" in trigger) {
+    wire.authentication_id = trigger.authenticationId;
+  } else if ("authentication_id" in trigger) {
+    wire.authentication_id = trigger.authentication_id;
+  }
+  if (trigger.params !== void 0) {
+    wire.params = trigger.params;
+  }
+  return wire;
+}
 var publishWorkflowVersionPlugin = definePlugin(
   (sdk) => createPluginMethod(sdk, {
     ...codeSubstrateDefaults,
@@ -12533,26 +12629,31 @@ var publishWorkflowVersionPlugin = definePlugin(
     outputSchema: PublishWorkflowVersionResponseSchema,
     resolvers: { workflow: workflowIdResolver },
     handler: async ({ sdk: sdk2, options }) => {
-      const body = {
-        source_files: options.source_files
-      };
+      const sourceFiles = "sourceFiles" in options ? options.sourceFiles : options.source_files;
+      const zapierDurableVersion = options.zapierDurableVersion ?? options.zapier_durable_version;
+      const appVersions = "appVersions" in options ? options.appVersions : options.app_versions;
+      const body = { source_files: sourceFiles };
       if (options.dependencies !== void 0) {
         body.dependencies = options.dependencies;
       }
-      if (options.zapier_durable_version !== void 0) {
-        body.zapier_durable_version = options.zapier_durable_version;
+      if (zapierDurableVersion !== void 0) {
+        body.zapier_durable_version = zapierDurableVersion;
       }
       if (options.enabled !== void 0) {
         body.enabled = options.enabled;
       }
-      if (options.connections !== void 0) {
-        body.connections = options.connections;
+      if (options.connections === null) {
+        body.connections = null;
+      } else if (options.connections !== void 0) {
+        body.connections = toWireConnections(options.connections);
       }
-      if (options.app_versions !== void 0) {
-        body.app_versions = options.app_versions;
+      if (appVersions === null) {
+        body.app_versions = null;
+      } else if (appVersions !== void 0) {
+        body.app_versions = toWireAppVersions(appVersions);
       }
       if (options.trigger !== void 0) {
-        body.trigger = options.trigger;
+        body.trigger = toWireTrigger(options.trigger);
       }
       const raw = await sdk2.context.api.post(
         `/durableworkflowzaps/api/v0/workflows/${encodeURIComponent(options.workflow)}/versions`,
@@ -12579,8 +12680,8 @@ var WorkflowVersionListItemSchema = z.object({
   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).")
+  connections: z.record(z.string(), ConnectionBindingSchema2).nullable().describe("Connection aliases bound on this version (or null)."),
+  app_versions: z.record(z.string(), AppVersionBindingSchema2).nullable().describe("App-version pins bound on this version (or null).")
 });
 var ListWorkflowVersionsOptionsSchema = z.object({
   workflow: z.string().uuid().describe("Durable workflow ID"),
@@ -12652,8 +12753,8 @@ var GetWorkflowVersionResponseSchema = z.object({
   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).")
+  connections: z.record(z.string(), ConnectionBindingSchema2).nullable().describe("Connection aliases bound on this version (or null)."),
+  app_versions: z.record(z.string(), AppVersionBindingSchema2).nullable().describe("App-version pins bound on this version (or null).")
 });
 
 // src/plugins/codeSubstrate/getWorkflowVersion/index.ts

package/dist/index.cjs

@@ -6880,7 +6880,7 @@ function parseApprovalReviewStreamPayload(parsed, toolNames) {
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.73.0" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.73.1" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";

package/dist/index.mjs

@@ -6878,7 +6878,7 @@ function parseApprovalReviewStreamPayload(parsed, toolNames) {
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.73.0" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.73.1" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";

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

@@ -56,21 +56,60 @@ export declare const publishWorkflowVersionPlugin: (sdk: {
     };
 }) => {
     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, {
-            connection_id: string | number;
+            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, {
-            implementation_name: string;
+            implementationName?: string | undefined;
+            implementation_name?: string | undefined;
             version?: string | undefined;
         }> | null | undefined;
         trigger?: {
-            selected_api: string;
             action: string;
+            selectedApi?: string | undefined;
+            selected_api?: string | undefined;
+            authenticationId?: string | null | undefined;
             authentication_id?: string | null | undefined;
             params?: Record<string, unknown> | undefined;
         } | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/publishWorkflowVersion/index.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDxC,CAAC;AAEF,MAAM,MAAM,oCAAoC,GAAG,UAAU,CAC3D,OAAO,4BAA4B,CACpC,CAAC"}
+{"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,7 +1,36 @@
 import { definePlugin, createPluginMethod } from "kitcore";
+import { ZapierValidationError } from "../../../types/errors";
 import { workflowIdResolver } from "../../../resolvers/workflowId";
-import { codeSubstrateDefaults } from "../shared";
+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",
@@ -11,26 +40,35 @@ export const publishWorkflowVersionPlugin = definePlugin((sdk) => createPluginMe
     outputSchema: PublishWorkflowVersionResponseSchema,
     resolvers: { workflow: workflowIdResolver },
     handler: async ({ sdk, options }) => {
-        const body = {
-            source_files: options.source_files,
-        };
+        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 (options.zapier_durable_version !== undefined) {
-            body.zapier_durable_version = options.zapier_durable_version;
+        if (zapierDurableVersion !== undefined) {
+            body.zapier_durable_version = zapierDurableVersion;
         }
         if (options.enabled !== undefined) {
             body.enabled = options.enabled;
         }
-        if (options.connections !== undefined) {
-            body.connections = options.connections;
+        if (options.connections === null) {
+            body.connections = null;
         }
-        if (options.app_versions !== undefined) {
-            body.app_versions = options.app_versions;
+        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 = options.trigger;
+            body.trigger = toWireTrigger(options.trigger);
         }
         const raw = await sdk.context.api.post(`/durableworkflowzaps/api/v0/workflows/${encodeURIComponent(options.workflow)}/versions`, body, {
             authRequired: true,