@zapier/zapier-sdk 0.78.0 → 0.80.0

package/dist/experimental.mjs

@@ -51,18 +51,20 @@ function buildRegistry({
   sdk,
   meta,
   formatters,
+  boundResolvers,
+  positional,
   packageFilter
 }) {
   const definitionsByKey = /* @__PURE__ */ new Map();
   const objectDeclaredKeys = /* @__PURE__ */ new Set();
   for (const m of Object.values(meta)) {
     for (const ref of m.categories ?? []) {
-      const key = typeof ref === "string" ? ref : ref.key;
+      const key2 = typeof ref === "string" ? ref : ref.key;
       if (typeof ref === "object") {
-        objectDeclaredKeys.add(key);
-        definitionsByKey.set(key, resolveCategoryDefinition(ref));
-      } else if (!objectDeclaredKeys.has(key)) {
-        definitionsByKey.set(key, resolveCategoryDefinition(ref));
+        objectDeclaredKeys.add(key2);
+        definitionsByKey.set(key2, resolveCategoryDefinition(ref));
+      } else if (!objectDeclaredKeys.has(key2)) {
+        definitionsByKey.set(key2, resolveCategoryDefinition(ref));
       }
     }
   }
@@ -70,16 +72,16 @@ function buildRegistry({
     definitionsByKey.set("other", resolveCategoryDefinition("other"));
   }
   const knownCategories = Array.from(definitionsByKey.keys());
-  const functions = Object.keys(meta).filter((key) => {
-    const property = sdk[key];
+  const functions = Object.keys(meta).filter((key2) => {
+    const property = sdk[key2];
     if (typeof property === "function") return true;
-    const [rootKey] = key.split(".");
+    const [rootKey] = key2.split(".");
     const rootProperty = sdk[rootKey];
     return typeof rootProperty === "object" && rootProperty !== null;
-  }).map((key) => {
-    const m = meta[key];
+  }).map((key2) => {
+    const m = meta[key2];
     return {
-      name: key,
+      name: key2,
       description: m.description,
       type: m.type,
       itemType: m.itemType,
@@ -87,11 +89,13 @@ function buildRegistry({
       inputSchema: canonicalInputSchema(m.inputSchema),
       inputParameters: m.inputParameters,
       outputSchema: m.outputSchema,
+      positional: positional?.[key2],
       categories: (m.categories ?? []).map(
         (c) => typeof c === "string" ? c : c.key
       ),
       resolvers: m.resolvers,
-      formatter: formatters?.[key],
+      boundResolvers: boundResolvers?.[key2],
+      formatter: formatters?.[key2],
       experimental: m.experimental,
       packages: m.packages,
       confirm: m.confirm ?? (m.type === "delete" ? "delete" : void 0),
@@ -129,8 +133,8 @@ function composeVoid(existing, added) {
 }
 function buildHooks(existing, added) {
   const result = {};
-  const start = composeVoid(existing.onMethodStart, added.onMethodStart);
-  if (start) result.onMethodStart = start;
+  const start2 = composeVoid(existing.onMethodStart, added.onMethodStart);
+  if (start2) result.onMethodStart = start2;
   const end = composeVoid(existing.onMethodEnd, added.onMethodEnd);
   if (end) result.onMethodEnd = end;
   return result;
@@ -763,11 +767,11 @@ var RESERVED_ROOT_KEYS = /* @__PURE__ */ new Set([
   "context",
   "getRegistry"
 ]);
-function hasOwn(obj, key) {
-  return Object.prototype.hasOwnProperty.call(obj, key);
+function hasOwn(obj, key2) {
+  return Object.prototype.hasOwnProperty.call(obj, key2);
 }
-function setOwn(target, key, value) {
-  Object.defineProperty(target, key, {
+function setOwn(target, key2, value) {
+  Object.defineProperty(target, key2, {
     value,
     enumerable: true,
     configurable: true,
@@ -779,31 +783,31 @@ function checkCollisions(target, source, kind, callerLabel, override) {
     checkRootKeyCollisions(target, Object.keys(source), override, callerLabel);
     return;
   }
-  for (const key of Object.keys(source)) {
-    if (!override && hasOwn(target, key)) {
+  for (const key2 of Object.keys(source)) {
+    if (!override && hasOwn(target, key2)) {
       throw new Error(
-        `${callerLabel}: duplicate ${kind} "${key}". If the override is intentional, pass { override: true } in the options.`
+        `${callerLabel}: duplicate ${kind} "${key2}". If the override is intentional, pass { override: true } in the options.`
       );
     }
   }
 }
 function checkRootKeyCollisions(target, keys, override, callerLabel) {
-  for (const key of keys) {
-    if (RESERVED_ROOT_KEYS.has(key)) {
+  for (const key2 of keys) {
+    if (RESERVED_ROOT_KEYS.has(key2)) {
       throw new Error(
-        `${callerLabel}: plugin attempted to register reserved root key "${key}". The SDK uses this key for its own accessor; rename the plugin's method.`
+        `${callerLabel}: plugin attempted to register reserved root key "${key2}". The SDK uses this key for its own accessor; rename the plugin's method.`
       );
     }
-    if (!override && hasOwn(target, key)) {
+    if (!override && hasOwn(target, key2)) {
       throw new Error(
-        `${callerLabel}: duplicate root key "${key}". If the override is intentional, pass { override: true } in the options.`
+        `${callerLabel}: duplicate root key "${key2}". If the override is intentional, pass { override: true } in the options.`
       );
     }
   }
 }
 function applyOwnProperties(target, source) {
-  for (const key of Object.keys(source)) {
-    setOwn(target, key, source[key]);
+  for (const key2 of Object.keys(source)) {
+    setOwn(target, key2, source[key2]);
   }
 }
 function createPluginAccumulator(initialProperties = {}, initialContext = {}) {
@@ -1051,8 +1055,8 @@ function normalizeImports(deps) {
 }
 function collectLeafMeta(config) {
   let meta;
-  for (const key of LEAF_META_KEYS) {
-    if (config[key] !== void 0) (meta ?? (meta = {}))[key] = config[key];
+  for (const key2 of LEAF_META_KEYS) {
+    if (config[key2] !== void 0) (meta ?? (meta = {}))[key2] = config[key2];
   }
   return meta;
 }
@@ -1075,12 +1079,66 @@ function defineMethod(config) {
     run: config.run
   };
 }
+function defineResolver(config) {
+  const deps = normalizeImports(config.imports);
+  const base = { imports: deps.plugins, importBindings: deps.bindings };
+  const gates = {
+    requireParameters: config.requireParameters
+  };
+  switch (config.type) {
+    case "static":
+      return {
+        ...base,
+        ...gates,
+        type: "static",
+        inputType: config.inputType,
+        placeholder: config.placeholder
+      };
+    case "constant":
+      return { ...base, ...gates, type: "constant", value: config.value };
+    case "info":
+      return { ...base, type: "info", text: config.text ?? "" };
+    case "object":
+      return {
+        ...base,
+        ...gates,
+        type: "object",
+        properties: config.properties,
+        definitions: config.definitions,
+        getProperties: config.getProperties
+      };
+    case "array":
+      return {
+        ...base,
+        ...gates,
+        type: "array",
+        items: config.items,
+        minItems: config.minItems,
+        maxItems: config.maxItems,
+        itemValueType: config.itemValueType,
+        definitions: config.definitions
+      };
+    default:
+      return {
+        ...base,
+        ...gates,
+        type: "dynamic",
+        inputType: config.inputType,
+        placeholder: config.placeholder,
+        getContext: config.getContext,
+        listItems: config.listItems,
+        prompt: config.prompt,
+        tryResolveWithoutPrompt: config.tryResolveWithoutPrompt,
+        tryResolveFromSearch: config.tryResolveFromSearch
+      };
+  }
+}
 function defineFormatter(config) {
   const deps = normalizeImports(config.imports);
   return {
     imports: deps.plugins,
     importBindings: deps.bindings,
-    fetchContext: config.fetchContext,
+    getContext: config.getContext,
     format: config.format
   };
 }
@@ -1209,7 +1267,7 @@ function legacyGraphEntry(name, value, pluginMeta) {
 function adaptLegacyFormatter(legacy, sdk) {
   const legacyFetch = legacy.fetch;
   return {
-    fetchContext: legacyFetch ? async ({ items, input, context }) => {
+    getContext: legacyFetch ? async ({ items, input, context }) => {
       let ctx = context;
       for (const item of items) {
         ctx = await legacyFetch(sdk, input, item, ctx);
@@ -1225,6 +1283,14 @@ function normalizeFormatter(entry, sdk) {
   const legacy = entry.meta?.formatter;
   return legacy ? adaptLegacyFormatter(legacy, sdk) : void 0;
 }
+function normalizeBoundResolvers(entry) {
+  if (entry.pluginType !== "method") return void 0;
+  return entry.resolvers;
+}
+function methodPositional(entry) {
+  if (entry.pluginType !== "method") return void 0;
+  return entry.positional;
+}
 function pluginEntryMeta(entry) {
   if (entry.pluginType === "method" && entry.meta) {
     return entry.inputSchema ? { ...entry.meta, inputSchema: entry.inputSchema } : entry.meta;
@@ -1245,11 +1311,24 @@ function buildSurfaceRegistry(context, packageFilter) {
     if (m) meta[binding] = m;
   }
   const formatters = {};
+  const boundResolvers = {};
+  const positional = {};
   for (const [binding, entry] of Object.entries(entries)) {
     const f = normalizeFormatter(entry, surface);
     if (f) formatters[binding] = f;
-  }
-  return buildRegistry({ sdk: surface, meta, formatters, packageFilter });
+    const r = normalizeBoundResolvers(entry);
+    if (r) boundResolvers[binding] = r;
+    const p = methodPositional(entry);
+    if (p) positional[binding] = p;
+  }
+  return buildRegistry({
+    sdk: surface,
+    meta,
+    formatters,
+    boundResolvers,
+    positional,
+    packageFilter
+  });
 }
 var dangerousContextPlugin = {
   pluginType: "property",
@@ -1366,15 +1445,15 @@ function collectPlugins(root, materialized = /* @__PURE__ */ new Set()) {
   }
   return byId;
 }
-function bindValue(target, key, entry) {
+function bindValue(target, key2, entry) {
   if (entry.pluginType === "property" && entry.getValue) {
-    Object.defineProperty(target, key, {
+    Object.defineProperty(target, key2, {
       get: entry.getValue,
       enumerable: true,
       configurable: true
     });
   } else {
-    Object.defineProperty(target, key, {
+    Object.defineProperty(target, key2, {
       value: entry.value,
       writable: true,
       enumerable: true,
@@ -1426,8 +1505,7 @@ function bindResolver(resolver, plugins) {
     case "static":
       return {
         type: "static",
-        requireParams: resolver.requireParams,
-        requireCapabilities: resolver.requireCapabilities,
+        requireParameters: resolver.requireParameters,
         inputType: resolver.inputType,
         placeholder: resolver.placeholder
       };
@@ -1435,8 +1513,7 @@ function bindResolver(resolver, plugins) {
       return {
         type: "constant",
         value: resolver.value,
-        requireParams: resolver.requireParams,
-        requireCapabilities: resolver.requireCapabilities
+        requireParameters: resolver.requireParameters
       };
     case "info":
       return { type: "info", text: resolver.text };
@@ -1444,24 +1521,24 @@ function bindResolver(resolver, plugins) {
       const imports = buildImports(plugins, resolver.importBindings);
       const bound = {
         type: "object",
-        requireParams: resolver.requireParams,
-        requireCapabilities: resolver.requireCapabilities
+        requireParameters: resolver.requireParameters
       };
       if (resolver.properties)
         bound.properties = bindFields(resolver.properties, plugins);
       if (resolver.definitions)
         bound.definitions = bindDefinitions(resolver.definitions, plugins);
-      const { fetch: fetch2 } = resolver;
-      if (fetch2) bound.fetch = ({ params }) => fetch2({ imports, params });
+      const { getProperties } = resolver;
+      if (getProperties)
+        bound.getProperties = ({ input }) => getProperties({ imports, input });
       return bound;
     }
     case "array": {
       const bound = {
         type: "array",
-        requireParams: resolver.requireParams,
-        requireCapabilities: resolver.requireCapabilities,
+        requireParameters: resolver.requireParameters,
         minItems: resolver.minItems,
         maxItems: resolver.maxItems,
+        itemValueType: resolver.itemValueType,
         items: isResolverRef(resolver.items) ? resolver.items : bindResolver(resolver.items, plugins)
       };
       if (resolver.definitions)
@@ -1472,17 +1549,26 @@ function bindResolver(resolver, plugins) {
       const imports = buildImports(plugins, resolver.importBindings);
       const bound = {
         type: "dynamic",
-        requireParams: resolver.requireParams,
-        requireCapabilities: resolver.requireCapabilities,
+        requireParameters: resolver.requireParameters,
         inputType: resolver.inputType,
         placeholder: resolver.placeholder,
         prompt: resolver.prompt
       };
-      const { fetch: fetch2, tryResolveWithoutPrompt } = resolver;
-      if (fetch2)
-        bound.fetch = ({ params, search }) => fetch2({ imports, params, search });
+      const {
+        getContext: getContext2,
+        listItems,
+        tryResolveWithoutPrompt,
+        tryResolveFromSearch
+      } = resolver;
+      if (getContext2)
+        bound.getContext = ({ input }) => getContext2({ imports, input });
+      if (listItems)
+        bound.listItems = ({ input, context, search, cursor }) => listItems({ imports, input, context, search, cursor });
       if (tryResolveWithoutPrompt) {
-        bound.tryResolveWithoutPrompt = ({ params }) => tryResolveWithoutPrompt({ imports, params });
+        bound.tryResolveWithoutPrompt = ({ input }) => tryResolveWithoutPrompt({ imports, input });
+      }
+      if (tryResolveFromSearch) {
+        bound.tryResolveFromSearch = ({ input, search }) => tryResolveFromSearch({ imports, input, search });
       }
       return bound;
     }
@@ -1490,8 +1576,8 @@ function bindResolver(resolver, plugins) {
 }
 function bindFields(fields, plugins) {
   const out = {};
-  for (const [key, field] of Object.entries(fields)) {
-    out[key] = {
+  for (const [key2, field] of Object.entries(fields)) {
+    out[key2] = {
       ...field,
       resolver: isResolverRef(field.resolver) ? field.resolver : bindResolver(field.resolver, plugins)
     };
@@ -1500,17 +1586,17 @@ function bindFields(fields, plugins) {
 }
 function bindDefinitions(definitions, plugins) {
   const out = {};
-  for (const [key, def] of Object.entries(definitions)) {
-    out[key] = bindResolver(def, plugins);
+  for (const [key2, def] of Object.entries(definitions)) {
+    out[key2] = bindResolver(def, plugins);
   }
   return out;
 }
 function bindFormatter(formatter, plugins) {
   const imports = buildImports(plugins, formatter.importBindings);
   const bound = { format: formatter.format };
-  const { fetchContext } = formatter;
-  if (fetchContext)
-    bound.fetchContext = ({ items, input, context }) => fetchContext({ imports, items, input, context });
+  const { getContext: getContext2 } = formatter;
+  if (getContext2)
+    bound.getContext = ({ items, input, context }) => getContext2({ imports, items, input, context });
   return bound;
 }
 function bindAttachments(descriptors, context) {
@@ -1558,6 +1644,7 @@ function runLegacyPass(descriptors, context) {
         const sdk = this ?? exports;
         const meta2 = {};
         const formatters = {};
+        const boundResolvers = {};
         for (const [binding, id2] of Object.entries(context.surface)) {
           const entry = context.plugins[id2];
           if (!entry || entry.pluginType === "aggregate") continue;
@@ -1565,12 +1652,15 @@ function runLegacyPass(descriptors, context) {
           if (m) meta2[binding] = m;
           const f = normalizeFormatter(entry, sdk);
           if (f) formatters[binding] = f;
+          const r = normalizeBoundResolvers(entry);
+          if (r) boundResolvers[binding] = r;
         }
         Object.assign(meta2, context.meta);
         return buildRegistry({
           sdk,
           meta: meta2,
           formatters,
+          boundResolvers,
           packageFilter: options?.package
         });
       };
@@ -1786,7 +1876,7 @@ function createSdk(root) {
       pluginSurface = {};
       bindValue(pluginSurface, plugin.name, plugins2[plugin.id]);
     }
-    for (const key of Object.keys(legacyExports)) context.surface[key] = key;
+    for (const key2 of Object.keys(legacyExports)) context.surface[key2] = key2;
     if (plugin.pluginType === "aggregate") {
       recordExportSurface(context, plugin.exports);
     } else {
@@ -1856,6 +1946,756 @@ function addPlugin(sdk, plugin, options) {
     options ?? {}
   );
 }
+var CORE_SIGNAL_SYMBOL = Symbol.for("kitcore.signal");
+var CoreSignal = class extends Error {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, new.target.prototype);
+    Object.defineProperty(this, CORE_SIGNAL_SYMBOL, {
+      value: true,
+      enumerable: false,
+      configurable: true,
+      writable: false
+    });
+  }
+};
+function isCoreSignal(value) {
+  return Boolean(
+    value && typeof value === "object" && value[CORE_SIGNAL_SYMBOL] === true
+  );
+}
+var CoreCancelledSignal = class extends CoreSignal {
+  constructor(message = "resolution cancelled") {
+    super(message);
+    this.name = "CoreCancelledSignal";
+    this.code = "CANCELLED";
+  }
+};
+function unwrap(schema) {
+  let inner = schema;
+  let required = true;
+  for (; ; ) {
+    if (inner instanceof z.ZodOptional) {
+      required = false;
+      inner = inner._zod.def.innerType;
+    } else if (inner instanceof z.ZodDefault) {
+      required = false;
+      inner = inner._zod.def.innerType;
+    } else if (inner instanceof z.ZodNullable) {
+      inner = inner._zod.def.innerType;
+    } else {
+      break;
+    }
+  }
+  return { inner, required };
+}
+function valueTypeOf(inner) {
+  if (inner instanceof z.ZodString) return "string";
+  if (inner instanceof z.ZodNumber) return "number";
+  if (inner instanceof z.ZodBoolean) return "boolean";
+  if (inner instanceof z.ZodEnum) return "string";
+  if (inner instanceof z.ZodArray) return "array";
+  if (inner instanceof z.ZodObject) return "object";
+  return void 0;
+}
+function staticChoicesOf(inner) {
+  if (inner instanceof z.ZodEnum) {
+    const values = inner.options;
+    return values.map((value) => ({ label: value, value }));
+  }
+  return void 0;
+}
+function objectShape(schema) {
+  const { inner } = schema ? unwrap(schema) : { inner: void 0 };
+  if (inner instanceof z.ZodObject) {
+    return inner.shape;
+  }
+  return void 0;
+}
+function topoOrder2(specs) {
+  const byName = new Map(specs.map((s) => [s.name, s]));
+  const ordered = [];
+  const placed = /* @__PURE__ */ new Set();
+  let progressed = true;
+  while (ordered.length < specs.length && progressed) {
+    progressed = false;
+    for (const spec of specs) {
+      if (placed.has(spec.name)) continue;
+      const ready = spec.requires.every((r) => !byName.has(r) || placed.has(r));
+      if (ready) {
+        ordered.push(spec);
+        placed.add(spec.name);
+        progressed = true;
+      }
+    }
+  }
+  for (const spec of specs) if (!placed.has(spec.name)) ordered.push(spec);
+  return ordered;
+}
+function planParameters(entry) {
+  const shape = objectShape(entry.inputSchema);
+  const resolvers = entry.boundResolvers ?? {};
+  const names = shape ? Object.keys(shape) : Object.keys(resolvers);
+  const specs = names.map((name) => {
+    const field = shape?.[name];
+    const { inner, required } = field ? unwrap(field) : { inner: void 0, required: false };
+    const resolver = resolvers[name];
+    return {
+      name,
+      required,
+      valueType: inner ? valueTypeOf(inner) : void 0,
+      staticChoices: inner ? staticChoicesOf(inner) : void 0,
+      resolver,
+      requires: resolver?.requireParameters ?? []
+    };
+  });
+  return { parameters: topoOrder2(specs) };
+}
+function getAtPath(root, path) {
+  let node = root;
+  for (const seg of path) {
+    if (node == null || typeof node !== "object") return void 0;
+    node = node[seg];
+  }
+  return node;
+}
+function setAtPath(root, path, value) {
+  let node = root;
+  for (let i = 0; i < path.length - 1; i++) {
+    const seg = path[i];
+    if (node[seg] == null || typeof node[seg] !== "object") node[seg] = {};
+    node = node[seg];
+  }
+  node[path[path.length - 1]] = value;
+}
+var key = (path) => path.join(".");
+function isSettled(state, path) {
+  return state.settled.includes(key(path));
+}
+function settle(state, path) {
+  const k = key(path);
+  if (!state.settled.includes(k)) state.settled.push(k);
+}
+function clone(state) {
+  return JSON.parse(JSON.stringify(state));
+}
+function coerce(leaf, raw) {
+  if (typeof raw !== "string") return raw;
+  if (leaf.valueType === "number") {
+    const n = Number(raw);
+    return raw.trim() !== "" && !Number.isNaN(n) ? n : raw;
+  }
+  if (leaf.valueType === "boolean") {
+    if (raw === "true") return true;
+    if (raw === "false") return false;
+  }
+  return raw;
+}
+async function validationError(leaf, value, state) {
+  const context = await resolveContext(leaf, state.resolved);
+  const config = leaf.resolver?.prompt?.({
+    items: state.listing?.items ?? [],
+    input: mergeInput(state.resolved, leaf.extraInput),
+    context
+  });
+  if (!config?.validate) return null;
+  const verdict = config.validate(value);
+  if (verdict === true) return null;
+  return typeof verdict === "string" ? verdict : `${leaf.name}: invalid value`;
+}
+function toChoice(c) {
+  const label = "label" in c ? c.label : c.name;
+  const hint = Array.isArray(c.hint) ? c.hint.join(", ") : c.hint;
+  return { label, value: String(c.value), hint };
+}
+function isRef(r) {
+  return typeof r === "object" && r !== null && "ref" in r;
+}
+function toLeaf(name, field, definitions) {
+  let resolver;
+  let extraInput;
+  if (isRef(field.resolver)) {
+    resolver = definitions?.[field.resolver.ref];
+    extraInput = field.resolver.input;
+  } else {
+    resolver = field.resolver;
+  }
+  return {
+    name,
+    required: field.required ?? false,
+    resolver,
+    extraInput,
+    // Carry the field's value type so nested answers coerce (number/boolean)
+    // the same way top-level params do. Without this a nested `z.number()`
+    // field's typed answer stays a string and fails final validation.
+    valueType: field.valueType,
+    requires: resolver?.requireParameters ?? []
+  };
+}
+async function objectChildren(resolver, input) {
+  if (resolver.properties) {
+    return Object.entries(resolver.properties).map(
+      ([name, field]) => toLeaf(name, field, resolver.definitions)
+    );
+  }
+  if (!resolver.getProperties) return [];
+  const fields = await resolver.getProperties({ input });
+  return Object.entries(fields).map(([name, field]) => {
+    if (!isRef(field.resolver) && (field.resolver.imports?.length ?? 0) > 0) {
+      throw new Error(
+        `dynamic object field "${name}" inlines an import-bearing resolver; use { ref } into the object's definitions so its imports bind`
+      );
+    }
+    return toLeaf(name, field, resolver.definitions);
+  });
+}
+function arrayItem(resolver) {
+  const items = resolver.items;
+  const valueType = resolver.itemValueType;
+  if (isRef(items)) {
+    return {
+      name: "",
+      required: true,
+      resolver: resolver.definitions?.[items.ref],
+      extraInput: items.input,
+      valueType,
+      requires: []
+    };
+  }
+  return {
+    name: "",
+    required: true,
+    resolver: items,
+    valueType,
+    requires: []
+  };
+}
+function mergeInput(input, extra) {
+  return extra ? { ...input, ...extra } : input;
+}
+async function childrenAt(ctx, path, resolved) {
+  if (path.length === 0) return ctx.parameters;
+  const leaf = await leafAt(ctx, path, resolved);
+  if (!leaf?.resolver || leaf.resolver.type !== "object") return [];
+  return objectChildren(leaf.resolver, mergeInput(resolved, leaf.extraInput));
+}
+async function leafAt(ctx, path, resolved) {
+  let children = ctx.parameters;
+  let leaf;
+  for (let i = 0; i < path.length; i++) {
+    const seg = path[i];
+    if (typeof seg === "number") {
+      if (leaf?.resolver?.type !== "array") return void 0;
+      leaf = arrayItem(leaf.resolver);
+    } else {
+      leaf = children.find((c) => c.name === seg);
+      if (!leaf) return void 0;
+    }
+    if (i < path.length - 1 && typeof path[i + 1] === "string") {
+      if (leaf?.resolver?.type !== "object") return void 0;
+      children = await objectChildren(
+        leaf.resolver,
+        mergeInput(resolved, leaf.extraInput)
+      );
+    }
+  }
+  return leaf;
+}
+async function arrayInfoAt(ctx, path, resolved) {
+  const leaf = await leafAt(ctx, path, resolved);
+  const resolver = leaf?.resolver;
+  if (resolver?.type !== "array") {
+    throw new Error(`expected an array resolver at "${key(path)}"`);
+  }
+  return {
+    min: resolver.minItems ?? 0,
+    max: resolver.maxItems ?? Infinity,
+    item: { ...arrayItem(resolver), name: String(path[path.length - 1]) }
+  };
+}
+var AFFORDANCE = {
+  choose: { action: "choose", description: "Pick one of the listed options" },
+  custom: {
+    action: "custom",
+    description: "Provide a value directly",
+    supply: "value"
+  },
+  search: {
+    action: "search",
+    description: "Filter the options by a search term",
+    supply: "term"
+  },
+  more: { action: "more", description: "Load more options" },
+  skip: { action: "skip", description: "Omit this optional parameter" },
+  add: { action: "add", description: "Add another item" },
+  done: { action: "done", description: "Finish the list" },
+  retry: { action: "retry", description: "Retry loading the options" },
+  cancel: { action: "cancel", description: "Cancel resolution" }
+};
+async function firstPage(result) {
+  const page = await result;
+  return {
+    data: Array.isArray(page?.data) ? page.data : [],
+    nextCursor: page?.nextCursor
+  };
+}
+async function resolveContext(leaf, input) {
+  return leaf.resolver?.getContext?.({
+    input: mergeInput(input, leaf.extraInput)
+  });
+}
+async function fetchListing(leaf, input, opts = {}) {
+  const page = await firstPage(
+    leaf.resolver?.listItems?.({
+      input: mergeInput(input, leaf.extraInput),
+      context: opts.context,
+      search: opts.search,
+      cursor: opts.cursor
+    })
+  );
+  return {
+    items: [...opts.priorItems ?? [], ...page.data],
+    cursor: page.nextCursor,
+    search: opts.search,
+    exhausted: page.nextCursor == null
+  };
+}
+function selectActions(leaf, listing, multiple) {
+  const actions = multiple ? [AFFORDANCE.choose] : [AFFORDANCE.choose, AFFORDANCE.custom];
+  if (leaf.resolver?.inputType === "search") actions.push(AFFORDANCE.search);
+  if (listing.cursor) actions.push(AFFORDANCE.more);
+  if (!leaf.required) actions.push(AFFORDANCE.skip);
+  return actions;
+}
+function selectQuestion(leaf, input, listing, context) {
+  const config = leaf.resolver?.prompt?.({
+    items: listing.items,
+    input: mergeInput(input, leaf.extraInput),
+    context
+  });
+  const multiple = config?.type === "checkbox";
+  return {
+    type: "select",
+    message: config?.message ?? `Select ${leaf.name}:`,
+    choices: (config?.choices ?? []).map(toChoice),
+    ...multiple ? { multiple: true } : {},
+    ...config?.notes?.length ? { notes: config.notes } : {},
+    actions: selectActions(leaf, listing, multiple)
+  };
+}
+function toControllerError(error) {
+  if (error instanceof Error) {
+    const code = error.code;
+    return {
+      name: error.name,
+      message: error.message,
+      ...typeof code === "string" ? { code } : {}
+    };
+  }
+  return { name: "Error", message: String(error) };
+}
+function failedResult(state, name, error) {
+  return {
+    state,
+    result: {
+      status: "failed",
+      error: toControllerError(error),
+      question: {
+        type: "select",
+        message: `Could not load options for ${name}.`,
+        choices: [],
+        actions: [AFFORDANCE.retry, AFFORDANCE.cancel]
+      }
+    }
+  };
+}
+async function buildQuestion(leaf, input) {
+  const optional = !leaf.required;
+  const resolver = leaf.resolver;
+  if (resolver?.listItems) {
+    const context = await resolveContext(leaf, input);
+    const listing = await fetchListing(leaf, input, { context });
+    return {
+      question: selectQuestion(leaf, input, listing, context),
+      listing
+    };
+  }
+  if (leaf.staticChoices) {
+    const actions2 = [AFFORDANCE.choose];
+    if (optional) actions2.push(AFFORDANCE.skip);
+    return {
+      question: {
+        type: "select",
+        message: `Select ${leaf.name}:`,
+        choices: leaf.staticChoices,
+        actions: actions2
+      }
+    };
+  }
+  const inputType = resolver?.inputType && resolver.inputType !== "search" ? resolver.inputType : "text";
+  const actions = [AFFORDANCE.custom];
+  if (optional) actions.push(AFFORDANCE.skip);
+  return {
+    question: {
+      type: "input",
+      message: `Enter ${leaf.name}:`,
+      inputType,
+      placeholder: resolver?.placeholder,
+      actions
+    }
+  };
+}
+function finalize(ctx, resolved) {
+  if (!ctx.schema) return { status: "done", value: resolved };
+  const parsed = ctx.schema.safeParse(resolved);
+  if (parsed.success) {
+    return { status: "done", value: parsed.data };
+  }
+  const issues = parsed.error.issues.map((i) => ({
+    parameter: i.path.map(String).join(".") || void 0,
+    message: i.message
+  }));
+  return { status: "invalid", issues };
+}
+function collectionQuestion(t) {
+  const actions = [AFFORDANCE.add];
+  if (t.count >= t.min) actions.push(AFFORDANCE.done);
+  return {
+    type: "collection",
+    message: `Add another ${t.path[t.path.length - 1]}? (${t.count} so far)`,
+    count: t.count,
+    min: t.min,
+    // An unbounded array's max is Infinity, which JSON.stringify turns to null;
+    // omit it so the question round-trips across the wall as plain data.
+    ...Number.isFinite(t.max) ? { max: t.max } : {},
+    actions
+  };
+}
+async function findInArray(ctx, state, path) {
+  if (isSettled(state, path)) return null;
+  if (getAtPath(state.resolved, path) == null)
+    setAtPath(state.resolved, path, []);
+  if (!state.interactive) {
+    settle(state, path);
+    return null;
+  }
+  const { min, max, item } = await arrayInfoAt(ctx, path, state.resolved);
+  const items = getAtPath(state.resolved, path);
+  const len = items.length;
+  const itemType = item.resolver?.type;
+  if (len > 0 && (itemType === "object" || itemType === "array")) {
+    const inner = await findNext(ctx, state, [...path, len - 1]);
+    if (inner) return inner;
+  }
+  if (len < min) return descendItem(ctx, state, path, len, item);
+  if (len < max) return { kind: "array", path, count: len, min, max };
+  settle(state, path);
+  return null;
+}
+function seedItemSlot(state, itemPath, item) {
+  const type = item.resolver?.type;
+  if (type === "object") {
+    setAtPath(state.resolved, itemPath, {});
+    return "object";
+  }
+  if (type === "array") {
+    setAtPath(state.resolved, itemPath, []);
+    return "array";
+  }
+  return "leaf";
+}
+async function descendItem(ctx, state, arrayPath, index, item) {
+  const itemPath = [...arrayPath, index];
+  const kind = seedItemSlot(state, itemPath, item);
+  if (kind === "object") return findNext(ctx, state, itemPath);
+  if (kind === "array") return findInArray(ctx, state, itemPath);
+  return { kind: "leaf", path: itemPath, leaf: item };
+}
+async function findNext(ctx, state, path = []) {
+  const container = getAtPath(state.resolved, path) ?? {};
+  for (const leaf of await childrenAt(ctx, path, state.resolved)) {
+    const childPath = [...path, leaf.name];
+    if (!leaf.requires.every((r) => container[r] !== void 0)) continue;
+    if (leaf.resolver?.type === "object") {
+      if (getAtPath(state.resolved, childPath) == null)
+        setAtPath(state.resolved, childPath, {});
+      const inner = await findNext(ctx, state, childPath);
+      if (inner) return inner;
+      continue;
+    }
+    if (leaf.resolver?.type === "array") {
+      const inner = await findInArray(ctx, state, childPath);
+      if (inner) return inner;
+      continue;
+    }
+    if (container[leaf.name] !== void 0 || isSettled(state, childPath))
+      continue;
+    return { kind: "leaf", path: childPath, leaf };
+  }
+  return null;
+}
+async function askLeaf(state, path, leaf, opts = {}) {
+  state.current = path;
+  try {
+    const { question, listing } = await buildQuestion(leaf, state.resolved);
+    state.listing = listing;
+    return {
+      state,
+      result: {
+        status: "ask",
+        question,
+        ...opts.error ? { error: opts.error } : {}
+      }
+    };
+  } catch (error) {
+    state.listing = { items: [], exhausted: false };
+    return failedResult(state, leaf.name, error);
+  }
+}
+async function advance(ctx, state) {
+  for (; ; ) {
+    const target = await findNext(ctx, state);
+    if (!target) {
+      delete state.current;
+      delete state.listing;
+      return { state, result: finalize(ctx, state.resolved) };
+    }
+    if (target.kind === "array") {
+      state.current = target.path;
+      delete state.listing;
+      return {
+        state,
+        result: { status: "ask", question: collectionQuestion(target) }
+      };
+    }
+    const { path, leaf } = target;
+    const auto = await leaf.resolver?.tryResolveWithoutPrompt?.({
+      input: mergeInput(state.resolved, leaf.extraInput)
+    });
+    if (auto) {
+      if (auto.resolvedValue !== void 0)
+        setAtPath(state.resolved, path, auto.resolvedValue);
+      settle(state, path);
+      continue;
+    }
+    if (!state.interactive) {
+      if (!leaf.required) {
+        settle(state, path);
+        continue;
+      }
+    } else if (!leaf.required && !leaf.resolver) {
+      settle(state, path);
+      continue;
+    }
+    return askLeaf(state, path, leaf);
+  }
+}
+async function start(ctx, input = {}, interactive = true) {
+  const resolved = {};
+  for (const spec of ctx.parameters) {
+    if (spec.resolver?.type === "constant")
+      resolved[spec.name] = spec.resolver.value;
+  }
+  Object.assign(resolved, input);
+  return advance(ctx, {
+    method: ctx.method,
+    resolved,
+    settled: [],
+    interactive
+  });
+}
+async function step(ctx, prior, action) {
+  const state = clone(prior);
+  if (action.type === "cancel") {
+    delete state.current;
+    delete state.listing;
+    return { state, result: { status: "cancelled" } };
+  }
+  const path = state.current;
+  if (!path) throw new Error("step called with no outstanding question");
+  const leaf = await leafAt(ctx, path, state.resolved);
+  if (leaf && (action.type === "search" || action.type === "more" || action.type === "retry")) {
+    return refine(ctx, state, leaf, path, action);
+  }
+  if (action.type === "add" || action.type === "done") {
+    delete state.current;
+    delete state.listing;
+    if (action.type === "done") {
+      settle(state, path);
+      return advance(ctx, state);
+    }
+    const items = getAtPath(state.resolved, path) ?? [];
+    const { item } = await arrayInfoAt(ctx, path, state.resolved);
+    const itemPath = [...path, items.length];
+    if (seedItemSlot(state, itemPath, item) === "leaf")
+      return askLeaf(state, itemPath, item);
+    return advance(ctx, state);
+  }
+  switch (action.type) {
+    case "choose":
+    case "custom": {
+      if (leaf) {
+        const error = await validationError(leaf, action.value, state);
+        if (error) return askLeaf(state, path, leaf, { error });
+      }
+      setAtPath(
+        state.resolved,
+        path,
+        leaf ? coerce(leaf, action.value) : action.value
+      );
+      break;
+    }
+    case "skip":
+      settle(state, path);
+      break;
+    default:
+      throw new Error(`action "${action.type}" is not supported here`);
+  }
+  delete state.current;
+  delete state.listing;
+  return advance(ctx, state);
+}
+async function refine(ctx, state, leaf, path, action) {
+  const attempt = action.type === "search" ? { search: action.term, cursor: void 0, priorItems: [] } : {
+    search: state.listing?.search,
+    cursor: state.listing?.cursor,
+    priorItems: state.listing?.items ?? []
+  };
+  try {
+    if (action.type === "search") {
+      const exact = await leaf.resolver?.tryResolveFromSearch?.({
+        input: mergeInput(state.resolved, leaf.extraInput),
+        search: action.term
+      });
+      if (exact) {
+        setAtPath(state.resolved, path, coerce(leaf, exact.resolvedValue));
+        delete state.current;
+        delete state.listing;
+        return advance(ctx, state);
+      }
+    }
+    const context = await resolveContext(leaf, state.resolved);
+    state.listing = await fetchListing(leaf, state.resolved, {
+      ...attempt,
+      context
+    });
+    return {
+      state,
+      result: {
+        status: "ask",
+        question: selectQuestion(leaf, state.resolved, state.listing, context)
+      }
+    };
+  } catch (error) {
+    state.listing = {
+      items: attempt.priorItems,
+      search: attempt.search,
+      cursor: attempt.cursor,
+      exhausted: false
+    };
+    return failedResult(state, leaf.name, error);
+  }
+}
+function toJsonSchema(schema) {
+  if (!schema) return void 0;
+  try {
+    return z.toJSONSchema(schema);
+  } catch {
+    return void 0;
+  }
+}
+function projectSummary(entry) {
+  return {
+    name: entry.name,
+    ...entry.description ? { description: entry.description } : {},
+    ...entry.categories?.length ? { categories: entry.categories } : {}
+  };
+}
+function projectMethod(entry) {
+  const inputProperties = toJsonSchema(entry.inputSchema)?.properties;
+  const parameters = {};
+  for (const spec of planParameters(entry).parameters) {
+    parameters[spec.name] = {
+      required: spec.required,
+      dynamic: Boolean(spec.resolver?.listItems),
+      ...spec.resolver?.inputType === "search" ? { searchable: true } : {},
+      ...inputProperties?.[spec.name] ? { schema: inputProperties[spec.name] } : {},
+      ...spec.staticChoices ? { choices: spec.staticChoices } : {},
+      ...spec.requires.length ? { requireParameters: spec.requires } : {}
+    };
+  }
+  const output = toJsonSchema(entry.outputSchema);
+  return {
+    name: entry.name,
+    ...entry.description ? { description: entry.description } : {},
+    ...entry.categories?.length ? { categories: entry.categories } : {},
+    parameters,
+    ...entry.positional?.length ? { positional: entry.positional } : {},
+    ...output ? { output } : {}
+  };
+}
+function createController(sdk) {
+  function entryFor(method) {
+    const entry = sdk.getRegistry().functions.find((f) => f.name === method);
+    if (!entry) throw new Error(`unknown method "${method}"`);
+    return entry;
+  }
+  function contextFor(method) {
+    const entry = entryFor(method);
+    return {
+      method,
+      schema: entry.inputSchema,
+      parameters: planParameters(entry).parameters
+    };
+  }
+  const start2 = ({ method, input, interactive }) => start(contextFor(method), input, interactive);
+  const step2 = ({ state, action }) => step(contextFor(state.method), state, action);
+  const resolve2 = async ({
+    method,
+    input,
+    answer,
+    interactive
+  }) => {
+    const ctx = contextFor(method);
+    let { state, result } = await start(ctx, input, interactive);
+    while (result.status === "ask" || result.status === "failed") {
+      const action = await answer({ state, result });
+      ({ state, result } = await step(ctx, state, action));
+    }
+    if (result.status === "done") return result.value;
+    if (result.status === "cancelled") {
+      throw new CoreCancelledSignal(`resolution cancelled for "${method}"`);
+    }
+    const detail = result.issues.map((i) => i.parameter ? `${i.parameter}: ${i.message}` : i.message).join("; ");
+    throw new Error(`invalid input for "${method}": ${detail}`);
+  };
+  const listMethods = () => ({
+    data: sdk.getRegistry().functions.map(projectSummary)
+  });
+  const getMethod = ({ method }) => ({
+    data: projectMethod(entryFor(method))
+  });
+  const listChoices = async ({
+    method,
+    parameter,
+    input = {},
+    search,
+    cursor
+  }) => {
+    const spec = contextFor(method).parameters.find(
+      (p) => p.name === parameter
+    );
+    if (!spec?.resolver?.listItems) return { data: [] };
+    const context = await spec.resolver.getContext?.({ input });
+    const page = await firstPage(
+      spec.resolver.listItems({ input, context, search, cursor })
+    );
+    const config = spec.resolver.prompt?.({ items: page.data, input, context });
+    const data = (config?.choices ?? []).map(toChoice);
+    return { data, nextCursor: page.nextCursor };
+  };
+  return { resolve: resolve2, start: start2, step: step2, listMethods, getMethod, listChoices };
+}
 function createCorePlugin(options) {
   return () => ({
     context: {
@@ -2823,8 +3663,8 @@ function normalizeHeaders(optionsHeaders) {
     return headers;
   }
   const headerEntries = optionsHeaders instanceof Headers ? Array.from(optionsHeaders.entries()) : Array.isArray(optionsHeaders) ? optionsHeaders : Object.entries(optionsHeaders);
-  for (const [key, value] of headerEntries) {
-    headers[key] = value;
+  for (const [key2, value] of headerEntries) {
+    headers[key2] = value;
   }
   return headers;
 }
@@ -3114,28 +3954,28 @@ function censorHeaders(headers) {
   if (!headers) return headers;
   const headersObj = new Headers(headers);
   const authKeys = ["authorization", "x-api-key"];
-  for (const [key, value] of headersObj.entries()) {
-    if (authKeys.some((authKey) => key.toLowerCase() === authKey)) {
+  for (const [key2, value] of headersObj.entries()) {
+    if (authKeys.some((authKey) => key2.toLowerCase() === authKey)) {
       const spaceIndex = value.indexOf(" ");
       if (spaceIndex > 0 && spaceIndex < value.length - 1) {
         const prefix = value.substring(0, spaceIndex + 1);
         const token = value.substring(spaceIndex + 1);
         if (token.length > 12) {
-          const start = token.substring(0, 4);
+          const start2 = token.substring(0, 4);
           const end = token.substring(token.length - 4);
-          headersObj.set(key, `${prefix}${start}...${end}`);
+          headersObj.set(key2, `${prefix}${start2}...${end}`);
         } else {
           const firstChar = token.charAt(0);
-          headersObj.set(key, `${prefix}${firstChar}...`);
+          headersObj.set(key2, `${prefix}${firstChar}...`);
         }
       } else {
         if (value.length > 12) {
-          const start = value.substring(0, 4);
+          const start2 = value.substring(0, 4);
           const end = value.substring(value.length - 4);
-          headersObj.set(key, `${start}...${end}`);
+          headersObj.set(key2, `${start2}...${end}`);
         } else {
           const firstChar = value.charAt(0);
-          headersObj.set(key, `${firstChar}...`);
+          headersObj.set(key2, `${firstChar}...`);
         }
       }
     }
@@ -3704,21 +4544,21 @@ function getClientIdFromCredentials(credentials) {
 function createMemoryCache() {
   const store = /* @__PURE__ */ new Map();
   return {
-    async get(key) {
-      const entry = store.get(key);
+    async get(key2) {
+      const entry = store.get(key2);
       if (!entry) return void 0;
       if (entry.expiresAt !== void 0 && entry.expiresAt <= Date.now()) {
-        store.delete(key);
+        store.delete(key2);
         return void 0;
       }
       return { value: entry.value, expiresAt: entry.expiresAt };
     },
-    async set(key, value, options) {
+    async set(key2, value, options) {
       const expiresAt = options?.ttl ? Date.now() + options.ttl * 1e3 : void 0;
-      store.set(key, { value, expiresAt });
+      store.set(key2, { value, expiresAt });
     },
-    async delete(key) {
-      store.delete(key);
+    async delete(key2) {
+      store.delete(key2);
     }
   };
 }
@@ -4209,14 +5049,14 @@ function createSseParserStream() {
     transform(chunk, controller) {
       buffer += chunk;
       const newline = /\r\n|\r|\n/g;
-      let start = 0;
+      let start2 = 0;
       let match;
       while ((match = newline.exec(buffer)) !== null) {
         if (match[0] === "\r" && match.index === buffer.length - 1) break;
-        processLine(buffer.slice(start, match.index), controller);
-        start = match.index + match[0].length;
+        processLine(buffer.slice(start2, match.index), controller);
+        start2 = match.index + match[0].length;
       }
-      buffer = buffer.slice(start);
+      buffer = buffer.slice(start2);
     },
     flush(controller) {
       if (buffer.endsWith("\r")) {
@@ -4318,8 +5158,63 @@ function parseApprovalReviewStreamPayload(parsed, toolNames) {
   }
 }
 
+// src/api/deprecation.ts
+var DEPRECATION_MESSAGE_HEADER = "zapier-sdk-deprecation-message";
+var DEPRECATION_ID_HEADER = "zapier-sdk-deprecation-id";
+var DEPRECATION_NOTICE_EVENT = "api:deprecation_notice";
+var displayedNoticeIds = /* @__PURE__ */ new Set();
+function handleDeprecationNotice({
+  response,
+  canSendDeprecationMessaging,
+  onEvent
+}) {
+  try {
+    sniffDeprecationNotice({ response, canSendDeprecationMessaging, onEvent });
+  } catch {
+  }
+}
+function sniffDeprecationNotice({
+  response,
+  canSendDeprecationMessaging,
+  onEvent
+}) {
+  if (!canSendDeprecationMessaging) return;
+  const message = response.headers?.get(DEPRECATION_MESSAGE_HEADER);
+  if (!message) return;
+  const id = response.headers.get(DEPRECATION_ID_HEADER) ?? message;
+  if (!displayedNoticeIds.has(id)) {
+    displayedNoticeIds.add(id);
+    console.warn(`[zapier-sdk] Deprecation: ${message}`);
+  }
+  if (onEvent) {
+    const payload = { id, message };
+    const deprecation = parseDeprecationDate(
+      response.headers.get("deprecation")
+    );
+    if (deprecation !== void 0) payload.deprecation = deprecation;
+    const maybePromise = onEvent({
+      type: DEPRECATION_NOTICE_EVENT,
+      payload: { ...payload },
+      timestamp: Date.now()
+    });
+    if (isPromiseLike(maybePromise)) {
+      void Promise.resolve(maybePromise).catch(() => {
+      });
+    }
+  }
+}
+function isPromiseLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
+}
+function parseDeprecationDate(value) {
+  if (!value) return void 0;
+  const match = /^@(-?\d+)$/.exec(value.trim());
+  if (!match) return void 0;
+  return Number(match[1]) * 1e3;
+}
+
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.78.0" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.80.0" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -4431,6 +5326,30 @@ var PollApprovalResponseSchema = z.object({
   reason: z.string().optional()
 });
 var APPROVAL_MAX_POLLING_INTERVAL_MS = 5e3;
+function validateSdkPath(path) {
+  if (!path.startsWith("/") || path.startsWith("//")) {
+    throw new ZapierValidationError(
+      `fetch expects a path starting with a single '/', got: ${path}`
+    );
+  }
+}
+function findPathConfigEntries({
+  path,
+  matchResolvedGatewayPath = false
+}) {
+  const pathSegments = path.split("/").filter(Boolean);
+  return Object.entries(pathConfig).filter(([configPath, config]) => {
+    if (!matchResolvedGatewayPath) {
+      return path === configPath || path.startsWith(`${configPath}/`);
+    }
+    const prefixSegments = (config.pathPrefix ?? configPath).split("/").filter(Boolean);
+    return pathSegments.some(
+      (_, startIndex) => prefixSegments.every(
+        (segment, offset) => pathSegments[startIndex + offset] === segment
+      )
+    );
+  }).map(([configPath, config]) => ({ configPath, config }));
+}
 function parseRateLimitHeaders(response) {
   const info = {};
   const retryAfter = response.headers.get("retry-after");
@@ -4475,8 +5394,18 @@ var pathConfig = {
   // e.g. /relay -> https://sdkapi.zapier.com/api/v0/sdk/relay/...
   "/relay": {
     authHeader: "X-Relay-Authorization",
-    pathPrefix: "/api/v0/sdk/relay"
+    pathPrefix: "/api/v0/sdk/relay",
+    omitDeprecationMessaging: true
+  },
+  // The concrete gateway form of the relay route. Callers that pass the
+  // already-prefixed path reach the same third-party upstreams, so it must
+  // classify as relay too; without this entry it would match nothing and
+  // sniff deprecation headers off a relay response.
+  "/api/v0/sdk/relay": {
+    omitDeprecationMessaging: true
   },
+  // Concrete sdkapi routes that do not live behind /api/v0/sdk/<service>.
+  "/api/v0": {},
   // e.g. /zapier -> https://sdkapi.zapier.com/api/v0/sdk/zapier/...
   "/zapier": {
     authHeader: "Authorization",
@@ -4531,11 +5460,11 @@ var ZapierApiClient = class {
       );
       const inputHeaders = new Headers(init?.headers ?? {});
       const mergedHeaders = new Headers();
-      builtHeaders.forEach((value, key) => {
-        mergedHeaders.set(key, value);
+      builtHeaders.forEach((value, key2) => {
+        mergedHeaders.set(key2, value);
       });
-      inputHeaders.forEach((value, key) => {
-        mergedHeaders.set(key, value);
+      inputHeaders.forEach((value, key2) => {
+        mergedHeaders.set(key2, value);
       });
       this.applyTelemetryHeaders(mergedHeaders);
       let retries = 0;
@@ -4625,17 +5554,50 @@ var ZapierApiClient = class {
      * parallelism into the queue.
      */
     this.rawFetch = async (path, init) => {
-      if (!path.startsWith("/")) {
-        throw new ZapierValidationError(
-          `fetch expects a path starting with '/', got: ${path}`
-        );
-      }
+      validateSdkPath(path);
       const { url, pathConfig: pathConfig2 } = this.buildUrl(path, init?.searchParams);
       return this.withSemaphore(
         { url, method: init?.method ?? "GET", signal: init?.signal },
         () => this.rawFetchUrl(url, init, pathConfig2)
       );
     };
+    this.runApprovalFetchLoop = async ({
+      path,
+      init,
+      maxRetries,
+      approvalMode,
+      approvalContext
+    }) => {
+      for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        const response = await this.rawFetch(path, init);
+        if (response.status !== 403) {
+          return { response };
+        }
+        const errorType = response.headers.get("x-zapier-error-type");
+        if (errorType !== "approval_required") {
+          return { response };
+        }
+        if (attempt === maxRetries) {
+          return { response };
+        }
+        if (approvalMode === "disabled") {
+          return { response };
+        }
+        if (!approvalContext) {
+          return { response };
+        }
+        try {
+          await this.runOneApprovalRound(
+            approvalContext,
+            approvalMode,
+            init?.signal ?? void 0
+          );
+        } catch (error) {
+          return { response, approvalRoundError: error };
+        }
+      }
+      throw new ZapierApiError("Approval retry loop ended unexpectedly");
+    };
     /**
      * Approval-aware HTTP fetch.
      *
@@ -4665,46 +5627,62 @@ var ZapierApiClient = class {
      * `max_retries_exceeded` instead.
      */
     this.fetch = async (path, init) => {
+      validateSdkPath(path);
       const maxRetries = this.options.maxApprovalRetries ?? DEFAULT_MAX_APPROVAL_RETRIES;
-      for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        const response = await this.rawFetch(path, init);
-        if (response.status !== 403) return response;
-        const errorType = response.headers.get("x-zapier-error-type");
-        if (errorType === "request_denied_by_policy") {
-          const { data } = await this.parseResult(response);
-          const { message, errors } = this.parseErrorResponse({
-            status: response.status,
-            statusText: response.statusText,
-            data
-          });
-          throw new ZapierApprovalError(
-            message || "Request explicitly denied by policy",
-            {
-              status: "policy_denied",
-              statusCode: response.status,
-              errors
-            }
-          );
-        }
-        if (errorType !== "approval_required") return response;
-        if (attempt === maxRetries) break;
-        const mode = this.options.approvalMode ?? getZapierApprovalMode() ?? getZapierDefaultApprovalMode();
-        if (mode === "disabled") {
-          throw new ZapierApprovalError(
-            "Approvals are disabled. Set approvalMode to 'poll' or 'throw' (or ZAPIER_APPROVAL_MODE) to enable.",
-            { status: "approval_required" }
-          );
-        }
-        if (!init?.approvalContext) {
-          throw new ZapierApiError(
-            `Received 403 approval_required for ${path}, but the caller did not provide an approvalContext builder. Every approval-capable request must pass approvalContext so the SDK can create the approval with the correct policy context.`,
-            { statusCode: 403 }
-          );
-        }
-        await this.runOneApprovalRound(
-          init.approvalContext,
-          mode,
-          init.signal ?? void 0
+      const { canSendDeprecationMessaging } = this.buildUrl(
+        path,
+        init?.searchParams
+      );
+      const approvalMode = this.options.approvalMode ?? getZapierApprovalMode() ?? getZapierDefaultApprovalMode();
+      const approvalContext = init?.approvalContext;
+      const { response, approvalRoundError } = await this.runApprovalFetchLoop({
+        path,
+        init,
+        maxRetries,
+        approvalMode,
+        approvalContext
+      });
+      handleDeprecationNotice({
+        response,
+        canSendDeprecationMessaging,
+        onEvent: this.options.onEvent
+      });
+      if (response.status !== 403) {
+        return response;
+      }
+      const errorType = response.headers.get("x-zapier-error-type");
+      if (errorType === "request_denied_by_policy") {
+        const { data } = await this.parseResult(response);
+        const { message, errors } = this.parseErrorResponse({
+          status: response.status,
+          statusText: response.statusText,
+          data
+        });
+        throw new ZapierApprovalError(
+          message || "Request explicitly denied by policy",
+          {
+            status: "policy_denied",
+            statusCode: response.status,
+            errors
+          }
+        );
+      }
+      if (errorType !== "approval_required") {
+        return response;
+      }
+      if (approvalRoundError) {
+        throw approvalRoundError;
+      }
+      if (approvalMode === "disabled") {
+        throw new ZapierApprovalError(
+          "Approvals are disabled. Set approvalMode to 'poll' or 'throw' (or ZAPIER_APPROVAL_MODE) to enable.",
+          { status: "approval_required" }
+        );
+      }
+      if (!approvalContext) {
+        throw new ZapierApiError(
+          `Received 403 approval_required for ${path}, but the caller did not provide an approvalContext builder. Every approval-capable request must pass approvalContext so the SDK can create the approval with the correct policy context.`,
+          { statusCode: 403 }
         );
       }
       throw new ZapierApprovalError(
@@ -4966,40 +5944,60 @@ var ZapierApiClient = class {
   }
   // Apply any special routing logic for configured paths.
   applyPathConfiguration(path) {
-    const matchingPathKey = Object.keys(pathConfig).find(
-      (configPath) => path === configPath || path.startsWith(configPath + "/")
-    );
-    const config = matchingPathKey ? pathConfig[matchingPathKey] : void 0;
+    const matchingPathEntries = findPathConfigEntries({ path });
+    const routingMatch = matchingPathEntries[0];
+    const buildResult = (url2) => {
+      const resolvedPathEntries = findPathConfigEntries({
+        path: url2.pathname,
+        matchResolvedGatewayPath: true
+      });
+      const deprecationPathMatches = [
+        ...matchingPathEntries,
+        ...resolvedPathEntries
+      ];
+      const canSendDeprecationMessaging = deprecationPathMatches.length > 0 && deprecationPathMatches.every(
+        ({ config }) => config.omitDeprecationMessaging !== true
+      );
+      return {
+        url: url2,
+        pathConfig: routingMatch?.config,
+        canSendDeprecationMessaging
+      };
+    };
     let finalPath = path;
-    if (config && "pathPrefix" in config && config.pathPrefix && matchingPathKey) {
-      const pathWithoutPrefix = path.slice(matchingPathKey.length) || "/";
-      finalPath = `${config.pathPrefix}${pathWithoutPrefix}`;
+    if (routingMatch?.config.pathPrefix) {
+      const pathWithoutPrefix = path.slice(routingMatch.configPath.length) || "/";
+      finalPath = `${routingMatch.config.pathPrefix}${pathWithoutPrefix}`;
     }
     const zapierBaseUrl = getZapierBaseUrl(this.options.baseUrl);
     if (zapierBaseUrl === this.options.baseUrl.replace(/\/$/, "")) {
       const originalBaseUrl = new URL(this.options.baseUrl);
       const finalBaseUrl = `https://sdkapi.${originalBaseUrl.hostname}`;
-      return {
-        url: new URL(finalPath, finalBaseUrl),
-        pathConfig: config
-      };
+      const url2 = new URL(finalPath, finalBaseUrl);
+      return buildResult(url2);
     }
     const baseUrl = new URL(this.options.baseUrl);
     const basePath = baseUrl.pathname.replace(/\/$/, "");
-    return {
-      url: new URL(basePath + finalPath, baseUrl.origin),
-      pathConfig: config
-    };
+    const url = new URL(basePath + finalPath, baseUrl.origin);
+    return buildResult(url);
   }
   // Helper to build full URLs and return routing info
   buildUrl(path, searchParams) {
-    const { url, pathConfig: config } = this.applyPathConfiguration(path);
+    const {
+      url,
+      pathConfig: config,
+      canSendDeprecationMessaging
+    } = this.applyPathConfiguration(path);
     if (searchParams) {
-      Object.entries(searchParams).forEach(([key, value]) => {
-        url.searchParams.set(key, value);
+      Object.entries(searchParams).forEach(([key2, value]) => {
+        url.searchParams.set(key2, value);
       });
     }
-    return { url: url.toString(), pathConfig: config };
+    return {
+      url: url.toString(),
+      pathConfig: config,
+      canSendDeprecationMessaging
+    };
   }
   // Helper to build headers
   async buildHeaders(options = {}, pathConfig2) {
@@ -5643,7 +6641,7 @@ var listAppsPlugin = definePlugin(
           locator
         ];
       }
-      const duplicatedLookupAppKeys = Object.keys(implementationNameToLocator).filter((key) => implementationNameToLocator[key].length > 1).map((key) => implementationNameToLocator[key]).flat().map((locator) => locator.lookupAppKey);
+      const duplicatedLookupAppKeys = Object.keys(implementationNameToLocator).filter((key2) => implementationNameToLocator[key2].length > 1).map((key2) => implementationNameToLocator[key2]).flat().map((locator) => locator.lookupAppKey);
       if (duplicatedLookupAppKeys.length > 0) {
         throw new Error(
           `Duplicate lookup app keys found: ${duplicatedLookupAppKeys.join(", ")}`
@@ -6136,7 +7134,7 @@ function formatRecordError(fieldId, err) {
 function formatResponseError(err) {
   const message = err.human_title || err.title || "Unknown error";
   if (err.meta && Object.keys(err.meta).length > 0) {
-    const metaParts = Object.entries(err.meta).map(([key, val]) => `${key}: ${JSON.stringify(val)}`).join(", ");
+    const metaParts = Object.entries(err.meta).map(([key2, val]) => `${key2}: ${JSON.stringify(val)}`).join(", ");
     return `${message} (${metaParts})`;
   }
   return message;
@@ -6171,8 +7169,8 @@ var TrashSchema = z.enum(["exclude", "include", "only"]).optional().describe(
   'Control soft-deleted item visibility. "exclude" (default) returns active items only, "include" returns both active and soft-deleted, "only" returns soft-deleted items only.'
 );
 var FIELD_ID_PATTERN = /^f\d+$/;
-function isFieldId(key) {
-  return FIELD_ID_PATTERN.test(key);
+function isFieldId(key2) {
+  return FIELD_ID_PATTERN.test(key2);
 }
 var NESTED_COMPONENTS = {
   labeled_string: /* @__PURE__ */ new Set(["value"]),
@@ -6210,7 +7208,7 @@ async function resolveFieldKeys({
   fieldKeys
 }) {
   const allAreIds = fieldKeys.every(
-    (key) => typeof key === "number" || /^(f?\d+)$/.test(key)
+    (key2) => typeof key2 === "number" || /^(f?\d+)$/.test(key2)
   );
   if (allAreIds) {
     return fieldKeys.map(toNumericFieldId);
@@ -6219,13 +7217,13 @@ async function resolveFieldKeys({
   if (!mapping) {
     return fieldKeys.map(toNumericFieldId);
   }
-  return fieldKeys.map((key) => {
-    if (typeof key === "number") return key;
-    if (FIELD_ID_PATTERN.test(key)) return toNumericFieldId(key);
-    const id = mapping.nameToId.get(key);
+  return fieldKeys.map((key2) => {
+    if (typeof key2 === "number") return key2;
+    if (FIELD_ID_PATTERN.test(key2)) return toNumericFieldId(key2);
+    const id = mapping.nameToId.get(key2);
     if (!id) {
       throw new ZapierValidationError(
-        `Unknown field name: "${key}". Use a valid field name or ID.`
+        `Unknown field name: "${key2}". Use a valid field name or ID.`
       );
     }
     return toNumericFieldId(id);
@@ -6241,13 +7239,13 @@ async function createFieldKeyTranslator({
     translateInput(data) {
       if (!mapping) return data;
       const result = {};
-      for (const [key, value] of Object.entries(data)) {
-        if (FIELD_ID_PATTERN.test(key) && mapping.idToName.has(key)) {
-          result[key] = value;
-        } else if (mapping.nameToId.has(key)) {
-          result[mapping.nameToId.get(key)] = value;
+      for (const [key2, value] of Object.entries(data)) {
+        if (FIELD_ID_PATTERN.test(key2) && mapping.idToName.has(key2)) {
+          result[key2] = value;
+        } else if (mapping.nameToId.has(key2)) {
+          result[mapping.nameToId.get(key2)] = value;
         } else {
-          result[key] = value;
+          result[key2] = value;
         }
       }
       return result;
@@ -6255,29 +7253,29 @@ async function createFieldKeyTranslator({
     translateOutput(data) {
       if (!mapping) return data;
       const result = {};
-      for (const [key, value] of Object.entries(data)) {
-        if (mapping.idToName.has(key)) {
-          result[mapping.idToName.get(key)] = value;
+      for (const [key2, value] of Object.entries(data)) {
+        if (mapping.idToName.has(key2)) {
+          result[mapping.idToName.get(key2)] = value;
         } else {
-          result[key] = value;
+          result[key2] = value;
         }
       }
       return result;
     },
-    translateFieldKey(key) {
-      if (!mapping) return key;
-      if (FIELD_ID_PATTERN.test(key) && mapping.idToName.has(key)) {
-        const fieldType = mapping.idToType.get(key);
+    translateFieldKey(key2) {
+      if (!mapping) return key2;
+      if (FIELD_ID_PATTERN.test(key2) && mapping.idToName.has(key2)) {
+        const fieldType = mapping.idToType.get(key2);
         if (fieldType) {
           const components = NESTED_COMPONENTS[fieldType];
           if (components?.size === 1) {
-            return `${key}__${[...components][0]}`;
+            return `${key2}__${[...components][0]}`;
           }
         }
-        return key;
+        return key2;
       }
-      if (mapping.nameToId.has(key)) {
-        const fieldId = mapping.nameToId.get(key);
+      if (mapping.nameToId.has(key2)) {
+        const fieldId = mapping.nameToId.get(key2);
         const fieldType = mapping.idToType.get(fieldId);
         if (fieldType) {
           const components = NESTED_COMPONENTS[fieldType];
@@ -6287,10 +7285,10 @@ async function createFieldKeyTranslator({
         }
         return fieldId;
       }
-      const sepIndex = key.lastIndexOf("__");
+      const sepIndex = key2.lastIndexOf("__");
       if (sepIndex > 0) {
-        const prefix = key.slice(0, sepIndex);
-        const component = key.slice(sepIndex + 2);
+        const prefix = key2.slice(0, sepIndex);
+        const component = key2.slice(sepIndex + 2);
         let fieldId;
         if (FIELD_ID_PATTERN.test(prefix) && mapping.idToName.has(prefix)) {
           fieldId = prefix;
@@ -6304,7 +7302,7 @@ async function createFieldKeyTranslator({
           }
         }
       }
-      return key;
+      return key2;
     }
   };
 }
@@ -7221,9 +8219,9 @@ var RunActionSchemaDeprecated = z.object({
 var RunActionInputSchema = z.union([RunActionSchema, RunActionSchemaDeprecated]).describe(RunActionDescription);
 
 // src/formatters/actionResult.ts
-function getStringProperty(obj, key) {
-  if (typeof obj === "object" && obj !== null && key in obj) {
-    const value = obj[key];
+function getStringProperty(obj, key2) {
+  if (typeof obj === "object" && obj !== null && key2 in obj) {
+    const value = obj[key2];
     return typeof value === "string" ? value : void 0;
   }
   return void 0;
@@ -7310,13 +8308,13 @@ var runActionPlugin = definePlugin(
       let oldestKey;
       let oldestExpiry = Infinity;
       let evictedAny = false;
-      for (const [key, entry] of runActionContextCache) {
+      for (const [key2, entry] of runActionContextCache) {
         if (now >= entry.expiresAt) {
-          runActionContextCache.delete(key);
+          runActionContextCache.delete(key2);
           evictedAny = true;
         } else if (entry.expiresAt < oldestExpiry) {
           oldestExpiry = entry.expiresAt;
-          oldestKey = key;
+          oldestKey = key2;
         }
       }
       if (!evictedAny && oldestKey) {
@@ -7944,36 +8942,36 @@ var createConnectionPlugin = definePlugin(
       sdk: inner,
       options
     }) => {
-      const { data: start } = await inner.getConnectionStartUrl({
+      const { data: start2 } = await inner.getConnectionStartUrl({
         app: options.app
       });
-      setMethodMetadata({ selectedApi: start.app });
+      setMethodMetadata({ selectedApi: start2.app });
       console.error(
         `
 Open this URL to complete the connection:
-  ${start.url}
+  ${start2.url}
 `
       );
       const shouldOpen = options.browser === "always" || options.browser === "auto" && shouldOpenBrowser();
       if (shouldOpen) {
         try {
-          await open_url_default(start.url);
+          await open_url_default(start2.url);
         } catch {
         }
       }
       const { data: fresh } = await inner.waitForNewConnection({
-        app: start.app,
+        app: start2.app,
         // Server-stamped mint time: measured on the same clock as a
         // connection's `date`, so the freshness check is immune to
         // client/server clock skew.
-        startedAt: start.startedAt,
+        startedAt: start2.startedAt,
         timeoutMs: options.timeoutMs,
         pollIntervalMs: options.pollIntervalMs
       });
       return {
         data: CreateConnectionItemSchema.parse({
           id: fresh.id,
-          app: start.app,
+          app: start2.app,
           title: fresh.title ?? null
         })
       };
@@ -9972,9 +10970,9 @@ function findManifestEntry({
       return [slug, manifest.apps[slug]];
     }
   }
-  for (const [key, entry] of Object.entries(manifest.apps)) {
+  for (const [key2, entry] of Object.entries(manifest.apps)) {
     if (entry.implementationName === appKeyWithoutVersion) {
-      return [key, entry];
+      return [key2, entry];
     }
   }
   return null;
@@ -10231,21 +11229,21 @@ var manifestPlugin = definePlugin(
 );
 
 // src/plugins/capabilities/index.ts
-function toDescription(key) {
-  const words = key.replace(/^can/, "").replace(/([A-Z])/g, " $1").trim().toLowerCase();
+function toDescription(key2) {
+  const words = key2.replace(/^can/, "").replace(/([A-Z])/g, " $1").trim().toLowerCase();
   return `To ${words}`;
 }
-function toEnvVar(key) {
-  return "ZAPIER_" + key.replace(/([A-Z])/g, "_$1").toUpperCase();
+function toEnvVar(key2) {
+  return "ZAPIER_" + key2.replace(/([A-Z])/g, "_$1").toUpperCase();
 }
-function toCliFlag(key) {
-  return "--" + key.replace(/([A-Z])/g, "-$1").toLowerCase();
+function toCliFlag(key2) {
+  return "--" + key2.replace(/([A-Z])/g, "-$1").toLowerCase();
 }
-function buildCapabilityMessage(key) {
+function buildCapabilityMessage(key2) {
   return [
-    `${toDescription(key)}, use ${toCliFlag(key)} in the CLI,`,
-    `set ${key}: true in SDK options or .zapierrc,`,
-    `or set ${toEnvVar(key)}=true.`
+    `${toDescription(key2)}, use ${toCliFlag(key2)} in the CLI,`,
+    `set ${key2}: true in SDK options or .zapierrc,`,
+    `or set ${toEnvVar(key2)}=true.`
   ].join(" ");
 }
 var GATED_FLAGS = [
@@ -10253,8 +11251,8 @@ var GATED_FLAGS = [
   "canIncludeSharedTables",
   "canDeleteTables"
 ];
-function isEnabledByEnv(key) {
-  const value = globalThis.process?.env?.[toEnvVar(key)];
+function isEnabledByEnv(key2) {
+  const value = globalThis.process?.env?.[toEnvVar(key2)];
   if (value === void 0) return void 0;
   if (value === "true" || value === "1") return true;
   if (value === "false" || value === "0") return false;
@@ -10277,17 +11275,17 @@ var capabilitiesPlugin = definePlugin(
     }
     return {
       context: {
-        checkCapability: async (key) => {
+        checkCapability: async (key2) => {
           const flags = await resolveFlags();
-          if (flags[key]) return;
+          if (flags[key2]) return;
           throw new ZapierConfigurationError(
-            buildCapabilityMessage(key) + " (If you are an AI agent, you MUST NOT retry. Ask the user if they want to enable this.)",
-            { configType: key }
+            buildCapabilityMessage(key2) + " (If you are an AI agent, you MUST NOT retry. Ask the user if they want to enable this.)",
+            { configType: key2 }
           );
         },
-        hasCapability: async (key) => {
+        hasCapability: async (key2) => {
           const flags = await resolveFlags();
-          return flags[key];
+          return flags[key2];
         }
       }
     };
@@ -10445,8 +11443,8 @@ function getOsInfo() {
 function getPlatformVersions() {
   const versions = {};
   if (typeof globalThis.process?.versions === "object") {
-    for (const [key, value] of Object.entries(globalThis.process.versions)) {
-      versions[key] = value || null;
+    for (const [key2, value] of Object.entries(globalThis.process.versions)) {
+      versions[key2] = value || null;
     }
   }
   return versions;
@@ -10688,9 +11686,9 @@ async function emitWithTimeout(transport, subject, event) {
 }
 function mergeUserContext(event, userContext) {
   const merged = { ...event };
-  for (const [key, value] of Object.entries(userContext)) {
-    if (merged[key] == null) {
-      merged[key] = value;
+  for (const [key2, value] of Object.entries(userContext)) {
+    if (merged[key2] == null) {
+      merged[key2] = value;
     }
   }
   return merged;
@@ -11963,9 +12961,9 @@ function createWaiter() {
     }
   };
 }
-function addToMap(m, key, value) {
-  const existing = m.get(key) ?? [];
-  m.set(key, [...existing, value]);
+function addToMap(m, key2, value) {
+  const existing = m.get(key2) ?? [];
+  m.set(key2, [...existing, value]);
 }
 async function runBatchedDrainPipeline(options) {
   const {
@@ -12768,14 +13766,14 @@ function toWireConnections(connections) {
 }
 function toWireAppVersions(appVersions) {
   const wire = {};
-  for (const [key, entry] of Object.entries(appVersions)) {
+  for (const [key2, entry] of Object.entries(appVersions)) {
     const implementationName = entry.implementationName ?? entry.implementation_name;
     if (implementationName === void 0) {
       throw new ZapierValidationError(
-        `appVersions["${key}"] is missing implementationName`
+        `appVersions["${key2}"] is missing implementationName`
       );
     }
-    wire[key] = {
+    wire[key2] = {
       implementation_name: implementationName,
       ...entry.version !== void 0 ? { version: entry.version } : {}
     };
@@ -14184,4 +15182,4 @@ function createZapierSdk2(options = {}) {
   );
 }
 
-export { ActionKeyPropertySchema, ActionPropertySchema, ActionTimeoutMsPropertySchema, ActionTypePropertySchema, AppKeyPropertySchema, AppPropertySchema, AppsPropertySchema, AuthMechanism, AuthenticationIdPropertySchema, BaseSdkOptionsSchema, CONTEXT_CACHE_MAX_SIZE, CONTEXT_CACHE_TTL_MS, CORE_ERROR_SYMBOL, ClientCredentialsObjectSchema, ConnectionEntrySchema, ConnectionIdPropertySchema, ConnectionPropertySchema, ConnectionsMapSchema, ConnectionsPropertySchema, CoreErrorCode, CredentialsFunctionSchema, CredentialsObjectSchema, CredentialsSchema, DEFAULT_ACTION_TIMEOUT_MS, DEFAULT_APPROVAL_TIMEOUT_MS, DEFAULT_CONFIG_PATH, DEFAULT_MAX_APPROVAL_RETRIES, DEFAULT_PAGE_SIZE, DebugPropertySchema, FieldsPropertySchema, InputFieldPropertySchema, InputsPropertySchema, LeaseLimitPropertySchema, LeasePropertySchema, LeaseSecondsPropertySchema, LimitPropertySchema, MAX_CONCURRENCY_LIMIT, MAX_PAGE_LIMIT, OffsetPropertySchema, OutputPropertySchema, ParamsPropertySchema, PkceCredentialsObjectSchema, RecordPropertySchema, RecordsPropertySchema, RelayFetchSchema, RelayRequestSchema, ResolvedCredentialsSchema, TablePropertySchema, TablesPropertySchema, TriggerInboxNamePropertySchema, TriggerInboxPropertySchema, ZAPIER_BASE_URL, ZAPIER_MAX_CONCURRENT_REQUESTS, ZAPIER_MAX_NETWORK_RETRIES, ZAPIER_MAX_NETWORK_RETRY_DELAY_MS, ZapierAbortDrainSignal, ZapierActionError, ZapierApiError, ZapierAppNotFoundError, ZapierApprovalError, ZapierAuthenticationError, ZapierBundleError, ZapierConfigurationError, ZapierConflictError, ZapierError, ZapierNotFoundError, ZapierRateLimitError, ZapierRelayError, ZapierReleaseTriggerMessageSignal, ZapierResourceNotFoundError, ZapierSignal, ZapierTimeoutError, ZapierUnknownError, ZapierValidationError, actionKeyResolver, actionTypeResolver, addPlugin, apiPlugin, appKeyResolver, appsPlugin, connectionIdGenericResolver as authenticationIdGenericResolver, connectionIdResolver as authenticationIdResolver, batch, buildApplicationLifecycleEvent, buildCapabilityMessage, buildErrorEvent, buildErrorEventWithContext, buildMethodCalledEvent, cleanupEventListeners, clearTokenCache, clientCredentialsNameResolver, clientIdResolver, composePlugins, connectionIdGenericResolver, connectionIdResolver, connectionsPlugin, createBaseEvent, createClientCredentialsPlugin, createCorePlugin, createFunction, createMemoryCache, createOptionsPlugin, createPaginatedPluginMethod, createPluginMethod, createPluginStack, createSdk, createTableFieldsPlugin, createTablePlugin, createTableRecordsPlugin, createZapierApi, createZapierCoreStack, createZapierSdk2 as createZapierSdk, createZapierSdkStack2 as createZapierSdkStack, createZapierSdkWithoutRegistry, dangerousContextPlugin, declareMethod, declareProperty, defineLegacyMerge, defineMethod, definePlugin, defineProperty, deleteClientCredentialsPlugin, deleteTableFieldsPlugin, deleteTablePlugin, deleteTableRecordsPlugin, durableRunIdResolver, eventEmissionPlugin, fetchPlugin, findFirstConnectionPlugin, findManifestEntry, findUniqueConnectionPlugin, formatErrorMessage, fromFunctionPlugin, generateEventId, getActionInputFieldsSchemaPlugin, getActionPlugin, getAgent, getAppPlugin, getBaseUrlFromCredentials, getCallerContext, getCiPlatform, getClientIdFromCredentials, getConnectionPlugin, getContext, getCoreErrorCause, getCoreErrorCode, getCpuTime, getCurrentTimestamp, getMemoryUsage, getOrCreateApiClient, getOsInfo, getPlatformVersions, getPreferredManifestEntryKey, getProfilePlugin, getReleaseId, getTablePlugin, getTableRecordPlugin, getTokenFromCliLogin, getTtyContext, getZapierApprovalMode, getZapierDefaultApprovalMode, getZapierOpenAutoModeApprovalsInBrowser, getZapierSdkService, injectCliLogin, inputFieldKeyResolver, inputsAllOptionalResolver, inputsResolver, invalidateCachedToken, invalidateCredentialsToken, isCi, isCliLoginAvailable, isClientCredentials, isCoreError, isCredentialsFunction, isCredentialsObject, isPermanentHttpError, isPkceCredentials, isPositional, listActionInputFieldChoicesPlugin, listActionInputFieldsPlugin, listActionsPlugin, listAppsPlugin, listClientCredentialsPlugin, listConnectionsPlugin, listTableFieldsPlugin, listTableRecordsPlugin, listTablesPlugin, logDeprecation2 as logDeprecation, manifestPlugin, parseConcurrencyEnvVar, readManifestFromFile, registryPlugin, requestPlugin, resetDeprecationWarnings2 as resetDeprecationWarnings, resolveAuth, resolveAuthToken, resolveCredentials, resolveCredentialsFromEnv, runActionPlugin, runInMethodScope, runWithCallerContext, runWithTelemetryContext, tableFieldIdsResolver, tableFieldsResolver, tableFiltersResolver, tableIdResolver, tableNameResolver, tableRecordIdResolver, tableRecordIdsResolver, tableRecordsResolver, tableSortResolver, tableUpdateRecordsResolver, toSnakeCase, toTitleCase, triggerInboxResolver, triggerMessagesResolver, updateTableRecordsPlugin, workflowIdResolver, workflowRunIdResolver, workflowVersionIdResolver, zapierAdaptError, zapierSdkPlugin };
+export { ActionKeyPropertySchema, ActionPropertySchema, ActionTimeoutMsPropertySchema, ActionTypePropertySchema, AppKeyPropertySchema, AppPropertySchema, AppsPropertySchema, AuthMechanism, AuthenticationIdPropertySchema, BaseSdkOptionsSchema, CONTEXT_CACHE_MAX_SIZE, CONTEXT_CACHE_TTL_MS, CORE_ERROR_SYMBOL, CORE_SIGNAL_SYMBOL, ClientCredentialsObjectSchema, ConnectionEntrySchema, ConnectionIdPropertySchema, ConnectionPropertySchema, ConnectionsMapSchema, ConnectionsPropertySchema, CoreCancelledSignal, CoreErrorCode, CoreSignal, CredentialsFunctionSchema, CredentialsObjectSchema, CredentialsSchema, DEFAULT_ACTION_TIMEOUT_MS, DEFAULT_APPROVAL_TIMEOUT_MS, DEFAULT_CONFIG_PATH, DEFAULT_MAX_APPROVAL_RETRIES, DEFAULT_PAGE_SIZE, DEPRECATION_NOTICE_EVENT, DebugPropertySchema, FieldsPropertySchema, InputFieldPropertySchema, InputsPropertySchema, LeaseLimitPropertySchema, LeasePropertySchema, LeaseSecondsPropertySchema, LimitPropertySchema, MAX_CONCURRENCY_LIMIT, MAX_PAGE_LIMIT, OffsetPropertySchema, OutputPropertySchema, ParamsPropertySchema, PkceCredentialsObjectSchema, RecordPropertySchema, RecordsPropertySchema, RelayFetchSchema, RelayRequestSchema, ResolvedCredentialsSchema, TablePropertySchema, TablesPropertySchema, TriggerInboxNamePropertySchema, TriggerInboxPropertySchema, ZAPIER_BASE_URL, ZAPIER_MAX_CONCURRENT_REQUESTS, ZAPIER_MAX_NETWORK_RETRIES, ZAPIER_MAX_NETWORK_RETRY_DELAY_MS, ZapierAbortDrainSignal, ZapierActionError, ZapierApiError, ZapierAppNotFoundError, ZapierApprovalError, ZapierAuthenticationError, ZapierBundleError, ZapierConfigurationError, ZapierConflictError, ZapierError, ZapierNotFoundError, ZapierRateLimitError, ZapierRelayError, ZapierReleaseTriggerMessageSignal, ZapierResourceNotFoundError, ZapierSignal, ZapierTimeoutError, ZapierUnknownError, ZapierValidationError, actionKeyResolver, actionTypeResolver, addPlugin, apiPlugin, appKeyResolver, appsPlugin, connectionIdGenericResolver as authenticationIdGenericResolver, connectionIdResolver as authenticationIdResolver, batch, buildApplicationLifecycleEvent, buildCapabilityMessage, buildErrorEvent, buildErrorEventWithContext, buildMethodCalledEvent, cleanupEventListeners, clearTokenCache, clientCredentialsNameResolver, clientIdResolver, composePlugins, connectionIdGenericResolver, connectionIdResolver, connectionsPlugin, createBaseEvent, createClientCredentialsPlugin, createController, createCorePlugin, createFunction, createMemoryCache, createOptionsPlugin, createPaginatedPluginMethod, createPluginMethod, createPluginStack, createSdk, createTableFieldsPlugin, createTablePlugin, createTableRecordsPlugin, createZapierApi, createZapierCoreStack, createZapierSdk2 as createZapierSdk, createZapierSdkStack2 as createZapierSdkStack, createZapierSdkWithoutRegistry, dangerousContextPlugin, declareMethod, declareProperty, defineLegacyMerge, defineMethod, definePlugin, defineProperty, defineResolver, deleteClientCredentialsPlugin, deleteTableFieldsPlugin, deleteTablePlugin, deleteTableRecordsPlugin, durableRunIdResolver, eventEmissionPlugin, fetchPlugin, findFirstConnectionPlugin, findManifestEntry, findUniqueConnectionPlugin, formatErrorMessage, fromFunctionPlugin, generateEventId, getActionInputFieldsSchemaPlugin, getActionPlugin, getAgent, getAppPlugin, getBaseUrlFromCredentials, getCallerContext, getCiPlatform, getClientIdFromCredentials, getConnectionPlugin, getContext, getCoreErrorCause, getCoreErrorCode, getCpuTime, getCurrentTimestamp, getMemoryUsage, getOrCreateApiClient, getOsInfo, getPlatformVersions, getPreferredManifestEntryKey, getProfilePlugin, getReleaseId, getTablePlugin, getTableRecordPlugin, getTokenFromCliLogin, getTtyContext, getZapierApprovalMode, getZapierDefaultApprovalMode, getZapierOpenAutoModeApprovalsInBrowser, getZapierSdkService, injectCliLogin, inputFieldKeyResolver, inputsAllOptionalResolver, inputsResolver, invalidateCachedToken, invalidateCredentialsToken, isCi, isCliLoginAvailable, isClientCredentials, isCoreError, isCoreSignal, isCredentialsFunction, isCredentialsObject, isPermanentHttpError, isPkceCredentials, isPositional, listActionInputFieldChoicesPlugin, listActionInputFieldsPlugin, listActionsPlugin, listAppsPlugin, listClientCredentialsPlugin, listConnectionsPlugin, listTableFieldsPlugin, listTableRecordsPlugin, listTablesPlugin, logDeprecation2 as logDeprecation, manifestPlugin, parseConcurrencyEnvVar, readManifestFromFile, registryPlugin, requestPlugin, resetDeprecationWarnings2 as resetDeprecationWarnings, resolveAuth, resolveAuthToken, resolveCredentials, resolveCredentialsFromEnv, runActionPlugin, runInMethodScope, runWithCallerContext, runWithTelemetryContext, tableFieldIdsResolver, tableFieldsResolver, tableFiltersResolver, tableIdResolver, tableNameResolver, tableRecordIdResolver, tableRecordIdsResolver, tableRecordsResolver, tableSortResolver, tableUpdateRecordsResolver, toSnakeCase, toTitleCase, triggerInboxResolver, triggerMessagesResolver, updateTableRecordsPlugin, workflowIdResolver, workflowRunIdResolver, workflowVersionIdResolver, zapierAdaptError, zapierSdkPlugin };