@zapier/zapier-sdk 0.69.2 → 0.70.0

package/dist/experimental.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"experimental.d.ts","sourceRoot":"","sources":["../src/experimental.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AA4F1C,cAAc,SAAS,CAAC;AAExB,MAAM,WAAW,gBAAiB,SAAQ,cAAc;CAAG;AAE3D;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,gBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA2IqrD,CAAC;;;;sBAAiX,CAAC;qBAAyB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAvBpoE;AAED,wBAAgB,eAAe,CAAC,OAAO,GAAE,gBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAqB0rD,CAAC;;;;sBAAiX,CAAC;qBAAyB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAhBpoE;AASD,MAAM,WAAW,SAAU,SAAQ,UAAU,CAAC,OAAO,eAAe,CAAC;CAAG;AAMxE,YAAY,EAAE,UAAU,EAAE,CAAC"}
+{"version":3,"file":"experimental.d.ts","sourceRoot":"","sources":["../src/experimental.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AA4F1C,cAAc,SAAS,CAAC;AAExB,MAAM,WAAW,gBAAiB,SAAQ,cAAc;CAAG;AAE3D;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,gBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA2IqrD,CAAC;;;;sBAAiX,CAAC;qBAAyB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAvBpoE;AAED,wBAAgB,eAAe,CAAC,OAAO,GAAE,gBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAqB0rD,CAAC;;;;sBAAiX,CAAC;qBAAyB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAhBpoE;AASD,MAAM,WAAW,SAAU,SAAQ,UAAU,CAAC,OAAO,eAAe,CAAC;CAAG;AAMxE,YAAY,EAAE,UAAU,EAAE,CAAC"}

package/dist/experimental.mjs

@@ -2893,13 +2893,16 @@ async function exchangeClientCredentials(options) {
       },
       timestamp: Date.now()
     });
-    throw new Error(
-      `Client credentials exchange failed: ${response.status} ${response.statusText}`
+    throw new ZapierAuthenticationError(
+      `Client credentials exchange failed: ${response.status} ${response.statusText}`,
+      { statusCode: response.status }
     );
   }
   const data = await response.json();
   if (!data.access_token) {
-    throw new Error("Client credentials response missing access_token");
+    throw new ZapierAuthenticationError(
+      "Client credentials response missing access_token"
+    );
   }
   onEvent?.({
     type: "auth_success",
@@ -3122,6 +3125,17 @@ async function invalidateCredentialsToken(options) {
 }
 
 // src/api/sse-parser.ts
+async function* jsonFrames(source) {
+  for await (const { data } of source) {
+    let frame;
+    try {
+      frame = { parsed: true, data: JSON.parse(data), raw: data };
+    } catch {
+      frame = { parsed: false, data: null, raw: data };
+    }
+    yield frame;
+  }
+}
 function createSseParserStream() {
   let buffer = "";
   let data = "";
@@ -3169,7 +3183,7 @@ function createSseParserStream() {
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.69.2" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.70.0" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -3544,6 +3558,15 @@ var ZapierApiClient = class {
      * never pins a slot — see `withSemaphore`.
      */
     this.fetchStream = (path, init) => this.streamSse(path, init);
+    /**
+     * Like `fetchStream`, but parses each frame's `data` as JSON. Diverges from
+     * `fetchJson` deliberately: that throws on invalid JSON, but a long-lived
+     * stream must survive a single malformed frame, so a parse failure is yielded
+     * as `{ parsed: false, data: null, raw }` rather than thrown. A non-ok
+     * response still throws the shared `ZapierError` (from `fetchStream`, before
+     * any frame), so transport / auth failures surface as usual.
+     */
+    this.fetchJsonStream = (path, init) => jsonFrames(this.fetchStream(path, init));
     this.get = async (path, options = {}) => {
       return this.fetchJson("GET", path, void 0, options);
     };
@@ -3750,16 +3773,16 @@ var ZapierApiClient = class {
       if (typeof errorInfo.data === "string") {
         return { message: `${fallbackMessage}: ${errorInfo.data}` };
       }
-      const errorMessage = this.extractErrorMessage(errorInfo.data) || fallbackMessage;
+      const errorMessage2 = this.extractErrorMessage(errorInfo.data) || fallbackMessage;
       if (this.hasErrorArray(errorInfo.data)) {
         if (this.isApiErrorArray(errorInfo.data.errors)) {
           return {
-            message: errorMessage,
+            message: errorMessage2,
             errors: errorInfo.data.errors
           };
         } else {
           return {
-            message: errorMessage,
+            message: errorMessage2,
             errors: errorInfo.data.errors.map((e) => ({
               status: errorInfo.status,
               code: String(errorInfo.status),
@@ -3769,7 +3792,7 @@ var ZapierApiClient = class {
           };
         }
       }
-      return { message: errorMessage };
+      return { message: errorMessage2 };
     } catch {
       return { message: fallbackMessage };
     }
@@ -4109,7 +4132,11 @@ var createZapierApi = (options) => {
 
 // src/api/error-classification.ts
 function isPermanentHttpError(err) {
-  const statusCode = err instanceof ZapierError ? err.statusCode : void 0;
+  if (!(err instanceof ZapierError)) return false;
+  if (err instanceof ZapierAuthenticationError && err.statusCode === void 0) {
+    return true;
+  }
+  const { statusCode } = err;
   return statusCode !== void 0 && statusCode >= 400 && statusCode < 500 && statusCode !== 429;
 }
 
@@ -6097,11 +6124,11 @@ var runActionPlugin = definePlugin(
           timeoutMs
         });
         if (result.errors && result.errors.length > 0) {
-          const errorMessage = result.errors.map(
+          const errorMessage2 = result.errors.map(
             (error) => error.detail || error.title || "Unknown error"
           ).join("; ");
           throw new ZapierActionError(
-            `Action execution failed: ${errorMessage}`,
+            `Action execution failed: ${errorMessage2}`,
             { appKey, actionKey }
           );
         }
@@ -9275,10 +9302,10 @@ var eventEmissionPlugin = definePlugin(
         registeredListeners.uncaughtException = uncaughtExceptionHandler;
         globalThis.process.on("uncaughtException", uncaughtExceptionHandler);
         const unhandledRejectionHandler = async (reason, promise) => {
-          const errorMessage = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "Unhandled promise rejection";
+          const errorMessage2 = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "Unhandled promise rejection";
           const errorStack = reason instanceof Error ? reason.stack : null;
           let errorEvent = buildErrorEventWithContext({
-            error_message: errorMessage,
+            error_message: errorMessage2,
             error_type: "UnhandledRejection",
             error_stack_trace: errorStack,
             error_severity: "critical",
@@ -10465,6 +10492,16 @@ async function runBatchedDrainPipeline(options) {
 }
 
 // src/plugins/triggers/drainTriggerInbox/index.ts
+var nonRetryableDrainErrors = /* @__PURE__ */ new WeakSet();
+function markNonRetryableDrainError(err) {
+  if (typeof err === "object" && err !== null) {
+    nonRetryableDrainErrors.add(err);
+  }
+  return err;
+}
+function isNonRetryableDrainError(err) {
+  return typeof err === "object" && err !== null && nonRetryableDrainErrors.has(err);
+}
 function isLeaseExpiredError(err) {
   if (!(err instanceof ZapierValidationError)) return false;
   return err.errors?.some((e) => e.code === "lease_expired") ?? false;
@@ -10485,6 +10522,7 @@ async function runDrainPass(options) {
   } = options;
   let firstFetch = options.firstFetch;
   let abortedFromCallback = false;
+  let handlerErrorCaptured = false;
   let firstHandlerError = void 0;
   const outcomes = await runBatchedDrainPipeline({
     concurrency,
@@ -10506,8 +10544,10 @@ async function runDrainPass(options) {
       }
       if (lease.results.length === 0) {
         if (firstFetch && lease.inbox_attributes.status === "initialization_failure") {
-          throw new ZapierApiError(
-            `Trigger inbox ${inboxId} is in initialization_failure state \u2014 inspect via getTriggerInbox.`
+          throw markNonRetryableDrainError(
+            new ZapierApiError(
+              `Trigger inbox ${inboxId} is in initialization_failure state \u2014 inspect via getTriggerInbox.`
+            )
           );
         }
         firstFetch = false;
@@ -10547,7 +10587,10 @@ async function runDrainPass(options) {
           }
         }
         if (!continueOnError && !(err instanceof ZapierSignal)) {
-          if (firstHandlerError === void 0) firstHandlerError = err;
+          if (!handlerErrorCaptured) {
+            firstHandlerError = err;
+            handlerErrorCaptured = true;
+          }
           abort = true;
         }
         return { value: message, action, abort };
@@ -10576,7 +10619,9 @@ async function runDrainPass(options) {
       }
     }
   });
-  if (firstHandlerError !== void 0) throw firstHandlerError;
+  if (handlerErrorCaptured) {
+    throw markNonRetryableDrainError(firstHandlerError);
+  }
   return { abortedFromCallback, processed: outcomes.length };
 }
 function requireOnMessage(onMessage) {
@@ -10650,16 +10695,12 @@ async function* readInboxEvents({
   signal,
   onOpen
 }) {
-  for await (const message of api.fetchStream(
+  for await (const message of api.fetchJsonStream(
     `/trigger-inbox/api/v1/inboxes/${encodeURIComponent(inboxId)}/events`,
     { method: "GET", signal, authRequired: true, onOpen }
   )) {
-    let parsed;
-    try {
-      parsed = JSON.parse(message.data);
-    } catch {
-      continue;
-    }
+    if (!message.parsed) continue;
+    const parsed = message.data;
     if (typeof parsed === "object" && parsed !== null && typeof parsed.inbox_id === "string" && // Only wake on a frame for this inbox. Case-insensitive: the endpoint
     // echoes the canonical lowercase UUID, but resolveTriggerInboxId passes
     // a UUID-shaped `inbox` through unchanged, so its casing may differ.
@@ -10673,6 +10714,7 @@ async function* readInboxEvents({
 var SSE_RECONNECT_BACKOFF_MS = [500, 1e3, 2e3, 5e3];
 var DEFAULT_SAFETY_DRAIN_INTERVAL_MS = 3e5;
 var SSE_HEALTHY_CONNECTION_MS = 5e3;
+var ERROR_BACKOFF_CAP = 4;
 function createDrainLatch() {
   let pending = false;
   const make = () => {
@@ -10703,9 +10745,14 @@ function createDrainLatch() {
 async function drainRunner({
   drainOptions,
   drainRequest,
-  signal
+  signal,
+  inboxId,
+  debug
 }) {
   let firstFetch = true;
+  let consecutiveErrors = 0;
+  let errorAttempts = 0;
+  let drainDegraded = false;
   while (!signal.aborted) {
     await drainRequest.waitForRequest();
     if (signal.aborted) return { kind: "aborted" };
@@ -10716,17 +10763,47 @@ async function drainRunner({
         firstFetch
       }));
     } catch (error) {
-      return { kind: "error", error };
+      if (signal.aborted) return { kind: "aborted" };
+      const isNonObjectThrow = typeof error !== "object" || error === null;
+      if (isNonObjectThrow || isNonRetryableDrainError(error) || isPermanentHttpError(error)) {
+        return { kind: "error", error };
+      }
+      consecutiveErrors = Math.min(consecutiveErrors + 1, ERROR_BACKOFF_CAP);
+      errorAttempts += 1;
+      const delay = calculateErrorBackoffMs(
+        BASE_ERROR_BACKOFF_MS,
+        consecutiveErrors
+      );
+      const statusCode = errorStatusCode(error);
+      const httpPart = statusCode !== void 0 ? ` (HTTP ${statusCode})` : "";
+      if (!drainDegraded && consecutiveErrors >= ERROR_BACKOFF_CAP) {
+        console.warn(
+          `[zapier-sdk] Draining inbox ${inboxId}${httpPart} is failing repeatedly: ${errorMessage(error)}. Continuing to retry with backoff.`
+        );
+        drainDegraded = true;
+      }
+      if (debug) {
+        console.error(
+          `[zapier-sdk] Retrying drain for inbox ${inboxId} (attempt ${errorAttempts}, retry in ${delay}ms)${httpPart}: ${errorMessage(error)}`
+        );
+      }
+      await sleep(delay, signal);
+      if (signal.aborted) return { kind: "aborted" };
+      drainRequest.request();
+      continue;
     }
     firstFetch = false;
+    consecutiveErrors = 0;
+    errorAttempts = 0;
+    drainDegraded = false;
     if (abortedFromCallback) return { kind: "abortedFromCallback" };
   }
   return { kind: "aborted" };
 }
-function sseErrorStatusCode(err) {
+function errorStatusCode(err) {
   return err instanceof ZapierError ? err.statusCode : void 0;
 }
-function sseErrorMessage(err) {
+function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
 async function sseLoop({
@@ -10767,8 +10844,8 @@ async function sseLoop({
       if (signal.aborted || isAbortError(err)) return;
       if (isPermanentHttpError(err)) {
         if (!degraded) {
-          const statusCode = sseErrorStatusCode(err);
-          const errorMsg = sseErrorMessage(err);
+          const statusCode = errorStatusCode(err);
+          const errorMsg = errorMessage(err);
           const httpPart = statusCode !== void 0 ? ` (HTTP ${statusCode})` : "";
           console.warn(
             `[zapier-sdk] Real-time wake-ups for inbox ${inboxId}${httpPart} paused: ${errorMsg}. Falling back to the periodic safety drain.`
@@ -10787,8 +10864,8 @@ async function sseLoop({
     const delay = SSE_RECONNECT_BACKOFF_MS[Math.min(attempt, SSE_RECONNECT_BACKOFF_MS.length - 1)];
     attempt = Math.min(attempt + 1, SSE_RECONNECT_BACKOFF_MS.length - 1);
     if (transientError !== void 0 && debug) {
-      const statusCode = sseErrorStatusCode(transientError);
-      const errorMsg = sseErrorMessage(transientError);
+      const statusCode = errorStatusCode(transientError);
+      const errorMsg = errorMessage(transientError);
       const httpPart = statusCode !== void 0 ? ` (HTTP ${statusCode})` : "";
       console.error(
         `[zapier-sdk] Reconnecting real-time wake-ups for inbox ${inboxId} (attempt ${attempt}, retry in ${delay}ms)${httpPart}: ${errorMsg}`
@@ -10848,7 +10925,13 @@ var watchTriggerInboxPlugin = definePlugin(
         signal
       };
       drainRequest.request();
-      const runnerDone = drainRunner({ drainOptions, drainRequest, signal });
+      const runnerDone = drainRunner({
+        drainOptions,
+        drainRequest,
+        signal,
+        inboxId,
+        debug
+      });
       const sseDone = sseLoop({
         api: sdk.context.api,
         inboxId,
@@ -10881,7 +10964,7 @@ var watchTriggerInboxPlugin = definePlugin(
           watchTriggerInbox: {
             ...triggersDefaults,
             type: "create",
-            description: "Continuously consume a trigger inbox: drain currently-available messages via onMessage, then subscribe to SSE notifications for new arrivals until aborted. A periodic safety drain runs every maxDrainIntervalSeconds (default: 300) to guarantee forward progress if SSE events are missed. Resolves cleanly on signal abort or ZapierAbortDrainSignal from a handler; rejects on fatal SDK errors or fail-fast handler errors. Real-time wake-up health is reported on stderr: a warning when wake-ups pause and the watch falls back to the safety drain, plus (with debug) transient reconnect notices.",
+            description: "Continuously consume a trigger inbox: drain currently-available messages via onMessage, then subscribe to SSE notifications for new arrivals until aborted. A periodic safety drain runs every maxDrainIntervalSeconds (default: 300) to guarantee forward progress if SSE events are missed. Resolves cleanly on signal abort or ZapierAbortDrainSignal from a handler. Transient drain failures (5xx, 429, network blips) retry indefinitely with bounded backoff until they succeed or the watch is aborted; it rejects on a fail-fast handler error, an initialization_failure, or a permanent HTTP error. Real-time wake-up health is reported on stderr: a warning when wake-ups pause and the watch falls back to the safety drain, plus (with debug) transient reconnect notices. Persistent drain failures likewise warn once on stderr while bounded-backoff retries continue.",
             itemType: "void",
             // See drainTriggerInbox: override the doc generator's default
             // suffix so the rendered return type is Promise<void>, not
@@ -11175,7 +11258,10 @@ var getWorkflowPlugin = definePlugin(
 );
 var CreateWorkflowOptionsSchema = z.object({
   name: z.string().min(1).describe("Workflow name"),
-  description: z.string().optional().describe("Optional description for the workflow")
+  description: z.string().optional().describe("Optional description for the workflow"),
+  is_private: z.boolean().optional().describe(
+    "If true, only the creating user can see or manage this workflow. Defaults to false (account-visible)."
+  )
 }).describe(
   "Create a durable workflow container. Starts disabled with no version; publish a version to add code."
 );
@@ -11189,6 +11275,10 @@ var CreateWorkflowResponseSchema = z.object({
   enabled: z.boolean().describe(
     "Whether the workflow currently accepts triggers. Always false on a new workflow until enabled."
   ),
+  is_private: z.boolean().describe(
+    "Whether the workflow is private to the creating user. False means account-visible."
+  ),
+  created_by_user_id: z.string().nullable().describe("User ID of the workflow creator (null in legacy data)"),
   created_at: z.string().describe("When the workflow was created (ISO-8601)")
 });
 
@@ -11206,6 +11296,9 @@ var createWorkflowPlugin = definePlugin(
       if (options.description !== void 0) {
         body.description = options.description;
       }
+      if (options.is_private !== void 0) {
+        body.is_private = options.is_private;
+      }
       const data = await sdk2.context.api.post(
         "/durableworkflowzaps/api/v0/workflows",
         body,
@@ -11656,6 +11749,34 @@ var cancelDurableRunPlugin = definePlugin(
     }
   })
 );
+var CONNECTION_ID_PATTERN = /^([1-9][0-9]*|[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 ConnectionBindingSchema = z.object({
+  connection_id: z.union([
+    z.number().int().positive(),
+    z.string().regex(
+      CONNECTION_ID_PATTERN,
+      "connection_id must be a positive integer string or UUID"
+    )
+  ]).describe(
+    "Zapier connection ID. Positive integer (legacy) or UUID string (newer)."
+  )
+}).describe(
+  "Connection binding: maps a single alias to a concrete connection."
+);
+var 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.");
+var TriggerConfigSchema = 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(
+  "Zapier trigger configuration. When set, the workflow subscribes to trigger events."
+);
 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, {
@@ -11667,6 +11788,15 @@ var PublishWorkflowVersionOptionsSchema = z.object({
   ),
   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(
+    "Map of app keys to pinned app implementation/version used by the workflow. Pass `null` to clear an existing binding."
+  ),
+  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."
@@ -11706,6 +11836,15 @@ var publishWorkflowVersionPlugin = definePlugin(
       if (options.enabled !== void 0) {
         body.enabled = options.enabled;
       }
+      if (options.connections !== void 0) {
+        body.connections = options.connections;
+      }
+      if (options.app_versions !== void 0) {
+        body.app_versions = options.app_versions;
+      }
+      if (options.trigger !== void 0) {
+        body.trigger = options.trigger;
+      }
       const raw = await sdk2.context.api.post(
         `/durableworkflowzaps/api/v0/workflows/${encodeURIComponent(options.workflow)}/versions`,
         body,

package/dist/{index-DuFFW71E.d.mts → index-C0bQ5snd.d.mts}

@@ -2071,6 +2071,23 @@ declare function createMemoryCache(): ZapierCache;
 interface SseMessage {
     data: string;
 }
+/**
+ * A streamed SSE frame after JSON parsing, as yielded by
+ * `ApiClient.fetchJsonStream`. Unlike `fetchJson` — which throws on invalid
+ * JSON — a long-lived stream must not die on one malformed frame, so a parse
+ * failure is reported as `{ parsed: false, data: null, raw }` rather than
+ * thrown. Callers skip `parsed: false` frames (and may inspect `raw`) and keep
+ * consuming.
+ */
+type JsonSseMessage<T = unknown> = {
+    parsed: true;
+    data: T;
+    raw: string;
+} | {
+    parsed: false;
+    data: null;
+    raw: string;
+};
 
 declare const NeedSchema: z.ZodObject<{
     key: z.ZodString;
@@ -2438,6 +2455,14 @@ interface ApiClient {
      * live (response ok, body present) and before the first frame.
      */
     fetchStream: (path: string, init?: FetchStreamInit) => AsyncGenerator<SseMessage>;
+    /**
+     * Like `fetchStream`, but parses each frame's `data` as JSON, yielding
+     * `{ parsed, data, raw }`. Unlike `fetchJson`, a malformed frame is never
+     * thrown — it surfaces as `{ parsed: false, data: null, raw }` so one bad
+     * frame can't kill a long-lived stream. A non-ok response still throws the
+     * shared `ZapierError` subclasses before the first frame.
+     */
+    fetchJsonStream: <T = unknown>(path: string, init?: FetchStreamInit) => AsyncGenerator<JsonSseMessage<T>>;
 }
 interface RequestOptions {
     headers?: Record<string, string>;
@@ -2636,6 +2661,13 @@ declare const createZapierApi: (options: ApiClientOptions) => ApiClient;
  * `api.fetch` already backed off and retried it upstream, so a
  * `ZapierRateLimitError` (also a `ZapierError`) that escapes should be retried
  * on the normal cadence rather than treated as permanent.
+ *
+ * A `ZapierAuthenticationError` with no `statusCode` is the one carve-out: the
+ * token-exchange / credential-resolution layer throws these for setup problems
+ * (token endpoint rejected the credentials, missing keychain secret, no
+ * credentials at all) that never self-heal, so they are permanent even without
+ * a status. Auth errors that DO carry a status fall through to the rule above,
+ * so a 5xx/429 from the token endpoint still retries.
  */
 declare function isPermanentHttpError(err: unknown): boolean;
 
@@ -15235,4 +15267,4 @@ declare const registryPlugin: (sdk: {
     };
 }) => {};
 
-export { createFunction as $, type ApiClient as A, type BaseSdkOptions as B, type CoreOptions as C, type DrainTriggerInboxOptions as D, type EventEmissionContext as E, type FieldsetItem as F, type GetAuthenticationPluginProvides as G, type Choice as H, type ActionExecutionResult as I, type ActionField as J, type ActionFieldChoice as K, type LeasedTriggerMessageItem as L, type MethodHooks as M, type Need as N, type OutputFormatter as O, type PluginStack as P, type NeedsRequest as Q, type ResolvedAppLocator as R, type NeedsResponse as S, type TriggerMessageStatus as T, type UpdateManifestEntryOptions as U, type Connection as V, type WatchTriggerInboxOptions as W, type ConnectionsResponse as X, type UserProfile as Y, type ZapierSdkOptions as Z, isPositional as _, type PluginMeta as a, InputFieldPropertySchema as a$, createPluginStack as a0, createCorePlugin as a1, addPlugin as a2, type FormattedItem as a3, type Resolver as a4, type ArrayResolver as a5, type ResolverMetadata as a6, type StaticResolver as a7, type DynamicListResolver as a8, type DynamicSearchResolver as a9, definePlugin as aA, createPluginMethod as aB, createPaginatedPluginMethod as aC, composePlugins as aD, type ActionItem as aE, type ActionTypeItem as aF, registryPlugin as aG, type RequestOptions as aH, type PollOptions as aI, createZapierApi as aJ, getOrCreateApiClient as aK, isPermanentHttpError as aL, type SseMessage as aM, type AppItem as aN, type ConnectionItem as aO, type ActionItem$1 as aP, type InputFieldItem as aQ, type InfoFieldItem as aR, type RootFieldItem as aS, type UserProfileItem as aT, type SdkPage as aU, type PaginatedSdkFunction as aV, AppKeyPropertySchema as aW, AppPropertySchema as aX, ActionTypePropertySchema as aY, ActionKeyPropertySchema as aZ, ActionPropertySchema as a_, type FieldsResolver as aa, runInMethodScope as ab, runWithTelemetryContext as ac, toSnakeCase as ad, toTitleCase as ae, batch as af, type BatchOptions as ag, buildCapabilityMessage as ah, logDeprecation as ai, resetDeprecationWarnings as aj, RelayRequestSchema as ak, RelayFetchSchema as al, createZapierSdkWithoutRegistry as am, createSdk as an, createOptionsPlugin as ao, createZapierCoreStack as ap, type FunctionRegistryEntry as aq, type FunctionDeprecation as ar, BaseSdkOptionsSchema as as, isCoreError as at, getCoreErrorCode as au, getCoreErrorCause as av, CORE_ERROR_SYMBOL as aw, CoreErrorCode as ax, type Plugin as ay, type PluginProvides as az, type Manifest as b, ZapierActionError as b$, ConnectionIdPropertySchema as b0, AuthenticationIdPropertySchema as b1, ConnectionPropertySchema as b2, InputsPropertySchema as b3, LimitPropertySchema as b4, OffsetPropertySchema as b5, OutputPropertySchema as b6, DebugPropertySchema as b7, ParamsPropertySchema as b8, ActionTimeoutMsPropertySchema as b9, type ParamsProperty as bA, type ActionTimeoutMsProperty as bB, type TableProperty as bC, type RecordProperty as bD, type RecordsProperty as bE, type FieldsProperty as bF, type AppsProperty as bG, type TablesProperty as bH, type ConnectionsProperty as bI, type TriggerInboxProperty as bJ, type TriggerInboxNameProperty as bK, type LeaseProperty as bL, type LeaseSecondsProperty as bM, type LeaseLimitProperty as bN, type ErrorOptions as bO, ZapierError as bP, ZapierValidationError as bQ, ZapierUnknownError as bR, ZapierAuthenticationError as bS, zapierAdaptError as bT, ZapierApiError as bU, ZapierAppNotFoundError as bV, ZapierNotFoundError as bW, ZapierResourceNotFoundError as bX, ZapierConfigurationError as bY, ZapierBundleError as bZ, ZapierTimeoutError as b_, TablePropertySchema as ba, RecordPropertySchema as bb, RecordsPropertySchema as bc, FieldsPropertySchema as bd, AppsPropertySchema as be, TablesPropertySchema as bf, ConnectionsPropertySchema as bg, TriggerInboxPropertySchema as bh, TriggerInboxNamePropertySchema as bi, LeasePropertySchema as bj, LeaseSecondsPropertySchema as bk, LeaseLimitPropertySchema as bl, type AppKeyProperty as bm, type AppProperty as bn, type ActionTypeProperty as bo, type ActionKeyProperty as bp, type ActionProperty as bq, type InputFieldProperty as br, type ConnectionIdProperty as bs, type ConnectionProperty as bt, type AuthenticationIdProperty as bu, type InputsProperty as bv, type LimitProperty as bw, type OffsetProperty as bx, type OutputProperty as by, type DebugProperty as bz, type UpdateManifestEntryResult as c, connectionIdResolver as c$, ZapierConflictError as c0, type RateLimitInfo as c1, ZapierRateLimitError as c2, type ApprovalStatus as c3, ZapierApprovalError as c4, ZapierRelayError as c5, formatErrorMessage as c6, type ApiError as c7, ZapierSignal as c8, appsPlugin as c9, type GetActionPluginProvides as cA, getConnectionPlugin as cB, type GetConnectionPluginProvides as cC, findFirstConnectionPlugin as cD, type FindFirstConnectionPluginProvides as cE, findUniqueConnectionPlugin as cF, type FindUniqueConnectionPluginProvides as cG, CONTEXT_CACHE_TTL_MS as cH, CONTEXT_CACHE_MAX_SIZE as cI, runActionPlugin as cJ, type RunActionPluginProvides as cK, requestPlugin as cL, type RequestPluginProvides as cM, type ManifestPluginOptions as cN, getPreferredManifestEntryKey as cO, manifestPlugin as cP, type ManifestPluginProvides as cQ, DEFAULT_CONFIG_PATH as cR, type ManifestEntry as cS, getProfilePlugin as cT, type GetProfilePluginProvides as cU, type ApiPluginOptions as cV, apiPlugin as cW, type ApiPluginProvides as cX, appKeyResolver as cY, actionTypeResolver as cZ, actionKeyResolver as c_, type AppsPluginProvides as ca, type ActionExecutionOptions as cb, type AppFactoryInput as cc, fetchPlugin as cd, type FetchPluginProvides as ce, listAppsPlugin as cf, type ListAppsPluginProvides as cg, listActionsPlugin as ch, type ListActionsPluginProvides as ci, listActionInputFieldsPlugin as cj, type ListActionInputFieldsPluginProvides as ck, listActionInputFieldChoicesPlugin as cl, type ListActionInputFieldChoicesPluginProvides as cm, getActionInputFieldsSchemaPlugin as cn, type GetActionInputFieldsSchemaPluginProvides as co, listConnectionsPlugin as cp, type ListConnectionsPluginProvides as cq, listClientCredentialsPlugin as cr, type ListClientCredentialsPluginProvides as cs, createClientCredentialsPlugin as ct, type CreateClientCredentialsPluginProvides as cu, deleteClientCredentialsPlugin as cv, type DeleteClientCredentialsPluginProvides as cw, getAppPlugin as cx, type GetAppPluginProvides as cy, getActionPlugin as cz, type AddActionEntryOptions as d, ConnectionsMapSchema as d$, connectionIdGenericResolver as d0, inputsResolver as d1, inputsAllOptionalResolver as d2, inputFieldKeyResolver as d3, clientCredentialsNameResolver as d4, clientIdResolver as d5, tableIdResolver as d6, triggerInboxResolver as d7, workflowIdResolver as d8, durableRunIdResolver as d9, type AuthEvent as dA, type ApiEvent as dB, type LoadingEvent as dC, type EventCallback as dD, type Credentials as dE, type ResolvedCredentials as dF, type CredentialsObject as dG, type ClientCredentialsObject as dH, type PkceCredentialsObject as dI, isClientCredentials as dJ, isPkceCredentials as dK, isCredentialsObject as dL, isCredentialsFunction as dM, type ResolveCredentialsOptions as dN, resolveCredentialsFromEnv as dO, resolveCredentials as dP, getBaseUrlFromCredentials as dQ, getClientIdFromCredentials as dR, ClientCredentialsObjectSchema as dS, PkceCredentialsObjectSchema as dT, CredentialsObjectSchema as dU, ResolvedCredentialsSchema as dV, CredentialsFunctionSchema as dW, type CredentialsFunction as dX, CredentialsSchema as dY, ConnectionEntrySchema as dZ, type ConnectionEntry as d_, workflowVersionIdResolver as da, workflowRunIdResolver as db, triggerMessagesResolver as dc, tableRecordIdResolver as dd, tableRecordIdsResolver as de, tableFieldIdsResolver as df, tableNameResolver as dg, tableFieldsResolver as dh, tableRecordsResolver as di, tableUpdateRecordsResolver as dj, tableFiltersResolver as dk, tableSortResolver as dl, type ResolveAuthTokenOptions as dm, clearTokenCache as dn, invalidateCachedToken as dp, injectCliLogin as dq, isCliLoginAvailable as dr, getTokenFromCliLogin as ds, resolveAuthToken as dt, invalidateCredentialsToken as du, type ZapierCache as dv, type ZapierCacheEntry as dw, type ZapierCacheSetOptions as dx, createMemoryCache as dy, type SdkEvent as dz, type AddActionEntryResult as e, getMemoryUsage as e$, type ConnectionsMap as e0, connectionsPlugin as e1, type ConnectionsPluginProvides as e2, ZAPIER_BASE_URL as e3, getZapierSdkService as e4, MAX_PAGE_LIMIT as e5, DEFAULT_PAGE_SIZE as e6, DEFAULT_ACTION_TIMEOUT_MS as e7, ZAPIER_MAX_NETWORK_RETRIES as e8, ZAPIER_MAX_NETWORK_RETRY_DELAY_MS as e9, type CreateTableRecordsPluginProvides as eA, deleteTableRecordsPlugin as eB, type DeleteTableRecordsPluginProvides as eC, updateTableRecordsPlugin as eD, type UpdateTableRecordsPluginProvides as eE, cleanupEventListeners as eF, type EventEmissionConfig as eG, eventEmissionPlugin as eH, type EventEmissionProvides as eI, type EventContext as eJ, type ApplicationLifecycleEventData as eK, type EnhancedErrorEventData as eL, type MethodCalledEventData as eM, buildApplicationLifecycleEvent as eN, buildErrorEventWithContext as eO, buildErrorEvent as eP, createBaseEvent as eQ, buildMethodCalledEvent as eR, type BaseEvent as eS, type MethodCalledEvent as eT, generateEventId as eU, getCurrentTimestamp as eV, getReleaseId as eW, getOsInfo as eX, getPlatformVersions as eY, isCi as eZ, getCiPlatform as e_, MAX_CONCURRENCY_LIMIT as ea, parseConcurrencyEnvVar as eb, ZAPIER_MAX_CONCURRENT_REQUESTS as ec, getZapierApprovalMode as ed, getZapierDefaultApprovalMode as ee, DEFAULT_APPROVAL_TIMEOUT_MS as ef, DEFAULT_MAX_APPROVAL_RETRIES as eg, listTablesPlugin as eh, type ListTablesPluginProvides as ei, getTablePlugin as ej, type GetTablePluginProvides as ek, createTablePlugin as el, type CreateTablePluginProvides as em, deleteTablePlugin as en, type DeleteTablePluginProvides as eo, listTableFieldsPlugin as ep, type ListTableFieldsPluginProvides as eq, createTableFieldsPlugin as er, type CreateTableFieldsPluginProvides as es, deleteTableFieldsPlugin as et, type DeleteTableFieldsPluginProvides as eu, getTableRecordPlugin as ev, type GetTableRecordPluginProvides as ew, listTableRecordsPlugin as ex, type ListTableRecordsPluginProvides as ey, createTableRecordsPlugin as ez, type ActionEntry as f, getCpuTime as f0, createZapierSdk as f1, createZapierSdkStack as f2, type ZapierSdk as f3, findManifestEntry as g, type CapabilitiesContext as h, type PaginatedSdkResult as i, type PositionalMetadata as j, type ZapierFetchInitOptions as k, type DynamicResolver as l, type ActionProxy as m, type ZapierSdkApps as n, type WithAddPlugin as o, ZapierAbortDrainSignal as p, ZapierReleaseTriggerMessageSignal as q, readManifestFromFile as r, type DrainTriggerInboxCallback as s, type DrainTriggerInboxErrorObserver as t, type ListAuthenticationsPluginProvides as u, type FindFirstAuthenticationPluginProvides as v, type FindUniqueAuthenticationPluginProvides as w, type Action as x, type App as y, type Field as z };
+export { createFunction as $, type ApiClient as A, type BaseSdkOptions as B, type CoreOptions as C, type DrainTriggerInboxOptions as D, type EventEmissionContext as E, type FieldsetItem as F, type GetAuthenticationPluginProvides as G, type Choice as H, type ActionExecutionResult as I, type ActionField as J, type ActionFieldChoice as K, type LeasedTriggerMessageItem as L, type MethodHooks as M, type Need as N, type OutputFormatter as O, type PluginStack as P, type NeedsRequest as Q, type ResolvedAppLocator as R, type NeedsResponse as S, type TriggerMessageStatus as T, type UpdateManifestEntryOptions as U, type Connection as V, type WatchTriggerInboxOptions as W, type ConnectionsResponse as X, type UserProfile as Y, type ZapierSdkOptions as Z, isPositional as _, type PluginMeta as a, ActionPropertySchema as a$, createPluginStack as a0, createCorePlugin as a1, addPlugin as a2, type FormattedItem as a3, type Resolver as a4, type ArrayResolver as a5, type ResolverMetadata as a6, type StaticResolver as a7, type DynamicListResolver as a8, type DynamicSearchResolver as a9, definePlugin as aA, createPluginMethod as aB, createPaginatedPluginMethod as aC, composePlugins as aD, type ActionItem as aE, type ActionTypeItem as aF, registryPlugin as aG, type RequestOptions as aH, type PollOptions as aI, createZapierApi as aJ, getOrCreateApiClient as aK, isPermanentHttpError as aL, type SseMessage as aM, type JsonSseMessage as aN, type AppItem as aO, type ConnectionItem as aP, type ActionItem$1 as aQ, type InputFieldItem as aR, type InfoFieldItem as aS, type RootFieldItem as aT, type UserProfileItem as aU, type SdkPage as aV, type PaginatedSdkFunction as aW, AppKeyPropertySchema as aX, AppPropertySchema as aY, ActionTypePropertySchema as aZ, ActionKeyPropertySchema as a_, type FieldsResolver as aa, runInMethodScope as ab, runWithTelemetryContext as ac, toSnakeCase as ad, toTitleCase as ae, batch as af, type BatchOptions as ag, buildCapabilityMessage as ah, logDeprecation as ai, resetDeprecationWarnings as aj, RelayRequestSchema as ak, RelayFetchSchema as al, createZapierSdkWithoutRegistry as am, createSdk as an, createOptionsPlugin as ao, createZapierCoreStack as ap, type FunctionRegistryEntry as aq, type FunctionDeprecation as ar, BaseSdkOptionsSchema as as, isCoreError as at, getCoreErrorCode as au, getCoreErrorCause as av, CORE_ERROR_SYMBOL as aw, CoreErrorCode as ax, type Plugin as ay, type PluginProvides as az, type Manifest as b, ZapierTimeoutError as b$, InputFieldPropertySchema as b0, ConnectionIdPropertySchema as b1, AuthenticationIdPropertySchema as b2, ConnectionPropertySchema as b3, InputsPropertySchema as b4, LimitPropertySchema as b5, OffsetPropertySchema as b6, OutputPropertySchema as b7, DebugPropertySchema as b8, ParamsPropertySchema as b9, type DebugProperty as bA, type ParamsProperty as bB, type ActionTimeoutMsProperty as bC, type TableProperty as bD, type RecordProperty as bE, type RecordsProperty as bF, type FieldsProperty as bG, type AppsProperty as bH, type TablesProperty as bI, type ConnectionsProperty as bJ, type TriggerInboxProperty as bK, type TriggerInboxNameProperty as bL, type LeaseProperty as bM, type LeaseSecondsProperty as bN, type LeaseLimitProperty as bO, type ErrorOptions as bP, ZapierError as bQ, ZapierValidationError as bR, ZapierUnknownError as bS, ZapierAuthenticationError as bT, zapierAdaptError as bU, ZapierApiError as bV, ZapierAppNotFoundError as bW, ZapierNotFoundError as bX, ZapierResourceNotFoundError as bY, ZapierConfigurationError as bZ, ZapierBundleError as b_, ActionTimeoutMsPropertySchema as ba, TablePropertySchema as bb, RecordPropertySchema as bc, RecordsPropertySchema as bd, FieldsPropertySchema as be, AppsPropertySchema as bf, TablesPropertySchema as bg, ConnectionsPropertySchema as bh, TriggerInboxPropertySchema as bi, TriggerInboxNamePropertySchema as bj, LeasePropertySchema as bk, LeaseSecondsPropertySchema as bl, LeaseLimitPropertySchema as bm, type AppKeyProperty as bn, type AppProperty as bo, type ActionTypeProperty as bp, type ActionKeyProperty as bq, type ActionProperty as br, type InputFieldProperty as bs, type ConnectionIdProperty as bt, type ConnectionProperty as bu, type AuthenticationIdProperty as bv, type InputsProperty as bw, type LimitProperty as bx, type OffsetProperty as by, type OutputProperty as bz, type UpdateManifestEntryResult as c, actionKeyResolver as c$, ZapierActionError as c0, ZapierConflictError as c1, type RateLimitInfo as c2, ZapierRateLimitError as c3, type ApprovalStatus as c4, ZapierApprovalError as c5, ZapierRelayError as c6, formatErrorMessage as c7, type ApiError as c8, ZapierSignal as c9, getActionPlugin as cA, type GetActionPluginProvides as cB, getConnectionPlugin as cC, type GetConnectionPluginProvides as cD, findFirstConnectionPlugin as cE, type FindFirstConnectionPluginProvides as cF, findUniqueConnectionPlugin as cG, type FindUniqueConnectionPluginProvides as cH, CONTEXT_CACHE_TTL_MS as cI, CONTEXT_CACHE_MAX_SIZE as cJ, runActionPlugin as cK, type RunActionPluginProvides as cL, requestPlugin as cM, type RequestPluginProvides as cN, type ManifestPluginOptions as cO, getPreferredManifestEntryKey as cP, manifestPlugin as cQ, type ManifestPluginProvides as cR, DEFAULT_CONFIG_PATH as cS, type ManifestEntry as cT, getProfilePlugin as cU, type GetProfilePluginProvides as cV, type ApiPluginOptions as cW, apiPlugin as cX, type ApiPluginProvides as cY, appKeyResolver as cZ, actionTypeResolver as c_, appsPlugin as ca, type AppsPluginProvides as cb, type ActionExecutionOptions as cc, type AppFactoryInput as cd, fetchPlugin as ce, type FetchPluginProvides as cf, listAppsPlugin as cg, type ListAppsPluginProvides as ch, listActionsPlugin as ci, type ListActionsPluginProvides as cj, listActionInputFieldsPlugin as ck, type ListActionInputFieldsPluginProvides as cl, listActionInputFieldChoicesPlugin as cm, type ListActionInputFieldChoicesPluginProvides as cn, getActionInputFieldsSchemaPlugin as co, type GetActionInputFieldsSchemaPluginProvides as cp, listConnectionsPlugin as cq, type ListConnectionsPluginProvides as cr, listClientCredentialsPlugin as cs, type ListClientCredentialsPluginProvides as ct, createClientCredentialsPlugin as cu, type CreateClientCredentialsPluginProvides as cv, deleteClientCredentialsPlugin as cw, type DeleteClientCredentialsPluginProvides as cx, getAppPlugin as cy, type GetAppPluginProvides as cz, type AddActionEntryOptions as d, type ConnectionEntry as d$, connectionIdResolver as d0, connectionIdGenericResolver as d1, inputsResolver as d2, inputsAllOptionalResolver as d3, inputFieldKeyResolver as d4, clientCredentialsNameResolver as d5, clientIdResolver as d6, tableIdResolver as d7, triggerInboxResolver as d8, workflowIdResolver as d9, type SdkEvent as dA, type AuthEvent as dB, type ApiEvent as dC, type LoadingEvent as dD, type EventCallback as dE, type Credentials as dF, type ResolvedCredentials as dG, type CredentialsObject as dH, type ClientCredentialsObject as dI, type PkceCredentialsObject as dJ, isClientCredentials as dK, isPkceCredentials as dL, isCredentialsObject as dM, isCredentialsFunction as dN, type ResolveCredentialsOptions as dO, resolveCredentialsFromEnv as dP, resolveCredentials as dQ, getBaseUrlFromCredentials as dR, getClientIdFromCredentials as dS, ClientCredentialsObjectSchema as dT, PkceCredentialsObjectSchema as dU, CredentialsObjectSchema as dV, ResolvedCredentialsSchema as dW, CredentialsFunctionSchema as dX, type CredentialsFunction as dY, CredentialsSchema as dZ, ConnectionEntrySchema as d_, durableRunIdResolver as da, workflowVersionIdResolver as db, workflowRunIdResolver as dc, triggerMessagesResolver as dd, tableRecordIdResolver as de, tableRecordIdsResolver as df, tableFieldIdsResolver as dg, tableNameResolver as dh, tableFieldsResolver as di, tableRecordsResolver as dj, tableUpdateRecordsResolver as dk, tableFiltersResolver as dl, tableSortResolver as dm, type ResolveAuthTokenOptions as dn, clearTokenCache as dp, invalidateCachedToken as dq, injectCliLogin as dr, isCliLoginAvailable as ds, getTokenFromCliLogin as dt, resolveAuthToken as du, invalidateCredentialsToken as dv, type ZapierCache as dw, type ZapierCacheEntry as dx, type ZapierCacheSetOptions as dy, createMemoryCache as dz, type AddActionEntryResult as e, getCiPlatform as e$, ConnectionsMapSchema as e0, type ConnectionsMap as e1, connectionsPlugin as e2, type ConnectionsPluginProvides as e3, ZAPIER_BASE_URL as e4, getZapierSdkService as e5, MAX_PAGE_LIMIT as e6, DEFAULT_PAGE_SIZE as e7, DEFAULT_ACTION_TIMEOUT_MS as e8, ZAPIER_MAX_NETWORK_RETRIES as e9, createTableRecordsPlugin as eA, type CreateTableRecordsPluginProvides as eB, deleteTableRecordsPlugin as eC, type DeleteTableRecordsPluginProvides as eD, updateTableRecordsPlugin as eE, type UpdateTableRecordsPluginProvides as eF, cleanupEventListeners as eG, type EventEmissionConfig as eH, eventEmissionPlugin as eI, type EventEmissionProvides as eJ, type EventContext as eK, type ApplicationLifecycleEventData as eL, type EnhancedErrorEventData as eM, type MethodCalledEventData as eN, buildApplicationLifecycleEvent as eO, buildErrorEventWithContext as eP, buildErrorEvent as eQ, createBaseEvent as eR, buildMethodCalledEvent as eS, type BaseEvent as eT, type MethodCalledEvent as eU, generateEventId as eV, getCurrentTimestamp as eW, getReleaseId as eX, getOsInfo as eY, getPlatformVersions as eZ, isCi as e_, ZAPIER_MAX_NETWORK_RETRY_DELAY_MS as ea, MAX_CONCURRENCY_LIMIT as eb, parseConcurrencyEnvVar as ec, ZAPIER_MAX_CONCURRENT_REQUESTS as ed, getZapierApprovalMode as ee, getZapierDefaultApprovalMode as ef, DEFAULT_APPROVAL_TIMEOUT_MS as eg, DEFAULT_MAX_APPROVAL_RETRIES as eh, listTablesPlugin as ei, type ListTablesPluginProvides as ej, getTablePlugin as ek, type GetTablePluginProvides as el, createTablePlugin as em, type CreateTablePluginProvides as en, deleteTablePlugin as eo, type DeleteTablePluginProvides as ep, listTableFieldsPlugin as eq, type ListTableFieldsPluginProvides as er, createTableFieldsPlugin as es, type CreateTableFieldsPluginProvides as et, deleteTableFieldsPlugin as eu, type DeleteTableFieldsPluginProvides as ev, getTableRecordPlugin as ew, type GetTableRecordPluginProvides as ex, listTableRecordsPlugin as ey, type ListTableRecordsPluginProvides as ez, type ActionEntry as f, getMemoryUsage as f0, getCpuTime as f1, createZapierSdk as f2, createZapierSdkStack as f3, type ZapierSdk as f4, findManifestEntry as g, type CapabilitiesContext as h, type PaginatedSdkResult as i, type PositionalMetadata as j, type ZapierFetchInitOptions as k, type DynamicResolver as l, type ActionProxy as m, type ZapierSdkApps as n, type WithAddPlugin as o, ZapierAbortDrainSignal as p, ZapierReleaseTriggerMessageSignal as q, readManifestFromFile as r, type DrainTriggerInboxCallback as s, type DrainTriggerInboxErrorObserver as t, type ListAuthenticationsPluginProvides as u, type FindFirstAuthenticationPluginProvides as v, type FindUniqueAuthenticationPluginProvides as w, type Action as x, type App as y, type Field as z };