@zapier/zapier-sdk 0.78.0 → 0.80.0

package/dist/{index-BgbftweS.d.ts → index-Dpl8IaV9.d.ts}

@@ -321,6 +321,10 @@ interface PromptConfig {
     message: string;
     choices?: Array<PromptConfigChoice | DeprecatedPromptConfigChoice>;
     default?: unknown;
+    /** Informational, non-selectable lines shown with the prompt (e.g. "enable X
+     * to see more"). A host renders them dimmed, after the choices. The framework
+     * stays agnostic about their content; the resolver composes the text. */
+    notes?: string[];
     filter?: (value: unknown) => unknown;
     /**
      * Return `true` for valid; a string for a custom invalid message; or
@@ -333,6 +337,17 @@ interface PromptConfig {
 type ListPromptConfig = PromptConfig & {
     type: "list";
 };
+/**
+ * The prompt config the NEW-model resolvers (`defineResolver`) return. It omits
+ * three fields the resolution controller does not honor, so authors can't
+ * supply a silent no-op:
+ *  - `name`   — the framework supplies the answer key (always was overwritten).
+ *  - `default`— no resolver uses it; the controller has no preselect concept.
+ *  - `filter` — no resolver uses it; transform values in `listItems` instead.
+ * (The legacy `SchemaParameterResolver` still honors `default`/`filter`, so the
+ * full `PromptConfig` stays for that path.)
+ */
+type ResolverPromptConfig = Omit<PromptConfig, "name" | "default" | "filter">;
 interface Resolver$1 {
     type: string;
     depends?: readonly string[] | string[];
@@ -645,7 +660,7 @@ interface MethodRunBag<TImports, TInput, TState = unknown> {
 }
 /** Shared plumbing for the method attachments: each declares its own
  * dependencies. Resolvers and formatters are otherwise separate concepts. */
-interface Attachment {
+interface MethodAttachment {
     imports: readonly AnyPlugin[];
     /** Binding-name to plugin-id edges, normalized from `imports`; what the
      * narrowed bag captured at materialization is built from. */
@@ -661,14 +676,14 @@ interface Attachment {
 type ResolverType = "dynamic" | "static" | "constant" | "info" | "object" | "array";
 /**
  * A reference from a field (or array `items`) to a reusable resolver in the
- * nearest `definitions` block. `params` are merged into the referenced
- * resolver's `params` (e.g. the field key a shared choices-fetcher needs).
+ * nearest `definitions` block. `input` are merged into the referenced
+ * resolver's `input` (e.g. the field key a shared choices-fetcher needs).
  * Used when a fetch-built field needs an import-bearing resolver, which can't
  * be inlined at fetch time (its imports bind at materialization).
  */
 interface ResolverRef {
     ref: string;
-    params?: Record<string, unknown>;
+    input?: Record<string, unknown>;
 }
 /**
  * One member of an object resolver's `properties` (literal or fetch-built): the
@@ -684,34 +699,68 @@ interface Field$1 {
     valueType?: string;
 }
 /** Shared gates for resolvers that resolve a value: the attachment plumbing
- * plus the param-dataflow / capability prerequisites. (`info` skips these.) */
-interface ResolverBase extends Attachment {
+ * plus the param-dataflow prerequisite. (`info` skips these.) */
+interface ResolverBase extends MethodAttachment {
     /** Sibling parameters that must resolve before this resolver runs (it reads
-     * their values from `params`). The param-dataflow prerequisite, the twin of
-     * `requireCapabilities` and distinct from `imports`' SDK-capability graph. */
-    requireParams?: readonly string[];
-    requireCapabilities?: readonly string[];
+     * their values from `input`). The param-dataflow prerequisite, distinct from
+     * `imports`' SDK-capability graph. */
+    requireParameters?: readonly string[];
 }
-/** Fetch a candidate list and prompt the user to pick one. */
+/** List candidate items and prompt the user to pick one. */
 interface DynamicResolver extends ResolverBase {
     type: "dynamic";
     inputType?: "text" | "password" | "email" | "search";
     placeholder?: string;
-    fetch?: (bag: {
+    /** Compute side-context once, before `listItems`, with the narrowed `imports`
+     * bag (no items yet — it runs pre-fetch so it can shape the fetch). The result
+     * flows into `listItems` and `prompt` as `context`. Use it to resolve, in one
+     * place, anything both the fetch and the render need (e.g. a capability gate:
+     * compute `includeShared` here, gate the fetch in `listItems`, surface a
+     * `notes` hint in `prompt`). May run more than once across re-asks, so keep it
+     * cheap/idempotent. */
+    getContext?: (bag: {
+        imports: Record<string, unknown>;
+        input: Record<string, unknown>;
+    }) => PromiseLike<unknown>;
+    /** Produce the candidate list. Behaves like an SDK list method: returns a
+     * paginated result (await for the first page + `nextCursor`, or iterate pages),
+     * never a bare array. `cursor` is the stateless re-entry hook for "load more":
+     * an in-process host iterates the result; a distributed host awaits one page,
+     * carries `nextCursor`, and calls again with `cursor`. */
+    listItems?: (bag: {
         imports: Record<string, unknown>;
-        params: Record<string, unknown>;
+        input: Record<string, unknown>;
+        /** The value `getContext` returned, if any. */
+        context?: unknown;
         /** Free-text term injected by the CLI for search-mode resolvers. A separate
-         * key, not part of `params`, so it never collides with a method parameter
+         * key, not part of `input`, so it never collides with a method parameter
          * also named `search`. */
         search?: string;
-    }) => PromiseLike<ResolverFetchResult<unknown>>;
+        cursor?: string;
+    }) => ListItemsResult<unknown>;
     prompt?: (bag: {
         items: unknown[];
-        params: Record<string, unknown>;
-    }) => PromptConfig;
+        input: Record<string, unknown>;
+        /** The value `getContext` returned, if any. */
+        context?: unknown;
+    }) => ResolverPromptConfig;
+    /** Resolve with no user input at all (e.g. a configured default), skipping the
+     * prompt. Runs before prompting; used always in non-interactive mode and as a
+     * "can we skip asking?" check otherwise. Returns null to fall through to a prompt. */
     tryResolveWithoutPrompt?: (bag: {
         imports: Record<string, unknown>;
-        params: Record<string, unknown>;
+        input: Record<string, unknown>;
+    }) => Promise<{
+        resolvedValue: unknown;
+    } | null>;
+    /** Search-mode exact match: the user typed `search`; if it already names a
+     * valid value (e.g. validated via the API), return it to skip the picker.
+     * Distinct from `tryResolveWithoutPrompt` (no input) — this is interactive,
+     * mid-prompt, with the typed term. Returns null to fall through to `listItems`. */
+    tryResolveFromSearch?: (bag: {
+        imports: Record<string, unknown>;
+        input: Record<string, unknown>;
+        search?: string;
     }) => Promise<{
         resolvedValue: unknown;
     } | null>;
@@ -728,20 +777,21 @@ interface ConstantResolver extends ResolverBase {
     value: unknown;
 }
 /** Display-only text; resolves no value (its key is skipped in the result). */
-interface InfoResolver extends Attachment {
+interface InfoResolver extends MethodAttachment {
     type: "info";
     text: string;
 }
-/** A keyed object. `properties` are known up front; `fetch` builds them when
- * the key set is dynamic (re-invoked as `params` grow, for depends-on fields).
- * `definitions` holds reusable resolvers reached by `{ ref }` from fetch-built
- * fields that need an import. */
+/** A keyed object. `properties` are known up front; `getProperties` builds them
+ * when the key set is dynamic (re-invoked as `input` grow, for depends-on
+ * fields). Returns the property map raw (no envelope: nothing to paginate).
+ * `definitions` holds reusable resolvers reached by `{ ref }` from built fields
+ * that need an import. */
 interface ObjectResolver extends ResolverBase {
     type: "object";
     properties?: Record<string, Field$1>;
-    fetch?: (bag: {
+    getProperties?: (bag: {
         imports: Record<string, unknown>;
-        params: Record<string, unknown>;
+        input: Record<string, unknown>;
     }) => PromiseLike<Record<string, Field$1>>;
     definitions?: Record<string, Resolver>;
 }
@@ -751,6 +801,11 @@ interface ArrayResolver extends ResolverBase {
     items: Resolver | ResolverRef;
     minItems?: number;
     maxItems?: number;
+    /** Coarse value type of each element, so a free-text item answer coerces
+     * (e.g. `"5"` → `5` for `z.array(z.number())`) the way object fields do via
+     * `Field.valueType`. `items` is a bare resolver with no `valueType` slot of
+     * its own, so the element type rides here. */
+    itemValueType?: string;
     definitions?: Record<string, Resolver>;
 }
 /**
@@ -764,14 +819,14 @@ interface ArrayResolver extends ResolverBase {
 type Resolver = DynamicResolver | StaticResolver | ConstantResolver | InfoResolver | ObjectResolver | ArrayResolver;
 /**
  * An output formatter descriptor (produced by `defineFormatter`, attached to a
- * method's output). `fetchContext` reaches the narrowed `imports` bag; the
+ * method's output). `getContext` reaches the narrowed `imports` bag; the
  * materializer captures it and produces a {@link BoundFormatter}. Stored
  * loosely, like {@link Resolver}. Both callbacks receive the method's `input`
  * (the formatter runs post-execution, so the input is complete, unlike a
- * resolver's partial `params`).
+ * resolver's partial `input`).
  */
-interface Formatter extends Attachment {
-    fetchContext?: (bag: {
+interface Formatter extends MethodAttachment {
+    getContext?: (bag: {
         imports: Record<string, unknown>;
         items: unknown[];
         input: Record<string, unknown>;
@@ -783,15 +838,11 @@ interface Formatter extends Attachment {
         context?: unknown;
     }) => FormattedItem;
 }
-/** What a dynamic resolver's `fetch` yields: a page, an item array, an async
- * iterable of pages, or a primitive (an exact-match short-circuit). */
-type ResolverFetchResult<TItem> = TItem[] | {
-    data: TItem[];
-    nextCursor?: string;
-} | AsyncIterable<{
-    data: TItem[];
-    nextCursor?: string;
-}> | string | number;
+/** What a dynamic resolver's `listItems` yields: an SDK list-method result
+ * (`await` for the first page + `nextCursor`, or iterate pages in-process), or a
+ * plain page / promise of one. No bare array and no scalar: it behaves like any
+ * other list method, and exact-match short-circuits live on `tryResolveFromSearch`. */
+type ListItemsResult<TItem> = PaginatedSdkResult<TItem> | SdkPage<TItem> | Promise<SdkPage<TItem>>;
 /** A bound object resolver's literal property: its resolver is already bound
  * (or a `{ ref }` the CLI resolves against `definitions` at runtime). */
 interface BoundField {
@@ -802,22 +853,21 @@ interface BoundField {
 }
 /**
  * The runtime resolver `defineResolver` binds to: its imports are already
- * captured, so the CLI calls these with params (and `search`) only, no sdk.
+ * captured, so the CLI calls these with input (and `search`) only, no sdk.
  * `prompt` stays pure (no SDK reach).
  *
  * Carries every kind's fields on one loose interface, discriminated by `type`.
  * The CLI rewrite (the consumer) narrows this into per-kind shapes; until then
- * a single shape keeps the binder simple. `fetch` returns a candidate list for
- * `dynamic`, or the (unbound) property map for `object` — the union reflects
- * both. `properties` / `definitions` are bound; `items` is bound (or a ref).
+ * a single shape keeps the binder simple. `listItems` produces the candidate
+ * list for `dynamic`; `getProperties` builds the (unbound) property map for
+ * `object`. `properties` / `definitions` are bound; `items` is bound (or a ref).
  */
 interface BoundResolver {
     type: ResolverType;
     /** Sibling parameters that must resolve before this resolver runs (it reads
-     * their values from `params`). The param-dataflow prerequisite, the twin of
-     * `requireCapabilities` and distinct from `imports`' SDK-capability graph. */
-    requireParams?: readonly string[];
-    requireCapabilities?: readonly string[];
+     * their values from `input`). The param-dataflow prerequisite, distinct from
+     * `imports`' SDK-capability graph. */
+    requireParameters?: readonly string[];
     inputType?: "text" | "password" | "email" | "search";
     placeholder?: string;
     value?: unknown;
@@ -827,27 +877,45 @@ interface BoundResolver {
     items?: BoundResolver | ResolverRef;
     minItems?: number;
     maxItems?: number;
-    fetch?: (bag: {
-        params: Record<string, unknown>;
+    /** For an array: the element's coarse value type, used to coerce a free-text
+     * item answer before validation (see {@link ArrayResolver.itemValueType}). */
+    itemValueType?: string;
+    getContext?: (bag: {
+        input: Record<string, unknown>;
+    }) => PromiseLike<unknown>;
+    listItems?: (bag: {
+        input: Record<string, unknown>;
+        context?: unknown;
         search?: string;
-    }) => PromiseLike<ResolverFetchResult<unknown> | Record<string, Field$1>>;
+        cursor?: string;
+    }) => ListItemsResult<unknown>;
+    getProperties?: (bag: {
+        input: Record<string, unknown>;
+    }) => PromiseLike<Record<string, Field$1>>;
     prompt?: (bag: {
         items: unknown[];
-        params: Record<string, unknown>;
-    }) => PromptConfig;
+        input: Record<string, unknown>;
+        context?: unknown;
+    }) => ResolverPromptConfig;
     tryResolveWithoutPrompt?: (bag: {
-        params: Record<string, unknown>;
+        input: Record<string, unknown>;
+    }) => Promise<{
+        resolvedValue: unknown;
+    } | null>;
+    tryResolveFromSearch?: (bag: {
+        input: Record<string, unknown>;
+        search?: string;
     }) => Promise<{
         resolvedValue: unknown;
     } | null>;
 }
 /**
- * The runtime formatter `defineFormatter` binds to: `prepare` runs once per
+ * The runtime formatter `defineFormatter` binds to: `getContext` runs once per
  * rendered batch (imports captured, no sdk) to build shared context; `format`
  * is pure and synchronous, turning one item + context into a `FormattedItem`.
  */
 interface BoundFormatter<TItem = unknown, TInput = Record<string, unknown>, TContext = unknown> {
-    fetchContext?: (bag: {
+    getContext?: (bag: {
         items: TItem[];
         input: TInput;
         context?: TContext;
@@ -1126,7 +1194,7 @@ interface MethodEntry {
      * public callable / imports take as positional args. */
     positional?: readonly string[];
     /** Bound input resolvers (their imports captured at materialization), keyed by
-     * param name. The CLI calls these with params only, no sdk. */
+     * param name. The CLI calls these with input only, no sdk. */
     resolvers?: Record<string, BoundResolver>;
     /** Bound output formatter (imports captured at materialization). */
     formatter?: BoundFormatter;
@@ -1328,8 +1396,24 @@ interface FunctionRegistryEntry<TSdk = any> {
         schema: z.ZodSchema;
     }>;
     outputSchema?: z.ZodSchema;
+    /**
+     * Ordered input keys the public surface projects onto positional arguments
+     * (the method's `positional` declaration). Absent when the method takes only
+     * the canonical single bag. Lifted off the materialized method entry by the
+     * surface builder, like `boundResolvers` — a runtime projection, not
+     * descriptive meta.
+     */
+    positional?: readonly string[];
     categories: string[];
     resolvers?: Record<string, ResolverMetadata<TSdk, any, any>>;
+    /**
+     * Per-parameter bound resolvers from the new model (imports already captured,
+     * called with `input` only, no sdk). Parallel to the legacy `resolvers` field
+     * and `formatter`: the surface builder lifts these off the materialized method
+     * entry. Additive bridge — populated for migrated `defineMethod` plugins; the
+     * legacy `resolvers` field above stays the source for unmigrated ones.
+     */
+    boundResolvers?: Record<string, BoundResolver>;
     packages?: string[];
     /**
      * True if the plugin is registered only in the experimental SDK
@@ -1350,7 +1434,7 @@ interface FunctionRegistryEntry<TSdk = any> {
     aliases?: Record<string, string>;
     /**
      * Output formatter, normalized to the bound runtime shape (its imports/sdk
-     * already captured), so consumers call `fetchContext`/`format` with no sdk.
+     * already captured), so consumers call `getContext`/`format` with no sdk.
      * The surface builder produces this from the method entry — `entry.formatter`
      * for a migrated plugin, or the legacy `meta.formatter` adapted — so vintage
      * is invisible here.
@@ -1883,6 +1967,112 @@ declare function defineMethod<const TName extends string, TInput, TResponse, TIt
     }) => TState;
     run: (bag: MethodRunBag<ImportsOf<TImports>, TInput & PageFetchInput, TState>) => TResponse | Promise<TResponse>;
 } & LeafMetaFields): MethodPlugin<TName, TInput & PaginatedCallInput, PaginatedSdkResult<TItem>> & LeafSummary<TNamespace, TName, TImports>;
+/**
+ * Define an input resolver: a method attachment for one of its parameters. Like
+ * `defineMethod` it declares its own `imports`, and its callbacks receive a
+ * narrowed `imports` bag, NOT the whole SDK. The graph reaches its imports
+ * (materialize + dedup) but they never enter the host method's run-bag, so a
+ * resolver may even import its own host method. At createSdk the imports are
+ * captured, so the CLI later calls `listItems(input)` / `tryResolveWithoutPrompt
+ * (input)` with no sdk argument.
+ *
+ * The `type` selects the kind (a {@link Resolver} union member); the config
+ * narrows to it. `requireParameters` names sibling parameters that must resolve
+ * first (it reads their values from `input`), independent of `imports` (the
+ * SDK-capability graph). `object` / `array` resolvers compose nested resolvers;
+ * an import-bearing resolver reached from a built field lives in `definitions`
+ * (reached by `{ ref }`), since it can't be inlined when the field set is built
+ * dynamically.
+ */
+declare function defineResolver<const TImports extends ImportsInput = readonly [], TItem = unknown, TInput = Record<string, unknown>, TContext = unknown>(config: {
+    type?: "dynamic";
+    imports?: TImports & StaticList<TImports>;
+    requireParameters?: readonly string[];
+    inputType?: "text" | "password" | "email" | "search";
+    placeholder?: string;
+    /** Compute side-context once, before `listItems` (pre-fetch, no items yet),
+     * with the narrowed `imports`. Its result flows into `listItems` and `prompt`
+     * as `context`, so one place resolves what both the fetch and the render need
+     * (e.g. a capability gate). May re-run across re-asks; keep it cheap. */
+    getContext?: (bag: {
+        imports: ImportsOf<TImports>;
+        input: TInput;
+    }) => PromiseLike<TContext>;
+    /** Produce the candidate list. Behaves like an SDK list method (returns a page
+     * / paginated result, never a bare array). `cursor` is the stateless "load
+     * more" re-entry hook. */
+    listItems?: (bag: {
+        imports: ImportsOf<TImports>;
+        input: TInput;
+        /** The value `getContext` returned, if any. */
+        context?: TContext;
+        /** Free-text term the CLI injects for search-mode resolvers; a separate key
+         * from `input`, so it never collides with a parameter named `search`. */
+        search?: string;
+        cursor?: string;
+    }) => ListItemsResult<TItem>;
+    prompt?: (bag: {
+        items: TItem[];
+        input: TInput;
+        /** The value `getContext` returned, if any. */
+        context?: TContext;
+    }) => ResolverPromptConfig;
+    /** Resolve with no user input (e.g. a configured default), skipping the prompt. */
+    tryResolveWithoutPrompt?: (bag: {
+        imports: ImportsOf<TImports>;
+        input: TInput;
+    }) => Promise<{
+        resolvedValue: unknown;
+    } | null>;
+    /** Search-mode exact match: the typed `search` already names a valid value, so
+     * return it and skip the picker. Returns null to fall through to `listItems`. */
+    tryResolveFromSearch?: (bag: {
+        imports: ImportsOf<TImports>;
+        input: TInput;
+        search?: string;
+    }) => Promise<{
+        resolvedValue: unknown;
+    } | null>;
+}): DynamicResolver;
+declare function defineResolver(config: {
+    type: "static";
+    requireParameters?: readonly string[];
+    inputType?: "text" | "password" | "email" | "search";
+    placeholder?: string;
+}): StaticResolver;
+declare function defineResolver(config: {
+    type: "constant";
+    value: unknown;
+    requireParameters?: readonly string[];
+}): ConstantResolver;
+declare function defineResolver(config: {
+    type: "info";
+    text: string;
+}): InfoResolver;
+declare function defineResolver<const TImports extends ImportsInput = readonly [], TInput = Record<string, unknown>>(config: {
+    type: "object";
+    imports?: TImports & StaticList<TImports>;
+    requireParameters?: readonly string[];
+    properties?: Record<string, Field$1>;
+    /** Build the property map when the key set is dynamic (re-invoked as `input`
+     * grow). Returns the map raw, no envelope. */
+    getProperties?: (bag: {
+        imports: ImportsOf<TImports>;
+        input: TInput;
+    }) => PromiseLike<Record<string, Field$1>>;
+    definitions?: Record<string, Resolver>;
+}): ObjectResolver;
+declare function defineResolver(config: {
+    type: "array";
+    requireParameters?: readonly string[];
+    items: Resolver | ResolverRef;
+    minItems?: number;
+    maxItems?: number;
+    /** Coarse value type of each element, so a free-text item answer coerces
+     * (e.g. `"5"` → `5`) like object fields do via `Field.valueType`. */
+    itemValueType?: string;
+    definitions?: Record<string, Resolver>;
+}): ArrayResolver;
 /**
  * Declare a stand-in for a method registered elsewhere (a configured factory
  * plugin, or just a different module). You reference it by `id` (`namespace/name`,
@@ -2026,6 +2216,308 @@ declare function addPlugin<TSdk extends object, P>(sdk: TSdk, plugin: P, options
     override?: boolean;
 }): asserts sdk is TSdk & AddedSurface<P>;
 
+/**
+ * Public types for the resolution engine: the serializable protocol a host
+ * drives (`start` / `step`), the in-process `resolve` sugar's answerer, and the
+ * reflection shapes (`listMethods` / `getMethod` / `listChoices`). The engine
+ * turns a method's partial input into a complete, validated input by resolving
+ * each parameter, interacting with the host only when it must. See the kitcore
+ * README's "Resolving inputs: controllers" section for worked host examples.
+ */
+/** A candidate value the host renders; the host composes its own display label
+ * from `label`/`hint`. `value` is what flows back in a `choose` action. */
+interface ControllerChoice {
+    label: string;
+    value: string;
+    hint?: string;
+}
+/**
+ * A move the host can make in response to a question, self-described so an agent
+ * can follow it without the type definitions (HATEOAS-lite). `description` says
+ * what it does; `supply` names the single payload field to include when sending
+ * the action (absent = no payload). Enriching an affordance with a full field
+ * schema later is additive and never changes the {@link ControllerAction} it
+ * produces.
+ */
+interface ControllerAffordance {
+    action: ControllerAction["type"];
+    description: string;
+    supply?: "value" | "term";
+}
+/** A question the host renders. Discriminated on `type`; the available moves are
+ * the self-describing `actions` list (single source of truth, no flags). */
+type ControllerQuestion = {
+    type: "select";
+    message: string;
+    /** What this field is, for an agent that lacks the schema. */
+    description?: string;
+    choices: ControllerChoice[];
+    actions: ControllerAffordance[];
+    /** A multi-select (the resolver's `prompt` returned `type: "checkbox"`);
+     * the `choose` action then carries an array. */
+    multiple?: boolean;
+    /** Informational, non-selectable lines (`PromptConfig.notes`), e.g. a
+     * capability hint. A host renders them dimmed, after the choices. */
+    notes?: string[];
+} | {
+    type: "input";
+    message: string;
+    description?: string;
+    inputType: "text" | "password" | "email";
+    placeholder?: string;
+    actions: ControllerAffordance[];
+} | {
+    type: "collection";
+    message: string;
+    description?: string;
+    count: number;
+    min: number;
+    /** Absent when the array is unbounded (no `maxItems`); a finite cap
+     * otherwise. Omitted rather than `Infinity` so the question stays JSON. */
+    max?: number;
+    actions: ControllerAffordance[];
+};
+/** The host's response to a question. The wire shape is frozen: a fuller
+ * HATEOAS affordance schema would still produce exactly these. */
+type ControllerAction = {
+    type: "choose";
+    value: string | string[];
+} | {
+    type: "search";
+    term: string;
+} | {
+    type: "more";
+} | {
+    type: "custom";
+    value: string;
+} | {
+    type: "skip";
+} | {
+    type: "add";
+} | {
+    type: "done";
+} | {
+    type: "cancel";
+} | {
+    type: "retry";
+};
+/** What `start` / `step` return alongside the next state. `ask` carries a
+ * question to answer; `done` the fully resolved input; `invalid` the validation
+ * issues; `failed` a thrown lookup error plus a question offering retry/cancel. */
+type ControllerResult = {
+    status: "ask";
+    question: ControllerQuestion;
+    /** The prior answer's validation failure (`PromptConfig.validate`), when
+     * this is a re-ask. About the last transition, not the question itself. */
+    error?: string;
+} | {
+    status: "done";
+    value: Record<string, unknown>;
+} | {
+    status: "invalid";
+    issues: ControllerIssue[];
+} | {
+    status: "failed";
+    error: ControllerError;
+    question: ControllerQuestion;
+} | {
+    status: "cancelled";
+};
+/** A thrown lookup failure, normalized to plain data at the wall. The engine
+ * catches an arbitrary throwable; a raw `Error` loses its message under
+ * `JSON.stringify` (and a circular/custom value can break transport), so a
+ * `failed` result carries this DTO instead, which a remote host can render. */
+interface ControllerError {
+    name: string;
+    message: string;
+    code?: string;
+}
+/** A single validation problem, keyed to the offending parameter when known. */
+interface ControllerIssue {
+    parameter?: string;
+    message: string;
+}
+/**
+ * The serializable, caller-held progress of a resolution. The host carries it
+ * forward and passes it back into the next `step`; it round-trips across a
+ * client/server boundary unchanged (no closures, no live iterators). It carries
+ * the method id, so `step` needs nothing else.
+ */
+interface ControllerState {
+    method: string;
+    /** The growing input, as a nested tree of *real values only* — objects build
+     * in place (`resolved.inputs.channel`), so a leaf value lives at its {@link ControllerPath}. */
+    resolved: Record<string, unknown>;
+    /** Dotted path-keys the engine is done with: a resolved leaf (value in
+     * `resolved`), a skipped leaf (no value), or a finished array. Objects derive
+     * doneness from their children. The "touched" analog from form libraries. */
+    settled: string[];
+    /** The path of the parameter (or nested field) currently being asked. */
+    current?: ControllerPath;
+    /** Listing progress for the current dynamic leaf (serializable: items +
+     * cursor, never a live iterator). */
+    listing?: ControllerListing;
+    /** Whether the host will prompt. Interactive (the default) always asks;
+     * non-interactive runs `tryResolveWithoutPrompt` to auto-fill what it can
+     * (e.g. configured defaults) before asking for the rest. */
+    interactive: boolean;
+}
+/** A location in the input tree: top-level `["app"]`, a nested object field
+ * `["inputs", "channel"]`, or (later) an array item `["records", 0, "id"]`. */
+type ControllerPath = (string | number)[];
+/** Accumulated candidate items for the current dynamic parameter, plus the
+ * serializable cursor for "load more" and the active search term. */
+interface ControllerListing {
+    items: unknown[];
+    cursor?: string;
+    search?: string;
+    /** True when the source reported no further pages. */
+    exhausted: boolean;
+}
+/**
+ * The one pluggable seam for the in-process `resolve` sugar. It receives the
+ * same `{ state, result }` pair `start`/`step` return (so an answer callback
+ * sees exactly what a host driving the protocol directly would) and produces
+ * the next action. `result` is a question-bearing result — `ask` (the question
+ * plus any prior-answer `error`) or `failed` (a lookup threw; the question
+ * offers `retry`/`cancel`, `error` is the thrown value). `state` is read-only
+ * context (e.g. an agent can inspect `state.resolved`); mutating it is
+ * unsupported. Modality-agnostic — inquirer/DOM, an LLM agent, an auto-select
+ * policy, or a test script all satisfy it. The `start`/`step` protocol needs no
+ * answer callback.
+ */
+type ControllerAnswerFn = (turn: {
+    state: ControllerState;
+    result: Extract<ControllerResult, {
+        status: "ask" | "failed";
+    }>;
+}) => Promise<ControllerAction>;
+/** Per-parameter metadata for reflection (agents / MCP / docs / previews). The
+ * static, no-I/O view, complementing the in-the-moment `question`. */
+interface ControllerParameterDescription {
+    required: boolean;
+    /** True when values come from a fetch (`listItems`) rather than a static set. */
+    dynamic: boolean;
+    /** True when the resolver accepts a free-text search term. */
+    searchable?: boolean;
+    /** The field's serialized type (`z.toJSONSchema` of its input schema). Absent
+     * for a dynamically-shaped field (`getProperties`) with no static schema, or
+     * when the schema can't be represented as JSON Schema. zod never crosses the
+     * wall; this is its plain-data projection. */
+    schema?: Record<string, unknown>;
+    /** Statically known labeled values, when the parameter is a fixed enum. Richer
+     * than `schema.enum` (carries label/hint), so kept alongside `schema`. */
+    choices?: ControllerChoice[];
+    /** Sibling parameters this one depends on (`requireParameters`). A form host
+     * reads this to know which fields are independent (render together) and which
+     * to re-fetch when a dependency changes. */
+    requireParameters?: readonly string[];
+}
+/** A method's lightweight index entry: enough to render a menu or tool list
+ * without the full per-parameter detail. The list face of {@link Controller}. */
+interface ControllerMethodSummary {
+    name: string;
+    description?: string;
+    categories?: string[];
+}
+/** A method's full static contract, serialized: its parameters as a named bag
+ * (mirroring the canonical single-object input), the positional projection if
+ * the surface declares one, and the output type. All plain JSON — the
+ * serializable projection of the registry entry, never its live zod. */
+interface ControllerMethodDescription {
+    name: string;
+    description?: string;
+    categories?: string[];
+    /** Keyed by parameter name (the input bag's shape), not an ordered array:
+     * named-first, since MCP/web/agent hosts fill named slots. Order, when it
+     * matters, lives in `positional`. */
+    parameters: Record<string, ControllerParameterDescription>;
+    /** Ordered input keys the public surface takes as positional args, when the
+     * method declares a positional projection. Absent for a pure single-bag call. */
+    positional?: readonly string[];
+    /** The output type (`z.toJSONSchema` of the output schema), when known. */
+    output?: Record<string, unknown>;
+}
+/**
+ * Drives parameter resolution over a built SDK, reading its registry for the
+ * method's input schema and bound resolvers. Created from an SDK with
+ * `createController(sdk)`; transport-agnostic, so a remote implementation
+ * (browser → server) satisfies the same interface.
+ */
+interface Controller {
+    /** In-process sugar: loop `start`/`step` against an answer callback, return
+     * the resolved input (ready to pass to the SDK method). Throws on cancel. */
+    resolve(opts: {
+        method: string;
+        input?: Record<string, unknown>;
+        answer: ControllerAnswerFn;
+        /** Defaults to true. Pass false for an agent/headless answer callback that
+         * wants configured defaults auto-filled (`tryResolveWithoutPrompt`) rather
+         * than prompted. */
+        interactive?: boolean;
+    }): Promise<Record<string, unknown>>;
+    /** Start resolving: seed from `input`, auto-resolve what needs no interaction,
+     * return the first result (an `ask`, or `done`). */
+    start(opts: {
+        method: string;
+        input?: Record<string, unknown>;
+        /** Defaults to true (always prompt). Pass false for headless/agent hosts to
+         * auto-fill via `tryResolveWithoutPrompt` before asking. */
+        interactive?: boolean;
+    }): Promise<{
+        state: ControllerState;
+        result: ControllerResult;
+    }>;
+    /** Advance with the user's action; return the next state and result. */
+    step(opts: {
+        state: ControllerState;
+        action: ControllerAction;
+    }): Promise<{
+        state: ControllerState;
+        result: ControllerResult;
+    }>;
+    /** Reflection (list): the lightweight index of every method (no I/O). The
+     * `nextCursor` slot mirrors `listChoices` and leaves room for paging a future
+     * dynamic/large method set; unpaged today. */
+    listMethods(): {
+        data: ControllerMethodSummary[];
+        nextCursor?: string;
+    };
+    /** Reflection (item): one method's full static contract, serialized (no I/O).
+     * Named `getMethod` to mirror the SDK's `getApp`/`listApps` resource pair;
+     * returns the method's *description*, not the callable. */
+    getMethod(opts: {
+        method: string;
+    }): {
+        data: ControllerMethodDescription;
+    };
+    /** Reflection: enumerate legal values for one dynamic parameter. */
+    listChoices(opts: {
+        method: string;
+        parameter: string;
+        input?: Record<string, unknown>;
+        search?: string;
+        cursor?: string;
+    }): Promise<{
+        data: ControllerChoice[];
+        nextCursor?: string;
+    }>;
+}
+
+/** The slice of a built SDK the driver needs: its registry accessor. */
+interface ControllerSdk {
+    getRegistry: (options?: {
+        package?: string;
+    }) => RegistryResult;
+}
+/**
+ * Build a {@link Controller} over a built SDK. Reads `sdk.getRegistry()`
+ * at call time (so post-build `addPlugin` additions are visible) to find each
+ * method's canonical input schema and bound resolvers, then drives the engine.
+ * The SDK surface itself is untouched; this is a sibling layer.
+ */
+declare function createController(sdk: ControllerSdk): Controller;
+
 /**
  * Generic utility functions for creating SDK-method wrappers.
  *
@@ -2100,10 +2592,10 @@ declare const CoreErrorCode: {
 type CoreErrorCode = (typeof CoreErrorCode)[keyof typeof CoreErrorCode];
 /**
  * Standard error envelope. kitcore doesn't generate these
- * itself; heads set `errors?: ApiError[]` on their error constructor
+ * itself; heads set `errors?: CoreApiError[]` on their error constructor
  * options when surfacing structured upstream failures.
  */
-interface ApiError {
+interface CoreApiError {
     status: number;
     code: string;
     title: string;
@@ -2229,6 +2721,55 @@ declare function toTitleCase(input: string): string;
  */
 declare function toSnakeCase(input: string): string;
 
+/**
+ * Core signal machinery.
+ *
+ * Signals are intentional control-flow throws — not failures. They're the
+ * sibling of {@link CoreError}: where an error means "something went wrong," a
+ * signal means "stop and do this on purpose." The first (and currently only)
+ * one is {@link CoreCancelledSignal}, thrown by `Controller.resolve` when the
+ * host cancels resolution (its answer callback returned `{ type: "cancel" }`).
+ *
+ * Like errors, every signal is brand-stamped with {@link CORE_SIGNAL_SYMBOL} so
+ * a consumer can recognize one via {@link isCoreSignal} without sharing class
+ * identity — important across the bundled-vs-standalone kitcore boundary.
+ */
+/**
+ * Cross-package brand for kitcore signals. `Symbol.for(key)` reads the
+ * engine-global registry, so the same value resolves across realms and across
+ * multiple copies of kitcore. Use {@link isCoreSignal} for cross-package checks.
+ */
+declare const CORE_SIGNAL_SYMBOL: unique symbol;
+/**
+ * Base class for kitcore signals. A signal is intentional control flow, not an
+ * error, so it does NOT extend any error hierarchy that failure-handling code
+ * sweeps up via `instanceof CoreError`. Subclasses declare a stable `name` and
+ * `code`. (Mirrors the head convention, e.g. zapier-sdk's `ZapierSignal`.)
+ */
+declare abstract class CoreSignal extends Error {
+    abstract readonly name: string;
+    abstract readonly code: string;
+    constructor(message?: string);
+}
+/**
+ * Cross-package-safe check that `value` is a kitcore signal (an intentional
+ * control-flow throw), as opposed to a real error. Survives the
+ * bundled/standalone kitcore split, where `instanceof CoreSignal` may not.
+ */
+declare function isCoreSignal(value: unknown): boolean;
+/**
+ * Thrown by `Controller.resolve` when the host cancels resolution (the answer
+ * callback returned `{ type: "cancel" }`). The lower-level `start`/`step`
+ * protocol instead returns a `{ status: "cancelled" }` result, so a host
+ * driving it directly never sees this throw; `resolve` raises it because its
+ * contract is "the resolved input, or nothing."
+ */
+declare class CoreCancelledSignal extends CoreSignal {
+    readonly name = "CoreCancelledSignal";
+    readonly code: "CANCELLED";
+    constructor(message?: string);
+}
+
 declare const AppKeyPropertySchema: z.ZodString & {
     _def: z.core.$ZodStringDef & PositionalMetadata;
 };
@@ -2313,7 +2854,7 @@ type LeaseLimitProperty = z.infer<typeof LeaseLimitPropertySchema>;
 
 interface ErrorOptions {
     statusCode?: number;
-    errors?: ApiError[];
+    errors?: CoreApiError[];
     cause?: unknown;
     response?: unknown;
 }
@@ -2329,7 +2870,7 @@ declare class ZapierError extends Error {
     readonly name: string;
     readonly code: string;
     statusCode?: number;
-    errors?: ApiError[];
+    errors?: CoreApiError[];
     cause?: unknown;
     response?: unknown;
     constructor(message: string, options?: ErrorOptions);
@@ -2462,7 +3003,7 @@ declare class ZapierActionError extends ZapierError {
         appKey?: string;
         actionKey?: string;
     });
-    get actionErrors(): ApiError[] | undefined;
+    get actionErrors(): CoreApiError[] | undefined;
 }
 /**
  * Error thrown when an operation conflicts with existing state (409). Common
@@ -3631,6 +4172,50 @@ declare const createZapierApi: (options: ApiClientOptions) => ApiClient;
  */
 declare function isPermanentHttpError(err: unknown): boolean;
 
+/**
+ * SDK deprecation notices from API responses.
+ *
+ * Trusted Zapier services tell SDK consumers about upcoming breakages via
+ * response headers: `zapier-sdk-deprecation-message` carries the exact text
+ * to display, `zapier-sdk-deprecation-id` is a stable identifier for deduping
+ * (the message text is the fallback key), and the standard RFC 9745
+ * `Deprecation` header carries machine-readable timing that is forwarded on
+ * the emitted event but never displayed on its own.
+ *
+ * Trust model: Zapier-owned services may write these headers, and Relay
+ * responses are never sniffed at all, so a third-party API can never print
+ * text in a user's terminal through this path — even if a relay deployment
+ * fails to strip the headers. Eligibility is decided by explicit client route
+ * config before sniffing: matched routes are eligible by default, Relay routes
+ * opt out with `omitDeprecationMessaging`, and the resolved gateway pathname
+ * is matched against the configured gateway prefixes so custom baseUrls that
+ * already point at Relay stay excluded.
+ *
+ * The configured baseUrl origin itself is deliberately NOT origin-checked
+ * here. The base URL is the client's trust anchor by definition — it
+ * receives the caller's credentials and controls every byte the SDK
+ * displays (error messages, item titles, ...), so a notice adds nothing an
+ * arbitrary origin couldn't already do, while an origin allowlist would
+ * break localhost, staging, and self-hosted gateway deployments that
+ * legitimately run the version gate or proxy trusted Zapier services. Relay
+ * is different precisely because relay upstreams are NOT user-designated
+ * origins: they're third parties reached through normal, trusted Zapier usage.
+ */
+
+declare const DEPRECATION_NOTICE_EVENT = "api:deprecation_notice";
+interface DeprecationNoticePayload {
+    /** Stable notice identifier; the message text when the id header is absent. */
+    id: string;
+    /** Exact server-composed text to display. */
+    message: string;
+    /**
+     * RFC 9745 deprecation date as Unix epoch milliseconds, parsed from a
+     * `Deprecation: @<seconds>` header. Omitted when the header is absent or
+     * not a structured-field date.
+     */
+    deprecation?: number;
+}
+
 /**
  * Zapier API Client Module
  *
@@ -16546,4 +17131,4 @@ declare const registryPlugin: (sdk: {
     };
 }) => {};
 
-export { type Connection 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 GetConnectionStartUrlItem as G, type Action as H, type App as I, type Field as J, type Choice as K, type LeasedTriggerMessageItem as L, type MethodHooks as M, type Need as N, type OutputFormatter as O, type PluginStack as P, type ActionExecutionResult as Q, type ResolvedAppLocator as R, type SdkContext as S, type TriggerMessageStatus as T, type UpdateManifestEntryOptions as U, type ActionField as V, type WaitForNewConnectionItem as W, type ActionFieldChoice as X, type NeedsRequest as Y, type ZapierSdkOptions as Z, type NeedsResponse as _, type PluginMeta as a, type PollOptions as a$, type ConnectionsResponse as a0, type UserProfile as a1, isPositional as a2, createFunction as a3, createPluginStack as a4, createCorePlugin as a5, addPlugin as a6, createSdk as a7, fromFunctionPlugin as a8, defineLegacyMerge as a9, buildCapabilityMessage as aA, logDeprecation as aB, resetDeprecationWarnings as aC, RelayRequestSchema as aD, RelayFetchSchema as aE, createZapierSdkWithoutRegistry as aF, createOptionsPlugin as aG, createZapierCoreStack as aH, type FunctionRegistryEntry as aI, type FunctionDeprecation as aJ, BaseSdkOptionsSchema as aK, isCoreError as aL, getCoreErrorCode as aM, getCoreErrorCause as aN, CORE_ERROR_SYMBOL as aO, CoreErrorCode as aP, type Plugin as aQ, type PluginProvides as aR, definePlugin as aS, createPluginMethod as aT, createPaginatedPluginMethod as aU, composePlugins as aV, type ActionItem as aW, type ActionTypeItem as aX, getAgent as aY, registryPlugin as aZ, type RequestOptions as a_, dangerousContextPlugin as aa, getContext as ab, defineMethod as ac, defineProperty as ad, declareMethod as ae, declareProperty as af, zapierSdkPlugin as ag, type FormattedItem as ah, type BoundFormatter as ai, type Formatter as aj, type Resolver$1 as ak, type ArrayResolver$1 as al, type ResolverMetadata as am, type StaticResolver$1 as an, type DynamicListResolver as ao, type DynamicSearchResolver as ap, type FieldsResolver as aq, runInMethodScope as ar, runWithTelemetryContext as as, getCallerContext as at, runWithCallerContext as au, type CallerContext as av, toSnakeCase as aw, toTitleCase as ax, batch as ay, type BatchOptions as az, type Manifest as b, type TablesProperty as b$, createZapierApi as b0, getOrCreateApiClient as b1, isPermanentHttpError as b2, type SseMessage as b3, type JsonSseMessage as b4, type AppItem as b5, type ConnectionItem as b6, type ActionItem$1 as b7, type InputFieldItem as b8, type InfoFieldItem as b9, ConnectionsPropertySchema as bA, TriggerInboxPropertySchema as bB, TriggerInboxNamePropertySchema as bC, LeasePropertySchema as bD, LeaseSecondsPropertySchema as bE, LeaseLimitPropertySchema as bF, type AppKeyProperty as bG, type AppProperty as bH, type ActionTypeProperty as bI, type ActionKeyProperty as bJ, type ActionProperty as bK, type InputFieldProperty as bL, type ConnectionIdProperty as bM, type ConnectionProperty as bN, type AuthenticationIdProperty as bO, type InputsProperty as bP, type LimitProperty as bQ, type OffsetProperty as bR, type OutputProperty as bS, type DebugProperty as bT, type ParamsProperty as bU, type ActionTimeoutMsProperty as bV, type TableProperty as bW, type RecordProperty as bX, type RecordsProperty as bY, type FieldsProperty as bZ, type AppsProperty as b_, type RootFieldItem as ba, type UserProfileItem as bb, type SdkPage as bc, type PaginatedSdkFunction as bd, AppKeyPropertySchema as be, AppPropertySchema as bf, ActionTypePropertySchema as bg, ActionKeyPropertySchema as bh, ActionPropertySchema as bi, InputFieldPropertySchema as bj, ConnectionIdPropertySchema as bk, AuthenticationIdPropertySchema as bl, ConnectionPropertySchema as bm, InputsPropertySchema as bn, LimitPropertySchema as bo, OffsetPropertySchema as bp, OutputPropertySchema as bq, DebugPropertySchema as br, ParamsPropertySchema as bs, ActionTimeoutMsPropertySchema as bt, TablePropertySchema as bu, RecordPropertySchema as bv, RecordsPropertySchema as bw, FieldsPropertySchema as bx, AppsPropertySchema as by, TablesPropertySchema as bz, type UpdateManifestEntryResult as c, CONTEXT_CACHE_TTL_MS as c$, type ConnectionsProperty as c0, type TriggerInboxProperty as c1, type TriggerInboxNameProperty as c2, type LeaseProperty as c3, type LeaseSecondsProperty as c4, type LeaseLimitProperty as c5, type ErrorOptions as c6, ZapierError as c7, ZapierValidationError as c8, ZapierUnknownError as c9, type ListAppsPluginProvides as cA, listActionsPlugin as cB, type ListActionsPluginProvides as cC, listActionInputFieldsPlugin as cD, type ListActionInputFieldsPluginProvides as cE, listActionInputFieldChoicesPlugin as cF, type ListActionInputFieldChoicesPluginProvides as cG, getActionInputFieldsSchemaPlugin as cH, type GetActionInputFieldsSchemaPluginProvides as cI, listConnectionsPlugin as cJ, type ListConnectionsPluginProvides as cK, listClientCredentialsPlugin as cL, type ListClientCredentialsPluginProvides as cM, createClientCredentialsPlugin as cN, type CreateClientCredentialsPluginProvides as cO, deleteClientCredentialsPlugin as cP, type DeleteClientCredentialsPluginProvides as cQ, getAppPlugin as cR, type GetAppPluginProvides as cS, getActionPlugin as cT, type GetActionPluginProvides as cU, getConnectionPlugin as cV, type GetConnectionPluginProvides as cW, findFirstConnectionPlugin as cX, type FindFirstConnectionPluginProvides as cY, findUniqueConnectionPlugin as cZ, type FindUniqueConnectionPluginProvides as c_, ZapierAuthenticationError as ca, zapierAdaptError as cb, ZapierApiError as cc, ZapierAppNotFoundError as cd, ZapierNotFoundError as ce, ZapierResourceNotFoundError as cf, ZapierConfigurationError as cg, ZapierBundleError as ch, ZapierTimeoutError as ci, ZapierActionError as cj, ZapierConflictError as ck, type RateLimitInfo as cl, ZapierRateLimitError as cm, type ApprovalStatus as cn, ZapierApprovalError as co, ZapierRelayError as cp, formatErrorMessage as cq, type ApiError as cr, ZapierSignal as cs, appsPlugin as ct, type AppsPluginProvides as cu, type ActionExecutionOptions as cv, type AppFactoryInput as cw, fetchPlugin as cx, type FetchPluginProvides as cy, listAppsPlugin as cz, type AddActionEntryOptions as d, type ResolvedCredentials as d$, CONTEXT_CACHE_MAX_SIZE as d0, runActionPlugin as d1, type RunActionPluginProvides as d2, requestPlugin as d3, type RequestPluginProvides as d4, type ManifestPluginOptions as d5, getPreferredManifestEntryKey as d6, manifestPlugin as d7, type ManifestPluginProvides as d8, DEFAULT_CONFIG_PATH as d9, tableNameResolver as dA, tableFieldsResolver as dB, tableRecordsResolver as dC, tableUpdateRecordsResolver as dD, tableFiltersResolver as dE, tableSortResolver as dF, type ResolveAuthTokenOptions as dG, AuthMechanism as dH, type ResolvedAuth as dI, clearTokenCache as dJ, invalidateCachedToken as dK, injectCliLogin as dL, isCliLoginAvailable as dM, getTokenFromCliLogin as dN, resolveAuth as dO, resolveAuthToken as dP, invalidateCredentialsToken as dQ, type ZapierCache as dR, type ZapierCacheEntry as dS, type ZapierCacheSetOptions as dT, createMemoryCache as dU, type SdkEvent as dV, type AuthEvent as dW, type ApiEvent as dX, type LoadingEvent as dY, type EventCallback as dZ, type Credentials as d_, type ManifestEntry as da, getProfilePlugin as db, type ApiPluginOptions as dc, apiPlugin as dd, type ApiPluginProvides as de, appKeyResolver as df, actionTypeResolver as dg, actionKeyResolver as dh, connectionIdResolver as di, connectionIdGenericResolver as dj, inputsResolver as dk, inputsAllOptionalResolver as dl, inputFieldKeyResolver as dm, clientCredentialsNameResolver as dn, clientIdResolver as dp, tableIdResolver as dq, triggerInboxResolver as dr, workflowIdResolver as ds, durableRunIdResolver as dt, workflowVersionIdResolver as du, workflowRunIdResolver as dv, triggerMessagesResolver as dw, tableRecordIdResolver as dx, tableRecordIdsResolver as dy, tableFieldIdsResolver as dz, type AddActionEntryResult as e, type UpdateTableRecordsPluginProvides as e$, type CredentialsObject as e0, type ClientCredentialsObject as e1, type PkceCredentialsObject as e2, isClientCredentials as e3, isPkceCredentials as e4, isCredentialsObject as e5, isCredentialsFunction as e6, type ResolveCredentialsOptions as e7, resolveCredentialsFromEnv as e8, resolveCredentials as e9, getZapierOpenAutoModeApprovalsInBrowser as eA, getZapierDefaultApprovalMode as eB, DEFAULT_APPROVAL_TIMEOUT_MS as eC, DEFAULT_MAX_APPROVAL_RETRIES as eD, listTablesPlugin as eE, type ListTablesPluginProvides as eF, getTablePlugin as eG, type GetTablePluginProvides as eH, createTablePlugin as eI, type CreateTablePluginProvides as eJ, deleteTablePlugin as eK, type DeleteTablePluginProvides as eL, listTableFieldsPlugin as eM, type ListTableFieldsPluginProvides as eN, createTableFieldsPlugin as eO, type CreateTableFieldsPluginProvides as eP, deleteTableFieldsPlugin as eQ, type DeleteTableFieldsPluginProvides as eR, getTableRecordPlugin as eS, type GetTableRecordPluginProvides as eT, listTableRecordsPlugin as eU, type ListTableRecordsPluginProvides as eV, createTableRecordsPlugin as eW, type CreateTableRecordsPluginProvides as eX, deleteTableRecordsPlugin as eY, type DeleteTableRecordsPluginProvides as eZ, updateTableRecordsPlugin as e_, getBaseUrlFromCredentials as ea, getClientIdFromCredentials as eb, ClientCredentialsObjectSchema as ec, PkceCredentialsObjectSchema as ed, CredentialsObjectSchema as ee, ResolvedCredentialsSchema as ef, CredentialsFunctionSchema as eg, type CredentialsFunction as eh, CredentialsSchema as ei, ConnectionEntrySchema as ej, type ConnectionEntry as ek, ConnectionsMapSchema as el, type ConnectionsMap as em, connectionsPlugin as en, type ConnectionsPluginProvides as eo, ZAPIER_BASE_URL as ep, getZapierSdkService as eq, MAX_PAGE_LIMIT as er, DEFAULT_PAGE_SIZE as es, DEFAULT_ACTION_TIMEOUT_MS as et, ZAPIER_MAX_NETWORK_RETRIES as eu, ZAPIER_MAX_NETWORK_RETRY_DELAY_MS as ev, MAX_CONCURRENCY_LIMIT as ew, parseConcurrencyEnvVar as ex, ZAPIER_MAX_CONCURRENT_REQUESTS as ey, getZapierApprovalMode as ez, type ActionEntry as f, cleanupEventListeners as f0, type EventEmissionConfig as f1, eventEmissionPlugin as f2, type EventEmissionProvides as f3, type EventContext as f4, type ApplicationLifecycleEventData as f5, type EnhancedErrorEventData as f6, type MethodCalledEventData as f7, buildApplicationLifecycleEvent as f8, buildErrorEventWithContext as f9, buildErrorEvent as fa, createBaseEvent as fb, buildMethodCalledEvent as fc, type BaseEvent as fd, type MethodCalledEvent as fe, generateEventId as ff, getCurrentTimestamp as fg, getReleaseId as fh, getOsInfo as fi, getPlatformVersions as fj, isCi as fk, getCiPlatform as fl, getMemoryUsage as fm, getCpuTime as fn, getTtyContext as fo, createZapierSdk as fp, createZapierSdkStack as fq, type ZapierSdk as fr, findManifestEntry as g, type CapabilitiesContext as h, type PaginatedSdkResult as i, type CreateConnectionItem as j, type PositionalMetadata as k, type ZapierFetchInitOptions as l, type DynamicResolver$1 as m, type WatchTriggerInboxOptions as n, type ActionProxy as o, type ZapierSdkApps as p, type RegistryResult as q, readManifestFromFile as r, ZapierAbortDrainSignal as s, ZapierReleaseTriggerMessageSignal as t, type DrainTriggerInboxCallback as u, type DrainTriggerInboxErrorObserver as v, type ListAuthenticationsPluginProvides as w, type GetAuthenticationPluginProvides as x, type FindFirstAuthenticationPluginProvides as y, type FindUniqueAuthenticationPluginProvides as z };
+export { type Connection 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 GetConnectionStartUrlItem as G, type Action as H, type App as I, type Field as J, type Choice as K, type LeasedTriggerMessageItem as L, type MethodHooks as M, type Need as N, type OutputFormatter as O, type PluginStack as P, type ActionExecutionResult as Q, type ResolvedAppLocator as R, type SdkContext as S, type TriggerMessageStatus as T, type UpdateManifestEntryOptions as U, type ActionField as V, type WaitForNewConnectionItem as W, type ActionFieldChoice as X, type NeedsRequest as Y, type ZapierSdkOptions as Z, type NeedsResponse as _, type PluginMeta as a, CORE_SIGNAL_SYMBOL as a$, type ConnectionsResponse as a0, type UserProfile as a1, isPositional as a2, createFunction as a3, createPluginStack as a4, createCorePlugin as a5, addPlugin as a6, createSdk as a7, fromFunctionPlugin as a8, defineLegacyMerge as a9, runWithTelemetryContext as aA, getCallerContext as aB, runWithCallerContext as aC, type CallerContext as aD, toSnakeCase as aE, toTitleCase as aF, batch as aG, type BatchOptions as aH, buildCapabilityMessage as aI, logDeprecation as aJ, resetDeprecationWarnings as aK, RelayRequestSchema as aL, RelayFetchSchema as aM, createZapierSdkWithoutRegistry 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, CoreSignal as aY, CoreCancelledSignal as aZ, isCoreSignal as a_, dangerousContextPlugin as aa, getContext as ab, defineMethod as ac, defineProperty as ad, defineResolver as ae, declareMethod as af, declareProperty as ag, zapierSdkPlugin as ah, type FormattedItem as ai, type BoundFormatter as aj, type Formatter as ak, type Resolver$1 as al, type ArrayResolver$1 as am, type ResolverMetadata as an, type StaticResolver$1 as ao, type DynamicListResolver as ap, type DynamicSearchResolver as aq, type FieldsResolver as ar, createController as as, type ControllerQuestion as at, type ControllerAction as au, type ControllerAnswerFn as av, type ControllerMethodSummary as aw, type ControllerMethodDescription as ax, type ControllerParameterDescription as ay, runInMethodScope as az, type Manifest as b, type ConnectionProperty as b$, type Plugin as b0, type PluginProvides as b1, definePlugin as b2, createPluginMethod as b3, createPaginatedPluginMethod as b4, composePlugins as b5, type ActionItem as b6, type ActionTypeItem as b7, getAgent as b8, registryPlugin as b9, ConnectionPropertySchema as bA, InputsPropertySchema as bB, LimitPropertySchema as bC, OffsetPropertySchema as bD, OutputPropertySchema as bE, DebugPropertySchema as bF, ParamsPropertySchema as bG, ActionTimeoutMsPropertySchema as bH, TablePropertySchema as bI, RecordPropertySchema as bJ, RecordsPropertySchema as bK, FieldsPropertySchema as bL, AppsPropertySchema as bM, TablesPropertySchema as bN, ConnectionsPropertySchema as bO, TriggerInboxPropertySchema as bP, TriggerInboxNamePropertySchema as bQ, LeasePropertySchema as bR, LeaseSecondsPropertySchema as bS, LeaseLimitPropertySchema as bT, type AppKeyProperty as bU, type AppProperty as bV, type ActionTypeProperty as bW, type ActionKeyProperty as bX, type ActionProperty as bY, type InputFieldProperty as bZ, type ConnectionIdProperty as b_, type RequestOptions as ba, type PollOptions as bb, createZapierApi as bc, getOrCreateApiClient as bd, isPermanentHttpError as be, type SseMessage as bf, type JsonSseMessage as bg, DEPRECATION_NOTICE_EVENT as bh, type DeprecationNoticePayload as bi, type AppItem as bj, type ConnectionItem as bk, type ActionItem$1 as bl, type InputFieldItem as bm, type InfoFieldItem as bn, type RootFieldItem as bo, type UserProfileItem as bp, type SdkPage as bq, type PaginatedSdkFunction as br, AppKeyPropertySchema as bs, AppPropertySchema as bt, ActionTypePropertySchema as bu, ActionKeyPropertySchema as bv, ActionPropertySchema as bw, InputFieldPropertySchema as bx, ConnectionIdPropertySchema as by, AuthenticationIdPropertySchema as bz, type UpdateManifestEntryResult as c, createClientCredentialsPlugin as c$, type AuthenticationIdProperty as c0, type InputsProperty as c1, type LimitProperty as c2, type OffsetProperty as c3, type OutputProperty as c4, type DebugProperty as c5, type ParamsProperty as c6, type ActionTimeoutMsProperty as c7, type TableProperty as c8, type RecordProperty as c9, ZapierRateLimitError as cA, type ApprovalStatus as cB, ZapierApprovalError as cC, ZapierRelayError as cD, formatErrorMessage as cE, type CoreApiError as cF, ZapierSignal as cG, appsPlugin as cH, type AppsPluginProvides as cI, type ActionExecutionOptions as cJ, type AppFactoryInput as cK, fetchPlugin as cL, type FetchPluginProvides as cM, listAppsPlugin as cN, type ListAppsPluginProvides as cO, listActionsPlugin as cP, type ListActionsPluginProvides as cQ, listActionInputFieldsPlugin as cR, type ListActionInputFieldsPluginProvides as cS, listActionInputFieldChoicesPlugin as cT, type ListActionInputFieldChoicesPluginProvides as cU, getActionInputFieldsSchemaPlugin as cV, type GetActionInputFieldsSchemaPluginProvides as cW, listConnectionsPlugin as cX, type ListConnectionsPluginProvides as cY, listClientCredentialsPlugin as cZ, type ListClientCredentialsPluginProvides as c_, type RecordsProperty as ca, type FieldsProperty as cb, type AppsProperty as cc, type TablesProperty as cd, type ConnectionsProperty as ce, type TriggerInboxProperty as cf, type TriggerInboxNameProperty as cg, type LeaseProperty as ch, type LeaseSecondsProperty as ci, type LeaseLimitProperty as cj, type ErrorOptions as ck, ZapierError as cl, ZapierValidationError as cm, ZapierUnknownError as cn, ZapierAuthenticationError as co, zapierAdaptError as cp, ZapierApiError as cq, ZapierAppNotFoundError as cr, ZapierNotFoundError as cs, ZapierResourceNotFoundError as ct, ZapierConfigurationError as cu, ZapierBundleError as cv, ZapierTimeoutError as cw, ZapierActionError as cx, ZapierConflictError as cy, type RateLimitInfo as cz, type AddActionEntryOptions as d, getTokenFromCliLogin as d$, type CreateClientCredentialsPluginProvides as d0, deleteClientCredentialsPlugin as d1, type DeleteClientCredentialsPluginProvides as d2, getAppPlugin as d3, type GetAppPluginProvides as d4, getActionPlugin as d5, type GetActionPluginProvides as d6, getConnectionPlugin as d7, type GetConnectionPluginProvides as d8, findFirstConnectionPlugin as d9, inputsAllOptionalResolver as dA, inputFieldKeyResolver as dB, clientCredentialsNameResolver as dC, clientIdResolver as dD, tableIdResolver as dE, triggerInboxResolver as dF, workflowIdResolver as dG, durableRunIdResolver as dH, workflowVersionIdResolver as dI, workflowRunIdResolver as dJ, triggerMessagesResolver as dK, tableRecordIdResolver as dL, tableRecordIdsResolver as dM, tableFieldIdsResolver as dN, tableNameResolver as dO, tableFieldsResolver as dP, tableRecordsResolver as dQ, tableUpdateRecordsResolver as dR, tableFiltersResolver as dS, tableSortResolver as dT, type ResolveAuthTokenOptions as dU, AuthMechanism as dV, type ResolvedAuth as dW, clearTokenCache as dX, invalidateCachedToken as dY, injectCliLogin as dZ, isCliLoginAvailable as d_, type FindFirstConnectionPluginProvides as da, findUniqueConnectionPlugin as db, type FindUniqueConnectionPluginProvides as dc, CONTEXT_CACHE_TTL_MS as dd, CONTEXT_CACHE_MAX_SIZE as de, runActionPlugin as df, type RunActionPluginProvides as dg, requestPlugin as dh, type RequestPluginProvides as di, type ManifestPluginOptions as dj, getPreferredManifestEntryKey as dk, manifestPlugin as dl, type ManifestPluginProvides as dm, DEFAULT_CONFIG_PATH as dn, type ManifestEntry as dp, getProfilePlugin as dq, type ApiPluginOptions as dr, apiPlugin as ds, type ApiPluginProvides as dt, appKeyResolver as du, actionTypeResolver as dv, actionKeyResolver as dw, connectionIdResolver as dx, connectionIdGenericResolver as dy, inputsResolver as dz, type AddActionEntryResult as e, type ListTableFieldsPluginProvides as e$, resolveAuth as e0, resolveAuthToken as e1, invalidateCredentialsToken as e2, type ZapierCache as e3, type ZapierCacheEntry as e4, type ZapierCacheSetOptions as e5, createMemoryCache as e6, type SdkEvent as e7, type AuthEvent as e8, type ApiEvent as e9, type ConnectionsMap as eA, connectionsPlugin as eB, type ConnectionsPluginProvides as eC, ZAPIER_BASE_URL as eD, getZapierSdkService as eE, MAX_PAGE_LIMIT as eF, DEFAULT_PAGE_SIZE as eG, DEFAULT_ACTION_TIMEOUT_MS as eH, ZAPIER_MAX_NETWORK_RETRIES as eI, ZAPIER_MAX_NETWORK_RETRY_DELAY_MS as eJ, MAX_CONCURRENCY_LIMIT as eK, parseConcurrencyEnvVar as eL, ZAPIER_MAX_CONCURRENT_REQUESTS as eM, getZapierApprovalMode as eN, getZapierOpenAutoModeApprovalsInBrowser as eO, getZapierDefaultApprovalMode as eP, DEFAULT_APPROVAL_TIMEOUT_MS as eQ, DEFAULT_MAX_APPROVAL_RETRIES as eR, listTablesPlugin as eS, type ListTablesPluginProvides as eT, getTablePlugin as eU, type GetTablePluginProvides as eV, createTablePlugin as eW, type CreateTablePluginProvides as eX, deleteTablePlugin as eY, type DeleteTablePluginProvides as eZ, listTableFieldsPlugin as e_, type LoadingEvent as ea, type EventCallback as eb, type Credentials as ec, type ResolvedCredentials as ed, type CredentialsObject as ee, type ClientCredentialsObject as ef, type PkceCredentialsObject as eg, isClientCredentials as eh, isPkceCredentials as ei, isCredentialsObject as ej, isCredentialsFunction as ek, type ResolveCredentialsOptions as el, resolveCredentialsFromEnv as em, resolveCredentials as en, getBaseUrlFromCredentials as eo, getClientIdFromCredentials as ep, ClientCredentialsObjectSchema as eq, PkceCredentialsObjectSchema as er, CredentialsObjectSchema as es, ResolvedCredentialsSchema as et, CredentialsFunctionSchema as eu, type CredentialsFunction as ev, CredentialsSchema as ew, ConnectionEntrySchema as ex, type ConnectionEntry as ey, ConnectionsMapSchema as ez, type ActionEntry as f, createTableFieldsPlugin as f0, type CreateTableFieldsPluginProvides as f1, deleteTableFieldsPlugin as f2, type DeleteTableFieldsPluginProvides as f3, getTableRecordPlugin as f4, type GetTableRecordPluginProvides as f5, listTableRecordsPlugin as f6, type ListTableRecordsPluginProvides as f7, createTableRecordsPlugin as f8, type CreateTableRecordsPluginProvides as f9, getMemoryUsage as fA, getCpuTime as fB, getTtyContext as fC, createZapierSdk as fD, createZapierSdkStack as fE, type ZapierSdk as fF, deleteTableRecordsPlugin as fa, type DeleteTableRecordsPluginProvides as fb, updateTableRecordsPlugin as fc, type UpdateTableRecordsPluginProvides as fd, cleanupEventListeners as fe, type EventEmissionConfig as ff, eventEmissionPlugin as fg, type EventEmissionProvides as fh, type EventContext as fi, type ApplicationLifecycleEventData as fj, type EnhancedErrorEventData as fk, type MethodCalledEventData as fl, buildApplicationLifecycleEvent as fm, buildErrorEventWithContext as fn, buildErrorEvent as fo, createBaseEvent as fp, buildMethodCalledEvent as fq, type BaseEvent as fr, type MethodCalledEvent as fs, generateEventId as ft, getCurrentTimestamp as fu, getReleaseId as fv, getOsInfo as fw, getPlatformVersions as fx, isCi as fy, getCiPlatform as fz, findManifestEntry as g, type CapabilitiesContext as h, type PaginatedSdkResult as i, type CreateConnectionItem as j, type PositionalMetadata as k, type ZapierFetchInitOptions as l, type DynamicResolver$1 as m, type WatchTriggerInboxOptions as n, type ActionProxy as o, type ZapierSdkApps as p, type RegistryResult as q, readManifestFromFile as r, ZapierAbortDrainSignal as s, ZapierReleaseTriggerMessageSignal as t, type DrainTriggerInboxCallback as u, type DrainTriggerInboxErrorObserver as v, type ListAuthenticationsPluginProvides as w, type GetAuthenticationPluginProvides as x, type FindFirstAuthenticationPluginProvides as y, type FindUniqueAuthenticationPluginProvides as z };