@zapier/zapier-sdk 0.79.0 → 0.80.0

package/dist/{index-DgX1b0Sv.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
@@ -16590,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 FieldsProperty as b$, createZapierApi as b0, getOrCreateApiClient as b1, isPermanentHttpError as b2, type SseMessage as b3, type JsonSseMessage as b4, DEPRECATION_NOTICE_EVENT as b5, type DeprecationNoticePayload as b6, type AppItem as b7, type ConnectionItem as b8, type ActionItem$1 as b9, AppsPropertySchema as bA, TablesPropertySchema as bB, ConnectionsPropertySchema as bC, TriggerInboxPropertySchema as bD, TriggerInboxNamePropertySchema as bE, LeasePropertySchema as bF, LeaseSecondsPropertySchema as bG, LeaseLimitPropertySchema as bH, type AppKeyProperty as bI, type AppProperty as bJ, type ActionTypeProperty as bK, type ActionKeyProperty as bL, type ActionProperty as bM, type InputFieldProperty as bN, type ConnectionIdProperty as bO, type ConnectionProperty as bP, type AuthenticationIdProperty as bQ, type InputsProperty as bR, type LimitProperty as bS, type OffsetProperty as bT, type OutputProperty as bU, type DebugProperty as bV, type ParamsProperty as bW, type ActionTimeoutMsProperty as bX, type TableProperty as bY, type RecordProperty as bZ, type RecordsProperty as b_, type InputFieldItem as ba, type InfoFieldItem as bb, type RootFieldItem as bc, type UserProfileItem as bd, type SdkPage as be, type PaginatedSdkFunction as bf, AppKeyPropertySchema as bg, AppPropertySchema as bh, ActionTypePropertySchema as bi, ActionKeyPropertySchema as bj, ActionPropertySchema as bk, InputFieldPropertySchema as bl, ConnectionIdPropertySchema as bm, AuthenticationIdPropertySchema as bn, ConnectionPropertySchema as bo, InputsPropertySchema as bp, LimitPropertySchema as bq, OffsetPropertySchema as br, OutputPropertySchema as bs, DebugPropertySchema as bt, ParamsPropertySchema as bu, ActionTimeoutMsPropertySchema as bv, TablePropertySchema as bw, RecordPropertySchema as bx, RecordsPropertySchema as by, FieldsPropertySchema as bz, type UpdateManifestEntryResult as c, findUniqueConnectionPlugin as c$, type AppsProperty as c0, type TablesProperty as c1, type ConnectionsProperty as c2, type TriggerInboxProperty as c3, type TriggerInboxNameProperty as c4, type LeaseProperty as c5, type LeaseSecondsProperty as c6, type LeaseLimitProperty as c7, type ErrorOptions as c8, ZapierError as c9, type FetchPluginProvides as cA, listAppsPlugin as cB, type ListAppsPluginProvides as cC, listActionsPlugin as cD, type ListActionsPluginProvides as cE, listActionInputFieldsPlugin as cF, type ListActionInputFieldsPluginProvides as cG, listActionInputFieldChoicesPlugin as cH, type ListActionInputFieldChoicesPluginProvides as cI, getActionInputFieldsSchemaPlugin as cJ, type GetActionInputFieldsSchemaPluginProvides as cK, listConnectionsPlugin as cL, type ListConnectionsPluginProvides as cM, listClientCredentialsPlugin as cN, type ListClientCredentialsPluginProvides as cO, createClientCredentialsPlugin as cP, type CreateClientCredentialsPluginProvides as cQ, deleteClientCredentialsPlugin as cR, type DeleteClientCredentialsPluginProvides as cS, getAppPlugin as cT, type GetAppPluginProvides as cU, getActionPlugin as cV, type GetActionPluginProvides as cW, getConnectionPlugin as cX, type GetConnectionPluginProvides as cY, findFirstConnectionPlugin as cZ, type FindFirstConnectionPluginProvides as c_, ZapierValidationError as ca, ZapierUnknownError as cb, ZapierAuthenticationError as cc, zapierAdaptError as cd, ZapierApiError as ce, ZapierAppNotFoundError as cf, ZapierNotFoundError as cg, ZapierResourceNotFoundError as ch, ZapierConfigurationError as ci, ZapierBundleError as cj, ZapierTimeoutError as ck, ZapierActionError as cl, ZapierConflictError as cm, type RateLimitInfo as cn, ZapierRateLimitError as co, type ApprovalStatus as cp, ZapierApprovalError as cq, ZapierRelayError as cr, formatErrorMessage as cs, type ApiError as ct, ZapierSignal as cu, appsPlugin as cv, type AppsPluginProvides as cw, type ActionExecutionOptions as cx, type AppFactoryInput as cy, fetchPlugin as cz, type AddActionEntryOptions as d, type EventCallback as d$, type FindUniqueConnectionPluginProvides as d0, CONTEXT_CACHE_TTL_MS as d1, CONTEXT_CACHE_MAX_SIZE as d2, runActionPlugin as d3, type RunActionPluginProvides as d4, requestPlugin as d5, type RequestPluginProvides as d6, type ManifestPluginOptions as d7, getPreferredManifestEntryKey as d8, manifestPlugin as d9, tableRecordIdsResolver as dA, tableFieldIdsResolver as dB, tableNameResolver as dC, tableFieldsResolver as dD, tableRecordsResolver as dE, tableUpdateRecordsResolver as dF, tableFiltersResolver as dG, tableSortResolver as dH, type ResolveAuthTokenOptions as dI, AuthMechanism as dJ, type ResolvedAuth as dK, clearTokenCache as dL, invalidateCachedToken as dM, injectCliLogin as dN, isCliLoginAvailable as dO, getTokenFromCliLogin as dP, resolveAuth as dQ, resolveAuthToken as dR, invalidateCredentialsToken as dS, type ZapierCache as dT, type ZapierCacheEntry as dU, type ZapierCacheSetOptions as dV, createMemoryCache as dW, type SdkEvent as dX, type AuthEvent as dY, type ApiEvent as dZ, type LoadingEvent as d_, type ManifestPluginProvides as da, DEFAULT_CONFIG_PATH as db, type ManifestEntry as dc, getProfilePlugin as dd, type ApiPluginOptions as de, apiPlugin as df, type ApiPluginProvides as dg, appKeyResolver as dh, actionTypeResolver as di, actionKeyResolver as dj, connectionIdResolver as dk, connectionIdGenericResolver as dl, inputsResolver as dm, inputsAllOptionalResolver as dn, inputFieldKeyResolver as dp, clientCredentialsNameResolver as dq, clientIdResolver as dr, tableIdResolver as ds, triggerInboxResolver as dt, workflowIdResolver as du, durableRunIdResolver as dv, workflowVersionIdResolver as dw, workflowRunIdResolver as dx, triggerMessagesResolver as dy, tableRecordIdResolver as dz, type AddActionEntryResult as e, type DeleteTableRecordsPluginProvides as e$, type Credentials as e0, type ResolvedCredentials as e1, type CredentialsObject as e2, type ClientCredentialsObject as e3, type PkceCredentialsObject as e4, isClientCredentials as e5, isPkceCredentials as e6, isCredentialsObject as e7, isCredentialsFunction as e8, type ResolveCredentialsOptions as e9, ZAPIER_MAX_CONCURRENT_REQUESTS as eA, getZapierApprovalMode as eB, getZapierOpenAutoModeApprovalsInBrowser as eC, getZapierDefaultApprovalMode as eD, DEFAULT_APPROVAL_TIMEOUT_MS as eE, DEFAULT_MAX_APPROVAL_RETRIES as eF, listTablesPlugin as eG, type ListTablesPluginProvides as eH, getTablePlugin as eI, type GetTablePluginProvides as eJ, createTablePlugin as eK, type CreateTablePluginProvides as eL, deleteTablePlugin as eM, type DeleteTablePluginProvides as eN, listTableFieldsPlugin as eO, type ListTableFieldsPluginProvides as eP, createTableFieldsPlugin as eQ, type CreateTableFieldsPluginProvides as eR, deleteTableFieldsPlugin as eS, type DeleteTableFieldsPluginProvides as eT, getTableRecordPlugin as eU, type GetTableRecordPluginProvides as eV, listTableRecordsPlugin as eW, type ListTableRecordsPluginProvides as eX, createTableRecordsPlugin as eY, type CreateTableRecordsPluginProvides as eZ, deleteTableRecordsPlugin as e_, resolveCredentialsFromEnv as ea, resolveCredentials as eb, getBaseUrlFromCredentials as ec, getClientIdFromCredentials as ed, ClientCredentialsObjectSchema as ee, PkceCredentialsObjectSchema as ef, CredentialsObjectSchema as eg, ResolvedCredentialsSchema as eh, CredentialsFunctionSchema as ei, type CredentialsFunction as ej, CredentialsSchema as ek, ConnectionEntrySchema as el, type ConnectionEntry as em, ConnectionsMapSchema as en, type ConnectionsMap as eo, connectionsPlugin as ep, type ConnectionsPluginProvides as eq, ZAPIER_BASE_URL as er, getZapierSdkService as es, MAX_PAGE_LIMIT as et, DEFAULT_PAGE_SIZE as eu, DEFAULT_ACTION_TIMEOUT_MS as ev, ZAPIER_MAX_NETWORK_RETRIES as ew, ZAPIER_MAX_NETWORK_RETRY_DELAY_MS as ex, MAX_CONCURRENCY_LIMIT as ey, parseConcurrencyEnvVar as ez, type ActionEntry as f, updateTableRecordsPlugin as f0, type UpdateTableRecordsPluginProvides as f1, cleanupEventListeners as f2, type EventEmissionConfig as f3, eventEmissionPlugin as f4, type EventEmissionProvides as f5, type EventContext as f6, type ApplicationLifecycleEventData as f7, type EnhancedErrorEventData as f8, type MethodCalledEventData as f9, buildApplicationLifecycleEvent as fa, buildErrorEventWithContext as fb, buildErrorEvent as fc, createBaseEvent as fd, buildMethodCalledEvent as fe, type BaseEvent as ff, type MethodCalledEvent as fg, generateEventId as fh, getCurrentTimestamp as fi, getReleaseId as fj, getOsInfo as fk, getPlatformVersions as fl, isCi as fm, getCiPlatform as fn, getMemoryUsage as fo, getCpuTime as fp, getTtyContext as fq, createZapierSdk as fr, createZapierSdkStack as fs, type ZapierSdk as ft, 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 };