@zapier/kitcore 0.8.0 → 0.10.0

package/dist/index.d.ts

@@ -61,6 +61,83 @@ interface PaginatedSdkResult<TItem> extends Promise<SdkPage<TItem>> {
 }
 type PaginatedSdkFunction<TOptions, TItem> = (options: TOptions) => PaginatedSdkResult<TItem>;
 
+/**
+ * Per-call context threaded explicitly through the method boundary in place of
+ * ambient AsyncLocalStorage. It carries call identity, nesting depth, and a
+ * per-invocation annotation bag. Because it travels as data, correlation and
+ * nested-call dedup work without `async_hooks` — including in browsers, where
+ * the old ALS store was inert and nested calls all looked top-level.
+ *
+ * Framework-neutral: heads surface `callId` under their own name (e.g. a
+ * correlation id) and own their annotation field names.
+ */
+/**
+ * A private brand (a fresh `Symbol()`, never `Symbol.for`) makes a CallContext
+ * unforgeable: no outside code can name the symbol to synthesize an id-bearing
+ * context, and the brand never collides across bundled copies. This is the same
+ * unforgeability the `INTERNAL_CALL` sentinel relies on.
+ */
+declare const CALL_CONTEXT_BRAND: unique symbol;
+interface CallContext {
+    /** Minted once at the root call; copied verbatim to every nested (child) call. */
+    callId: string | null;
+    /** 0 at the outermost call; `parent.depth + 1` for a delegated call. */
+    depth: number;
+    /**
+     * Per-invocation scratch space. Never forwarded to callees — a child call
+     * gets a fresh bag — so annotations describe one method's own invocation.
+     */
+    annotations: Record<string, unknown>;
+    readonly [CALL_CONTEXT_BRAND]: true;
+}
+
+/**
+ * Method-call lifecycle hooks. Plugins contribute `onMethodStart` and/or
+ * `onMethodEnd` on their context; `buildHooks` composes contributions across
+ * plugins so multiple observers can coexist. Composition is right-additive
+ * (newer plugins fire after earlier ones); only opt-in methods built through
+ * `createPluginMethod` / `createPaginatedPluginMethod` trigger the hooks.
+ */
+interface OnMethodStartContext {
+    methodName: string;
+    args: unknown[];
+    isPaginated: boolean;
+    /**
+     * Depth of this method invocation in the SDK call tree. 0 = outermost
+     * (user-initiated) call; 1+ = called from inside another SDK method.
+     * Observers can use this to ignore nested calls if they only want
+     * top-level events.
+     */
+    depth: number;
+}
+type OnMethodStart = (ctx: OnMethodStartContext) => void;
+interface OnMethodEndContext {
+    methodName: string;
+    args: unknown[];
+    isPaginated: boolean;
+    depth: number;
+    durationMs: number;
+    error?: Error;
+}
+type OnMethodEnd = (ctx: OnMethodEndContext) => void;
+interface MethodHooks {
+    onMethodStart?: OnMethodStart;
+    onMethodEnd?: OnMethodEnd;
+}
+
+/**
+ * Plugins with a required-parameter rename declare two schemas: a canonical one
+ * (new names only, carrying `.meta({ aliases })`) and a `z.union([canonical,
+ * deprecated])` for runtime input parsing (so callers passing old names still
+ * validate). The union has no object shape, so everything that reads parameter
+ * shape/requiredness — the registry projection, generated docs, and the
+ * resolution planner — must read the canonical variant, not the union.
+ *
+ * Convention: the FIRST union variant is the canonical schema. Every plugin
+ * that uses unions follows this; it's explicit and needs no extra metadata.
+ * Runtime validation still uses the full union; only shape reading canonicalizes.
+ */
+declare function canonicalInputSchema(schema: z.ZodSchema | undefined): z.ZodSchema | undefined;
 interface FormattedItem {
     title: string;
     /**
@@ -157,8 +234,6 @@ type ListPromptConfig = PromptConfig & {
  *  - `filter`  — no resolver uses it; transform values in `listItems` instead.
  *  - `validate`— validation is the resolver's top-level `validate`, which
  *    never routes through rendering (and gets `imports`).
- * (The legacy `SchemaParameterResolver` still honors `default`/`filter`/
- * `validate`, so the full `PromptConfig` stays for that path.)
  */
 type ResolverPromptConfig = Omit<PromptConfig, "name" | "default" | "filter" | "validate">;
 interface Resolver$1 {
@@ -338,40 +413,6 @@ declare function withPositional<T extends z.ZodType>(schema: T): T & {
 declare function isPositional(schema: z.ZodType): boolean;
 declare function openEnum<const T extends readonly [string, ...string[]]>(values: T, description: string): z.ZodUnion<readonly [z.ZodEnum<{ [k_1 in T[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: { [k_1 in T[number]]: k_1; }[k]; } : never>, z.ZodString]>;
 
-/**
- * Method-call lifecycle hooks. Plugins contribute `onMethodStart` and/or
- * `onMethodEnd` on their context; `buildHooks` composes contributions across
- * plugins so multiple observers can coexist. Composition is right-additive
- * (newer plugins fire after earlier ones); only opt-in methods built through
- * `createPluginMethod` / `createPaginatedPluginMethod` trigger the hooks.
- */
-interface OnMethodStartContext {
-    methodName: string;
-    args: unknown[];
-    isPaginated: boolean;
-    /**
-     * Depth of this method invocation in the SDK call tree. 0 = outermost
-     * (user-initiated) call; 1+ = called from inside another SDK method.
-     * Observers can use this to ignore nested calls if they only want
-     * top-level events.
-     */
-    depth: number;
-}
-type OnMethodStart = (ctx: OnMethodStartContext) => void;
-interface OnMethodEndContext {
-    methodName: string;
-    args: unknown[];
-    isPaginated: boolean;
-    depth: number;
-    durationMs: number;
-    error?: Error;
-}
-type OnMethodEnd = (ctx: OnMethodEndContext) => void;
-interface MethodHooks {
-    onMethodStart?: OnMethodStart;
-    onMethodEnd?: OnMethodEnd;
-}
-
 /**
  * Descriptive metadata a leaf carries for the registry / CLI / MCP / docs:
  * description, categories, type, formatter, resolvers, etc.
@@ -394,10 +435,6 @@ interface LeafMetaFields {
     itemType?: string;
     returnType?: string;
     outputSchema?: z.ZodSchema;
-    inputParameters?: Array<{
-        name: string;
-        schema: z.ZodSchema;
-    }>;
     packages?: string[];
     experimental?: boolean;
     confirm?: "create-secret" | "delete";
@@ -571,12 +608,11 @@ interface DynamicResolver extends ResolverBase {
         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`. Required: a dynamic
-     * resolver IS a candidate-lister; a free-text field (with or without
-     * auto-resolution someday) is the `static` kind's job. */
+     * paginated result (the engine awaits the first page + `nextCursor`), never a
+     * bare array. `cursor` is the stateless re-entry hook for "load more": the
+     * engine awaits one page, carries `nextCursor`, and calls again with `cursor`.
+     * Required: a dynamic resolver IS a candidate-lister; a free-text field (with
+     * or without auto-resolution someday) is the `static` kind's job. */
     listItems: (bag: {
         imports: Record<string, unknown>;
         input: Record<string, unknown>;
@@ -660,6 +696,27 @@ interface ObjectResolver extends ResolverBase {
         input: Record<string, unknown>;
     }) => PromiseLike<Record<string, Field>>;
     definitions?: Record<string, Resolver>;
+    /** Open-ended entries whose keys aren't known up front (a `z.record`): the
+     * walk collects entries in an add/done loop, asking each entry's key (via
+     * `keys`, default a free-text string) then its value (via `values`), and
+     * assembling them onto the object alongside any fixed `properties`. The
+     * JSON-Schema `additionalProperties` analog. */
+    additionalKeys?: AdditionalKeys;
+}
+/** The open-keyed-entry spec for an {@link ObjectResolver.additionalKeys}. */
+interface AdditionalKeys {
+    /** Resolver for each entry's key; defaults to a free-text string prompt. A
+     * `{ ref }` resolves against the object's `definitions`. */
+    keys?: Resolver | ResolverRef;
+    /** Resolver for each entry's value. A `{ ref }` resolves against the
+     * object's `definitions`. */
+    values: Resolver | ResolverRef;
+    minEntries?: number;
+    maxEntries?: number;
+    /** Coarse value types so a free-text key/value answer coerces (usually
+     * `"string"` for the key), the way `Field.valueType` does. */
+    keyValueType?: string;
+    valueValueType?: string;
 }
 /** A homogeneous list: each element resolves through `items`. */
 interface ArrayResolver extends ResolverBase {
@@ -705,9 +762,9 @@ interface Formatter extends MethodAttachment {
     }) => FormattedItem;
 }
 /** 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`. */
+ * (the engine awaits the first page + `nextCursor`), 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). */
@@ -778,7 +835,8 @@ interface BoundDynamicResolver extends BoundResolverBase {
     } | null>;
 }
 /** Keyed members: static `properties` (bound) or a `getProperties`-built
- * (unbound) field map; `definitions` holds ref targets. */
+ * (unbound) field map; `definitions` holds ref targets. `additionalKeys`
+ * carries open-ended entries (a `z.record`). */
 interface BoundObjectResolver extends BoundResolverBase {
     type: "object";
     properties?: Record<string, BoundField>;
@@ -786,6 +844,17 @@ interface BoundObjectResolver extends BoundResolverBase {
     getProperties?: (bag: {
         input: Record<string, unknown>;
     }) => PromiseLike<Record<string, Field>>;
+    additionalKeys?: BoundAdditionalKeys;
+}
+/** The bound form of {@link AdditionalKeys}: `keys`/`values` are bound (or a
+ * `{ ref }` into the object's `definitions`). */
+interface BoundAdditionalKeys {
+    keys?: BoundResolver | ResolverRef;
+    values: BoundResolver | ResolverRef;
+    minEntries?: number;
+    maxEntries?: number;
+    keyValueType?: string;
+    valueValueType?: string;
 }
 /** A homogeneous list resolved through `items` (bound, or a ref into
  * `definitions`). */
@@ -1193,9 +1262,18 @@ interface MethodEntry {
      * `resolvePlugin` bind this; the surface and registry bind `value`. Absent
      * on legacy graph entries (they bind `value`). */
     internalValue?: (input: any) => any;
+    /** Produce the import-facing twin for a given call context: with a context,
+     * the twin mints a fresh child per invocation (callee inherits `callId`, sits
+     * one level deeper); without one it is the parent-less `internalValue`.
+     * `buildImports` binds this. Absent on legacy graph entries. */
+    bindInternal?: (ctx?: CallContext) => (...args: any[]) => any;
     chain: MiddlewareWrap[];
     /** Carried from the descriptor for the registry / CLI / MCP / docs. */
     inputSchema?: z.ZodType;
+    /** When true, the method owns its input validation and the boundary passes it
+     * through unparsed; carried so the controller skips its final `safeParse` too
+     * (it still uses `inputSchema` to plan/prompt parameters). */
+    skipInputValidation?: boolean;
     meta?: LeafMeta;
     /** Resolved output mode; the registry derives presentation from it. */
     output?: NormalizedOutput;
@@ -1440,7 +1518,7 @@ interface CategoryDefinition {
     /** Plural form of `title`. Auto-derived from the resolved title if omitted. */
     titlePlural?: string;
 }
-interface FunctionRegistryEntry<TSdk = any> {
+interface FunctionRegistryEntry {
     name: string;
     /**
      * Human-readable description of the function. Surfaced wherever the
@@ -1453,29 +1531,30 @@ interface FunctionRegistryEntry<TSdk = any> {
     itemType?: string;
     returnType?: string;
     inputSchema?: z.ZodSchema;
-    inputParameters?: Array<{
-        name: string;
-        schema: z.ZodSchema;
-    }>;
+    /**
+     * When true, the method owns its input validation and its boundary passes the
+     * input through unparsed. The resolution controller reads this to skip its
+     * final `safeParse` (it still uses `inputSchema` to plan/prompt parameters),
+     * so a method routed through the controller isn't re-validated against a
+     * schema it deliberately opts out of. Lifted off the materialized entry.
+     */
+    skipInputValidation?: boolean;
     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
+     * surface builder, like `resolvers` — 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.
+     * Per-parameter bound resolvers (imports already captured, called with
+     * `input` only, no sdk). Lifted off the materialized method entry by the
+     * surface builder.
      */
-    boundResolvers?: Record<string, BoundResolver>;
+    resolvers?: Record<string, BoundResolver>;
     packages?: string[];
     /**
      * True if the plugin is registered only in the experimental SDK
@@ -1509,8 +1588,8 @@ interface FunctionDeprecation {
     /** User-facing deprecation message for why/how to migrate */
     message: string;
 }
-interface RegistryResult<TSdk = any> {
-    functions: FunctionRegistryEntry<TSdk>[];
+interface RegistryResult {
+    functions: FunctionRegistryEntry[];
     categories: {
         key: string;
         title: string;
@@ -1615,7 +1694,7 @@ type Sdk<T = {
 }> = T & {
     getRegistry(options?: {
         package?: string;
-    }): RegistryResult<T>;
+    }): RegistryResult;
 };
 
 /**
@@ -2203,6 +2282,8 @@ declare function defineResolver<const TImports extends ImportsInput = readonly [
         input: TInput;
     }) => PromiseLike<Record<string, Field>>;
     definitions?: Record<string, Resolver>;
+    /** Open-ended entries whose keys aren't known up front (a `z.record`). */
+    additionalKeys?: AdditionalKeys;
 }): ObjectResolver;
 declare function defineResolver(config: {
     type: "array";
@@ -2683,7 +2764,7 @@ declare const dangerousContextPlugin: PropertyPlugin<"context", SdkContext>;
  */
 declare const getRegistryPlugin: MethodPlugin<"getRegistry", {
     package?: string | undefined;
-} | undefined, RegistryResult<any>, readonly []> & LeafSummary<"kitcore", "getRegistry", readonly [PropertyPlugin<"context", SdkContext>]>;
+} | undefined, RegistryResult, readonly []> & LeafSummary<"kitcore", "getRegistry", readonly [PropertyPlugin<"context", SdkContext>]>;
 
 /**
  * The external escape-hatch key for an SDK's context. A Symbol,
@@ -2844,13 +2925,13 @@ type ControllerQuestion = {
     path: ControllerPath;
     message: string;
     description?: string;
-    /** Which container kind this decision gates. `array` is the add-another
-     * loop; `object` is the entry gate on an optional object, fired BEFORE
-     * its fields are fetched (`add` descends into the fields, `done` skips
-     * the container). A host that renders `message` + `actions` generically
-     * needs nothing else; this is additive metadata for hosts that render
-     * containers specially. */
-    container: "array" | "object";
+    /** Which container type this decision is about. `array`/`record` are the
+     * add-another loops; `object` covers both the optional-object gate (fired
+     * BEFORE its fields are fetched: `add` descends, `done` skips it) and the
+     * optional-fields gate. A host that renders `message` + `actions`
+     * generically needs nothing else; this is additive metadata for hosts
+     * that render containers specially. */
+    container: "array" | "object" | "record";
     /** Object optionals gate only: the fields the `add` action would walk
      * (key + display label + coarse value type), so a smart host can render
      * them (or a form section) instead of a blind yes/no. Dumb hosts keep
@@ -2959,11 +3040,16 @@ interface ControllerState {
     /** The path of the parameter (or nested field) currently being asked. */
     current?: ControllerPath;
     /** Which container decision the outstanding `collection` question is, when
-     * `current` points at one: the array add/done loop, an optional object's
-     * entry gate, or an object's optionals gate. Recorded explicitly so `step`'s
-     * add/done handling never infers the decision from value presence or
-     * resolver shape. Absent when `current` is a plain leaf question. */
-    gate?: "array" | "entry" | "optionals";
+     * `current` points at one, named `<container>_<subject>`: `array_items` and
+     * `record_entries` are the add/done loops; `object_optional` is whether to
+     * provide an optional object at all (fired before its fields are fetched);
+     * `object_optional_properties` is whether to fill that object's optional
+     * fields. `record_key` marks the one bespoke record step (collecting an
+     * entry's key); the value that follows is an ordinary leaf question with no
+     * gate. Recorded explicitly so `step`'s handling never infers the decision
+     * from value presence or resolver shape. Absent when `current` is a plain
+     * leaf question. */
+    gate?: "array_items" | "record_entries" | "record_key" | "object_optional" | "object_optional_properties";
     /** Where pagination stands for the current dynamic leaf: coordinates only
      * (cursor trail, generation), never items or live iterators — the page's
      * items ride the ask's question. */
@@ -3190,7 +3276,7 @@ type FunctionSdk = {
  *                      and `context.core`
  * @param options.schema - optional Zod schema for input validation
  */
-declare function createFunction<TOptions, TResult, TSchemaOptions extends TOptions = TOptions>(coreFn: (options: TOptions) => Promise<TResult>, options: {
+declare function createFunction<TOptions, TResult, TSchemaOptions extends TOptions = TOptions>(coreFn: (options: TOptions, context?: CallContext) => Promise<TResult>, options: {
     sdk: FunctionSdk;
     schema?: z.ZodSchema<TSchemaOptions>;
     name?: string;
@@ -3216,7 +3302,7 @@ type ItemType<TResult> = TResult extends {
 declare function createPaginatedFunction<TUserOptions, TResponse, TItem = ItemType<TResponse>>(coreFn: (options: TUserOptions & {
     cursor?: string;
     pageSize?: number;
-}) => Promise<TResponse>, options: {
+}, context?: CallContext) => Promise<TResponse>, options: {
     sdk: FunctionSdk;
     schema?: z.ZodSchema<TUserOptions>;
     name?: string;
@@ -3510,7 +3596,7 @@ declare abstract class CoreSignal extends Error {
  * 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;
+declare function isCoreSignal(value: unknown): value is CoreSignal;
 /**
  * Thrown by `Controller.resolve` when the host cancels resolution (the answer
  * callback returned `{ type: "cancel" }`). The lower-level `start`/`step`
@@ -3523,5 +3609,12 @@ declare class CoreCancelledSignal extends CoreSignal {
     readonly code: "CANCELLED";
     constructor(message?: string);
 }
+/**
+ * Cross-package-safe check for {@link CoreCancelledSignal}. Keys on the
+ * signal brand + `code` rather than `instanceof`, so it recognizes a
+ * cancel signal raised by a different copy of kitcore (e.g. one bundled
+ * into a head vs. one installed standalone).
+ */
+declare function isCoreCancelledSignal(value: unknown): value is CoreCancelledSignal;
 
-export { type AdaptError, type AdaptErrorOptions, type AdaptPage, type AggregatePlugin, type ArrayResolver$1 as ArrayResolver, type AsyncContext, type BoundFormatter, type BoundResolver, CONTEXT, CORE_ERROR_SYMBOL, CORE_OPTIONS_ID, CORE_SIGNAL_SYMBOL, type CategoryDefinition, type ConstantResolver$1 as ConstantResolver, type Controller, type ControllerAction, type ControllerAffordance, type ControllerAnswerFn, type ControllerChoice, type ControllerError, type ControllerIssue, type ControllerListingPage, type ControllerListingPosition, type ControllerMethodDescription, type ControllerMethodSummary, type ControllerPagination, type ControllerParameterDescription, type ControllerPath, type ControllerQuestion, type ControllerResult, type ControllerSdk, type ControllerSelectPage, type ControllerState, type CoreApiError, CoreCancelledSignal, CoreDisposeError, CoreError, CoreErrorCode, type CoreErrorOptions, type CoreOptions, CoreSignal, type CreateSdkOptions, type DeprecatedPromptConfigChoice, type DeprecationLogger, type DeprecationWarning, type DisposeFn, type DynamicListResolver, type DynamicMember, type DynamicResolver$1 as DynamicResolver, type DynamicSearchResolver, type FieldsResolver, type FormattedItem, type Formatter, type FunctionDeprecation, type FunctionRegistryEntry, type HookPlugin, type LeafMeta, type LeafSummary, type LegacyMergePlugin, type LegacyPlugin, type ListItemsResult, type ListPromptConfig, type MethodAttachment, type MethodHooks, type MethodOverridePlugin, type MethodPlugin, type MethodScope, type Resolver as ModelResolver, type OnMethodEnd, type OnMethodEndContext, type OnMethodStart, type OnMethodStartContext, type OutputFormatter, type PaginatedSdkFunction, type PaginatedSdkResult, type Plugin, type PluginMeta, type PluginProvides, type PluginStack, type PluginSummary, type PluginSurface, type PositionalMetadata, type PromptConfig, type PromptConfigChoice, type PropertyPlugin, type RegistryResult, type RequiredSdkOf, type Resolver$1 as Resolver, type ResolverConfig, type ResolverFieldItem, type ResolverMetadata, type ResolverPromptConfig, type ResolverType, type Sdk, type SdkContext, type SdkPage, type StaticResolver$1 as StaticResolver, type ValidResolvers, addPlugin, composePlugins, concatLists, concatPaginated, coreOptionsPluginRef, createAsyncContext, createController, createCoreError, createCorePlugin, createDeprecationLogger, createFunction, createPaginatedFunction, createPaginatedPluginMethod, createPluginMethod, createPluginStack, createPrefixedCursor, createSdk, createValidator, dangerousContextPlugin, declareMethod, declareOptionalProperty, declarePlugin, declareProperty, decodeIncomingCursor, defaultLogDeprecation, defineFormatter, defineHook, defineLegacyMerge, defineMethod, defineMethodOverride, definePlugin, defineProperty, defineResolver, disposeSdk, fromFunctionPlugin, getContext, getCoreErrorCause, getCoreErrorCode, getCurrentDepth, getCurrentScope, getFieldDescriptions, getOutputSchema, getRegistryPlugin, getSchemaDescription, isCoreError, isCoreSignal, isNestedMethodCall, isPositional, isTelemetryNested, omitExports, openEnum, paginate, paginateBuffered, paginateMaxItems, resolvePlugin, runInMethodScope, runWithTelemetryContext, selectExports, splitPrefixedCursor, toIterable, toSnakeCase, toTitleCase, validateOptions, withOutputSchema, withPositional, withResolver };
+export { type AdaptError, type AdaptErrorOptions, type AdaptPage, type AggregatePlugin, type ArrayResolver$1 as ArrayResolver, type AsyncContext, type BoundFormatter, type BoundResolver, CONTEXT, CORE_ERROR_SYMBOL, CORE_OPTIONS_ID, CORE_SIGNAL_SYMBOL, type CategoryDefinition, type ConstantResolver$1 as ConstantResolver, type Controller, type ControllerAction, type ControllerAffordance, type ControllerAnswerFn, type ControllerChoice, type ControllerError, type ControllerIssue, type ControllerListingPage, type ControllerListingPosition, type ControllerMethodDescription, type ControllerMethodSummary, type ControllerPagination, type ControllerParameterDescription, type ControllerPath, type ControllerQuestion, type ControllerResult, type ControllerSdk, type ControllerSelectPage, type ControllerState, type CoreApiError, CoreCancelledSignal, CoreDisposeError, CoreError, CoreErrorCode, type CoreErrorOptions, type CoreOptions, CoreSignal, type CreateSdkOptions, type DeprecatedPromptConfigChoice, type DeprecationLogger, type DeprecationWarning, type DisposeFn, type DynamicListResolver, type DynamicMember, type DynamicResolver$1 as DynamicResolver, type DynamicSearchResolver, type FieldsResolver, type FormattedItem, type Formatter, type FunctionDeprecation, type FunctionRegistryEntry, type HookPlugin, type LeafMeta, type LeafSummary, type LegacyMergePlugin, type LegacyPlugin, type ListItemsResult, type ListPromptConfig, type MethodAttachment, type MethodHooks, type MethodOverridePlugin, type MethodPlugin, type MethodScope, type Resolver as ModelResolver, type OnMethodEnd, type OnMethodEndContext, type OnMethodStart, type OnMethodStartContext, type OutputFormatter, type PaginatedSdkFunction, type PaginatedSdkResult, type Plugin, type PluginMeta, type PluginProvides, type PluginStack, type PluginSummary, type PluginSurface, type PositionalMetadata, type PromptConfig, type PromptConfigChoice, type PropertyPlugin, type RegistryResult, type RequiredSdkOf, type Resolver$1 as Resolver, type ResolverConfig, type ResolverFieldItem, type ResolverMetadata, type ResolverPromptConfig, type ResolverType, type Sdk, type SdkContext, type SdkPage, type StaticResolver$1 as StaticResolver, type ValidResolvers, addPlugin, canonicalInputSchema, composePlugins, concatLists, concatPaginated, coreOptionsPluginRef, createAsyncContext, createController, createCoreError, createCorePlugin, createDeprecationLogger, createFunction, createPaginatedFunction, createPaginatedPluginMethod, createPluginMethod, createPluginStack, createPrefixedCursor, createSdk, createValidator, dangerousContextPlugin, declareMethod, declareOptionalProperty, declarePlugin, declareProperty, decodeIncomingCursor, defaultLogDeprecation, defineFormatter, defineHook, defineLegacyMerge, defineMethod, defineMethodOverride, definePlugin, defineProperty, defineResolver, disposeSdk, fromFunctionPlugin, getContext, getCoreErrorCause, getCoreErrorCode, getCurrentDepth, getCurrentScope, getFieldDescriptions, getOutputSchema, getRegistryPlugin, getSchemaDescription, isCoreCancelledSignal, isCoreError, isCoreSignal, isNestedMethodCall, isPositional, isTelemetryNested, omitExports, openEnum, paginate, paginateBuffered, paginateMaxItems, resolvePlugin, runInMethodScope, runWithTelemetryContext, selectExports, splitPrefixedCursor, toIterable, toSnakeCase, toTitleCase, validateOptions, withOutputSchema, withPositional, withResolver };