@zapier/kitcore 0.4.0 → 0.5.0

package/dist/index.d.mts

@@ -387,6 +387,33 @@ interface LeafMetaFields {
     aliases?: Record<string, string>;
     supportsJsonOutput?: boolean;
 }
+/** One segment of a {@link DynamicMember} path: a literal binding/segment name,
+ * or a `{ param }` placeholder for an open-ended key (rendered `{param}`). */
+type DynamicMemberSegment = string | {
+    param: string;
+};
+/**
+ * A templated registry member: a dynamic sub-surface with no static binding
+ * (e.g. `apps.{appKey}.{actionType}.{actionKey}`), backed at runtime by a proxy.
+ * It is a bodyless declaration — the same descriptive fields an author sets on a
+ * leaf, keyed by a `path` instead of a `name`. The framework derives the
+ * registry name by joining the path (params rendered `{param}`) and folds these
+ * fields into a `PluginMeta` for the registry / CLI / MCP / docs projection.
+ * `path[0]` must be a literal that resolves to a real surfaced binding (the
+ * owning member).
+ */
+type DynamicMember = {
+    path: readonly DynamicMemberSegment[];
+    /** Projection-only input schema (no runtime; the proxy validates its own). */
+    inputSchema?: z.ZodType;
+} & LeafMetaFields;
+/** A {@link DynamicMember} normalized at define time: the derived registry name,
+ * the literal root segment (validated against the surface), and the folded meta. */
+interface NormalizedDynamicMember {
+    name: string;
+    rootBinding: string;
+    meta: PluginMeta;
+}
 type AnyMethodPlugin = MethodPlugin<string, any, any, readonly string[]>;
 type AnyPropertyPlugin = PropertyPlugin<string, any>;
 /** A leaf plugin: a method (callable) or a property (value). */
@@ -403,6 +430,10 @@ type ImportsInput = readonly AnyPlugin[];
 interface ImportBinding {
     binding: string;
     id: string;
+    /** True when the edge came from a `declareOptionalProperty` stand-in: if no real
+     * plugin satisfies the id, the binding resolves to `undefined` instead of
+     * failing the build as a missing dependency. */
+    optional?: boolean;
 }
 /**
  * Collapse a union to an intersection. Turns the per-dependency
@@ -437,15 +468,9 @@ type SurfaceCall<TInput, TOutput, TPositional extends readonly string[]> = TPosi
 /**
  * The bindings one array-form dependency contributes to `imports`: a leaf under
  * its own name (method callable or property value), an aggregate under each of
- * its export names.
+ * its export names — exactly the dependency's {@link PluginSurface}.
  */
-type BindingsOf<TDep> = TDep extends MethodPlugin<infer TName, infer TInput, infer TOutput, infer TPositional> ? {
-    [P in TName]: SurfaceCall<TInput, TOutput, TPositional>;
-} : TDep extends PropertyPlugin<infer TName, infer TValue> ? {
-    [P in TName]: TValue;
-} : TDep extends AggregatePlugin<string, infer TExports> ? {
-    [K in keyof TExports]: ExportSurface<TExports[K]>;
-} : never;
+type BindingsOf<TDep extends AnyPlugin> = PluginSurface<TDep>;
 /**
  * The `imports` a body receives. Each element contributes its bindings
  * (`BindingsOf`); empty imports yield an empty object.
@@ -531,8 +556,10 @@ interface DynamicResolver extends ResolverBase {
      * 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: {
+     * 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>;
         /** The value `getContext` returned, if any. */
@@ -656,47 +683,44 @@ interface BoundField {
     required?: boolean;
     valueType?: string;
 }
-/**
- * The runtime resolver `defineResolver` binds to: its imports are already
- * 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. `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;
+/** Fields shared by every bound resolver kind. */
+interface BoundResolverBase {
     /** Sibling parameters that must resolve before this resolver runs (it reads
      * their values from `input`). The param-dataflow prerequisite, distinct from
      * `imports`' SDK-capability graph. */
     requireParameters?: readonly string[];
+}
+/** Free-text input, no candidate list. */
+interface BoundStaticResolver extends BoundResolverBase {
+    type: "static";
+    inputType?: "text" | "password" | "email" | "search";
+    placeholder?: string;
+}
+/** A fixed value the author pinned; auto-settles, never asks. */
+interface BoundConstantResolver extends BoundResolverBase {
+    type: "constant";
+    value: unknown;
+}
+/** Display-only text; resolves no value, never asks. */
+interface BoundInfoResolver extends BoundResolverBase {
+    type: "info";
+    text: string;
+}
+/** List candidate items (`listItems`) and prompt to pick one; carries the
+ * auto-resolution hooks (`tryResolveWithoutPrompt`, `tryResolveFromSearch`). */
+interface BoundDynamicResolver extends BoundResolverBase {
+    type: "dynamic";
     inputType?: "text" | "password" | "email" | "search";
     placeholder?: string;
-    value?: unknown;
-    text?: string;
-    properties?: Record<string, BoundField>;
-    definitions?: Record<string, BoundResolver>;
-    items?: BoundResolver | ResolverRef;
-    minItems?: number;
-    maxItems?: number;
-    /** 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: {
+    listItems: (bag: {
         input: Record<string, unknown>;
         context?: unknown;
         search?: string;
         cursor?: string;
     }) => ListItemsResult<unknown>;
-    getProperties?: (bag: {
-        input: Record<string, unknown>;
-    }) => PromiseLike<Record<string, Field>>;
     prompt?: (bag: {
         items: unknown[];
         input: Record<string, unknown>;
@@ -714,6 +738,37 @@ interface BoundResolver {
         resolvedValue: unknown;
     } | null>;
 }
+/** Keyed members: static `properties` (bound) or a `getProperties`-built
+ * (unbound) field map; `definitions` holds ref targets. */
+interface BoundObjectResolver extends BoundResolverBase {
+    type: "object";
+    properties?: Record<string, BoundField>;
+    definitions?: Record<string, BoundResolver>;
+    getProperties?: (bag: {
+        input: Record<string, unknown>;
+    }) => PromiseLike<Record<string, Field>>;
+}
+/** A homogeneous list resolved through `items` (bound, or a ref into
+ * `definitions`). */
+interface BoundArrayResolver extends BoundResolverBase {
+    type: "array";
+    items: BoundResolver | ResolverRef;
+    minItems?: number;
+    maxItems?: number;
+    /** The element's coarse value type, used to coerce a free-text item answer
+     * before validation (see {@link ArrayResolver.itemValueType}). */
+    itemValueType?: string;
+    definitions?: Record<string, BoundResolver>;
+}
+/**
+ * The runtime resolver `defineResolver` binds to: its imports are already
+ * captured, so the CLI calls these with input (and `search`) only, no sdk.
+ * `prompt` stays pure (no SDK reach). A discriminated union mirroring
+ * {@link Resolver}, so kind-specific field access compiles only behind a
+ * `type` narrow (the binder's switch is the one exhaustiveness-checked
+ * dispatch; the engine's if-chains get the field-access check).
+ */
+type BoundResolver = BoundStaticResolver | BoundConstantResolver | BoundInfoResolver | BoundDynamicResolver | BoundObjectResolver | BoundArrayResolver;
 /**
  * The runtime formatter `defineFormatter` binds to: `getContext` runs once per
  * rendered batch (imports captured, no sdk) to build shared context; `format`
@@ -747,6 +802,9 @@ interface MethodPlugin<TName extends string = string, TInput = unknown, TOutput
     /** True for a `declareMethod` stand-in: a typed reference with no real
      * implementation. A real plugin under the same id satisfies it. */
     standIn?: boolean;
+    /** True for a `declareOptionalProperty` stand-in over a method id: dependents bind
+     * `undefined` if no real plugin satisfies it. */
+    optional?: boolean;
     imports: readonly AnyPlugin[];
     /** Binding-name to plugin-id edges, normalized from `imports`;
      * what the `imports` bag is built from. */
@@ -757,8 +815,17 @@ interface MethodPlugin<TName extends string = string, TInput = unknown, TOutput
     setup?: (bag: {
         imports: Record<string, unknown>;
     }) => unknown;
+    /** `setup`'s dual: releases what setup acquired. Run by `disposeSdk` in
+     * reverse dependency order. */
+    dispose?: DisposeFn;
     /** Validates `input` before `run` and drives the authoring `input` type. */
     inputSchema?: z.ZodType;
+    /** When true, skip the runtime validation/parse of `input`: `run` receives the
+     * raw input untouched — no coercion, stripping, or cloning — even if
+     * `inputSchema` is set (the schema stays for registry / CLI / MCP projection).
+     * For raw methods that own their own validation and must not have their input
+     * transformed, e.g. `fetch` passing a `RequestInit` bag through unchanged. */
+    skipInputValidation?: boolean;
     /** Descriptive metadata for the registry / CLI / MCP / docs (carry-only at
      * runtime). */
     meta?: LeafMeta;
@@ -846,6 +913,10 @@ interface PropertyPlugin<TName extends string = string, TValue = unknown> {
     /** True for a `declareProperty` stand-in: a typed reference with no value. A
      * real property under the same id satisfies it. */
     standIn?: boolean;
+    /** True for a `declareOptionalProperty` stand-in: an optional reference. If no real
+     * property satisfies it, dependents bind `undefined` rather than the build
+     * failing on a missing dependency. */
+    optional?: boolean;
     imports: readonly AnyPlugin[];
     /** Binding-name to plugin-id edges, normalized from `imports`;
      * what the `imports` bag is built from. */
@@ -856,6 +927,9 @@ interface PropertyPlugin<TName extends string = string, TValue = unknown> {
     setup?: (bag: {
         imports: Record<string, unknown>;
     }) => unknown;
+    /** `setup`'s dual: releases what setup acquired. Run by `disposeSdk` in
+     * reverse dependency order. */
+    dispose?: DisposeFn;
     value?: TValue;
     /** A live getter: computes the value from imports and `setup` state on each
      * read (not once). The stored shape is loose; the precise typing lives on the
@@ -866,6 +940,9 @@ interface PropertyPlugin<TName extends string = string, TValue = unknown> {
     }) => TValue;
     /** Descriptive metadata for the registry / CLI / MCP / docs (carry-only). */
     meta?: LeafMeta;
+    /** Templated registry members for this property's dynamic sub-surface (e.g. a
+     * proxy). Carry-only: normalized at define time, folded into the registry. */
+    dynamicMembers?: readonly NormalizedDynamicMember[];
     /** A built-in whose value is the live `SdkContext`, injected at
      * materialization. Reserved for kitcore's own plugins;
      * authors use `value` / `get`. */
@@ -882,20 +959,23 @@ type MiddlewareFn = (bag: {
     imports: any;
     next: (input: any) => any;
     input: any;
+    state: unknown;
 }) => any;
 /**
- * The authoring type for an aggregate's `middleware`: a map
- * whose keys are the method bindings among `imports` (you can only wrap a
- * method you import) and whose values are contract-preserving wraps. `next` and
- * `input` take the target's input and the wrap must return the target's output,
- * so a wrap that changes the public signature, or that targets a non-imported /
- * non-method binding, does not compile.
+ * The authoring type for a hook's `wrap`: a map whose keys are the method
+ * bindings among the hook's `imports` (you can only wrap a method you import)
+ * and whose values are contract-preserving wraps. `next` and `input` take the
+ * target's input and the wrap must return the target's output, so a wrap that
+ * changes the public signature, or that targets a non-imported / non-method
+ * binding, does not compile. `state` is the hook's `setup` result (one bag
+ * shape across run/observe/wrap; `next` is the only variant).
  */
-type MiddlewareMap<TImports> = {
+type MiddlewareMap<TImports, TState = unknown> = {
     [K in keyof TImports as TImports[K] extends (input: any) => any ? K : never]?: TImports[K] extends (input: infer TInput) => infer TOutput ? (bag: {
         imports: TImports;
         next: (input: TInput) => TOutput;
         input: TInput;
+        state: TState;
     }) => TOutput : never;
 };
 /** The export record one array element contributes: a leaf under its own name,
@@ -923,11 +1003,10 @@ interface AggregatePlugin<TName extends string = string, TExports extends Record
     standIn?: boolean;
     imports: readonly AnyPlugin[];
     /** Binding-name to plugin-id edges, normalized from `imports`; what a
-     * middleware wrap's `imports` is built from, and how a middleware target
+     * wrap's `imports` is built from, and how a wrap target
      * binding resolves to a method id. */
     importBindings: readonly ImportBinding[];
     exports: TExports;
-    middleware?: Record<string, MiddlewareFn>;
 }
 type AnyAggregatePlugin = AggregatePlugin<string, Record<string, any>>;
 /**
@@ -952,7 +1031,72 @@ interface LegacyPlugin<TSurface = Record<string, unknown>> {
     readonly __surface?: TSurface;
 }
 type AnyLegacyPlugin = LegacyPlugin<any>;
-type AnyPlugin = AnyLeafPlugin | AnyAggregatePlugin | AnyLegacyPlugin;
+/**
+ * A patch over an already-defined method's descriptive fields. It carries no
+ * `run`: it names an existing method by id (`target`) and, after that method
+ * materializes, merges its `meta` (the same public {@link LeafMetaFields} an
+ * author sets on `defineMethod`) onto the method's entry, so the surface
+ * registry / CLI / MCP / docs project the patched values. For surface-specific
+ * tweaks a base method should not carry (e.g. a CLI that deprecates `fetch`
+ * while the SDK does not, or a host that hides a method via `packages`).
+ *
+ * Distinct from a *replacement* (`addPlugin(..., { override: true })`), which
+ * swaps the whole implementation and forces re-declaring `run`. An override
+ * inherits the target's implementation untouched and only patches meta.
+ */
+interface MethodOverridePlugin {
+    pluginType: "method-override";
+    name: string;
+    id: string;
+    /** The id of the method whose meta is patched (its bare name if the method is
+     * namespace-less). */
+    target: string;
+    imports: readonly AnyPlugin[];
+    importBindings: readonly ImportBinding[];
+    meta?: LeafMeta;
+}
+/**
+ * A method-lifecycle hook leaf (`defineHook`). `observe` contributes
+ * fire-and-forget observers (`onMethodStart` / `onMethodEnd`) that the method
+ * boundary fires around every method; they run defensively (an observer error
+ * never breaks the observed call). `setup` runs once and owns the hook's state
+ * (e.g. a telemetry queue), delivered to the observers.
+ * Each observer bag mirrors a method's: `{ imports, input, state }` — `input` is
+ * the lifecycle context, and there is no `next` (observers don't participate in
+ * the call). The module-model replacement for a legacy plugin that contributed
+ * `context.hooks`.
+ */
+interface HookPlugin<TName extends string = string> {
+    pluginType: "hook";
+    name: TName;
+    namespace?: string;
+    id: string;
+    imports: readonly AnyPlugin[];
+    importBindings: readonly ImportBinding[];
+    setup?: (bag: {
+        imports: any;
+    }) => unknown;
+    /** `setup`'s dual: releases what setup acquired. Run by `disposeSdk` in
+     * reverse dependency order. */
+    dispose?: DisposeFn;
+    /** Contract-preserving wraps around imported methods (the middleware onion,
+     * folded dependents-outermost in topological order). Keyed by the target's
+     * binding among this hook's `imports`. */
+    wrap?: Record<string, MiddlewareFn>;
+    observe?: {
+        onMethodStart?: (bag: {
+            imports: any;
+            input: OnMethodStartContext;
+            state: unknown;
+        }) => void;
+        onMethodEnd?: (bag: {
+            imports: any;
+            input: OnMethodEndContext;
+            state: unknown;
+        }) => void;
+    };
+}
+type AnyPlugin = AnyLeafPlugin | AnyAggregatePlugin | AnyLegacyPlugin | HookPlugin | MethodOverridePlugin;
 /**
  * A transitional root that merges a legacy function-plugin stack with the
  * module-model plugins migrated off it (see Migration order). At `createSdk` it
@@ -976,11 +1120,11 @@ interface LegacyMergePlugin<TProvides extends PluginProvides = PluginProvides, T
     /** The module-model plugins migrated off the legacy stack. */
     plugin: TPlugin;
 }
-/** One middleware layer on a method's chain: the wrap and its owning aggregate
+/** One middleware layer on a method's chain: the wrap and its owning hook
  * (whose `imports` the wrap receives, built live at call time). */
 interface MiddlewareWrap {
     run: MiddlewareFn;
-    owner: AnyAggregatePlugin;
+    owner: HookPlugin;
 }
 /** A materialized method: a stable callable `value` that folds `chain` around
  * the core at call time. The chain is ordered dependents-outermost; it is
@@ -989,6 +1133,12 @@ interface MethodEntry {
     pluginType: "method";
     name: string;
     value: (input: any) => any;
+    /** The import-facing twin of `value`: the same boundary, called with the
+     * internal-call sentinel so surface-only concerns (the deprecation signal)
+     * don't fire when a sibling plugin delegates. `buildImports` and
+     * `resolvePlugin` bind this; the surface and registry bind `value`. Absent
+     * on legacy graph entries (they bind `value`). */
+    internalValue?: (input: any) => any;
     chain: MiddlewareWrap[];
     /** Carried from the descriptor for the registry / CLI / MCP / docs. */
     inputSchema?: z.ZodType;
@@ -1014,6 +1164,9 @@ interface PropertyEntry {
     getValue?: () => any;
     /** Carried from the descriptor for the registry / CLI / MCP / docs. */
     meta?: LeafMeta;
+    /** Carried from the descriptor: templated registry members for this
+     * property's dynamic sub-surface (folded into the registry by getRegistry). */
+    dynamicMembers?: readonly NormalizedDynamicMember[];
 }
 /** A materialized aggregate: its resolved export bindings to child values
  * (a method's callable or a property's value). */
@@ -1045,11 +1198,51 @@ interface SdkContext {
      * binding (with meta from the leaf) rather than dumping `plugins` by id. An
      * aliased re-export (`{ hi: greet }`) appears here as `hi -> "greet"`. */
     surface: Record<string, string>;
+    /** Teardown callbacks recorded at materialization, in build order
+     * (dependencies first); `disposeSdk` walks them in reverse. */
+    disposers?: SdkDisposer[];
+    /** The first `disposeSdk` call's settled result; later calls return it
+     * (idempotent, first input wins). */
+    disposed?: Promise<void>;
     [key: string]: any;
 }
+/** One leaf's recorded teardown: built at materialization (closing over the
+ * leaf's imports + setup state), run by `disposeSdk`. */
+interface SdkDisposer {
+    id: string;
+    dispose: (input?: unknown) => void | Promise<void>;
+}
+/** The teardown callback a leaf declares beside `setup`, releasing what setup
+ * acquired. `input` is whatever the caller passed to `disposeSdk` (untyped:
+ * the framework does not bless a shape; each dispose narrows what it reads). */
+type DisposeFn = (bag: {
+    imports: any;
+    state: unknown;
+    input?: unknown;
+}) => void | Promise<void>;
 /** The surfaced shape of one re-exported child: a method's callable or a
  * property's value. */
 type ExportSurface<TChild extends AnyLeafPlugin> = TChild extends MethodPlugin<any, infer TInput, infer TOutput, infer TPositional> ? SurfaceCall<TInput, TOutput, TPositional> : TChild extends PropertyPlugin<any, infer TValue> ? TValue : never;
+/**
+ * The SDK surface a plugin contributes, derived from its descriptor: a
+ * method's callable or a property's value under its name, or an aggregate's
+ * export bindings. No `SdkInternals` — this is the plugin's own slice, not a
+ * whole SDK. The inference replacement for a hand-written
+ * `<Name>PluginProvides` interface:
+ *
+ *   export type ListAppsPluginProvides = PluginSurface<typeof listAppsPlugin>;
+ *
+ * "Surface", not "Provides": `PluginProvides` is the legacy function-plugin
+ * bag and `ProvidesOf` is the completeness ledger's phantom ids — both
+ * different concepts.
+ */
+type PluginSurface<P extends AnyPlugin> = P extends MethodPlugin<infer TName, infer TInput, infer TOutput, infer TPositional> ? {
+    [K in TName]: SurfaceCall<TInput, TOutput, TPositional>;
+} : P extends PropertyPlugin<infer TName, infer TValue> ? {
+    [K in TName]: TValue;
+} : P extends AggregatePlugin<string, infer TExports> ? {
+    [K in keyof TExports]: ExportSurface<TExports[K]>;
+} : never;
 /**
  * The framework-owned access an SDK carries beyond its string surface: the
  * legacy `context` string key (back-compat, narrows away later). The off-surface
@@ -1083,13 +1276,9 @@ type AggregateSdk<TExports extends Record<string, AnyLeafPlugin>> = {
  * under its name, a property's value, an aggregate's export bindings, or a
  * legacy function plugin's root provides (minus `context`).
  */
-type AddedSurface<P> = P extends MethodPlugin<infer TName, infer TInput, infer TOutput, infer TPositional> ? {
-    [K in TName]: SurfaceCall<TInput, TOutput, TPositional>;
-} : P extends PropertyPlugin<infer TName, infer TValue> ? {
-    [K in TName]: TValue;
-} : P extends AggregatePlugin<string, infer TExports> ? {
-    [K in keyof TExports]: ExportSurface<TExports[K]>;
-} : P extends (sdk: any) => infer TProvides ? TProvides extends PluginProvides ? Omit<TProvides, "context"> : Record<never, never> : Record<never, never>;
+type AddedSurface<P> = [P] extends [AnyPlugin] ? [
+    PluginSurface<P>
+] extends [never] ? Record<never, never> : PluginSurface<P> : P extends (sdk: any) => infer TProvides ? TProvides extends PluginProvides ? Omit<TProvides, "context"> : Record<never, never> : Record<never, never>;
 /** `T` when it is a specific string literal, else `never`. Used on a stand-in's
  * `name` so the id is always captured as a literal: a widened `string` (or the
  * stale `declareMethod<TInput, TOutput>(...)` call shape, where the contract
@@ -1145,6 +1334,20 @@ type LastSegment<TId extends string> = TId extends `${string}/${infer Rest}` ? L
 type LeafSummary<TNamespace extends string, TName extends string, TImports extends readonly unknown[]> = PluginSummary<LeafRequires<IdOf<TNamespace, TName>, TImports>, LeafProvides<IdOf<TNamespace, TName>, TImports>>;
 /** The `PluginSummary` an aggregate carries, keyed on its full id. */
 type AggregateSummary<TNamespace extends string, TName extends string, TImports extends readonly unknown[], TExports extends readonly unknown[]> = PluginSummary<AggregateRequires<IdOf<TNamespace, TName>, TImports, TExports>, AggregateProvides<IdOf<TNamespace, TName>, TImports, TExports>>;
+/**
+ * The runtime-input channel for `createSdk`. `configuration` maps plugin ids to
+ * immutable values; each entry materializes as a static value property under
+ * that id, satisfying a `declareProperty` / `declareOptionalProperty` stand-in exactly
+ * as a registered provider would (DI value injection). Strict at build time:
+ * an id must resolve to a property stand-in reachable from the root, so
+ * unknown ids, non-property targets, and collisions with a registered real
+ * provider all throw. kitcore keeps the map untyped; a head's factory is the
+ * typed wrapper (`createMySdk(options)` passes
+ * `{ configuration: { "my/config": options } }`).
+ */
+interface CreateSdkOptions {
+    configuration?: Record<string, unknown>;
+}
 /** Surfaced by `createSdk` when reachable declarations have no provider. */
 interface MissingDependencies<TIds extends string> {
     readonly __kitcoreError: "Missing concrete provider(s) for required declaration id(s)";
@@ -1378,12 +1581,18 @@ type Sdk<T = {
  * Two method helpers (rather than one with a `paginated: true` discriminant)
  * because the handler signature changes shape across pagination, and
  * discriminated unions on optional booleans produce noisy TS errors.
+ *
+ * @deprecated The module model replaces this exit; it logs a runtime
+ * deprecation and will be removed in a release after this warning ships.
  */
 
 /**
  * Method-level meta fields. Mirrors `PluginMeta` minus `inputSchema`, which is
  * passed at the top level alongside the handler and merged into the meta by
  * the helpers themselves.
+ *
+ * @deprecated The module model replaces this exit; it logs a runtime
+ * deprecation and will be removed in a release after this warning ships.
  */
 type MethodMeta<TSdk> = Omit<PluginMeta<TSdk>, "inputSchema">;
 /**
@@ -1404,6 +1613,9 @@ type MethodMeta<TSdk> = Omit<PluginMeta<TSdk>, "inputSchema">;
  * Not mixed into the handler's `sdk`: handlers run against the SDK that
  * existed when the plugin was added to the stack (closure-captured), so
  * self-method access there would be a lie at runtime.
+ *
+ * @deprecated The module model replaces this exit; it logs a runtime
+ * deprecation and will be removed in a release after this warning ships.
  */
 type SelfMethod<TName extends string> = {
     [K in TName]: (options?: any) => any;
@@ -1416,6 +1628,9 @@ interface PluginMethodConfig<TSdk, TInput, TResult, TName extends string, TResol
      * `z.union([CanonicalSchema, DeprecatedSchema])` — the registry
      * unwraps unions and exposes only the first variant (canonical) to
      * documentation and downstream consumer surfaces.
+     *
+     * @deprecated The module model replaces this exit; it logs a runtime
+     * deprecation and will be removed in a release after this warning ships.
      */
     inputSchema?: z.ZodSchema<TInput>;
     handler: (args: {
@@ -1428,6 +1643,9 @@ interface PluginMethodConfig<TSdk, TInput, TResult, TName extends string, TResol
      * {@link SelfMethod}) using {@link ValidResolvers}; mismatches surface
      * at the offending key. `NoInfer` pins `TSdk` to the `sdk` argument so
      * resolver entries don't widen the inferred `TSdk`.
+     *
+     * @deprecated The module model replaces this exit; it logs a runtime
+     * deprecation and will be removed in a release after this warning ships.
      */
     resolvers?: ValidResolvers<NoInfer<TSdk & SelfMethod<TName>>, TResolvers> & TResolvers;
 }
@@ -1453,6 +1671,9 @@ type PluginMethodReturn<TName extends string, TInput, TResult> = {
  *         handler: async ({ sdk }) => { ... },
  *       }),
  *   );
+ *
+ * @deprecated The module model replaces this exit; it logs a runtime
+ * deprecation and will be removed in a release after this warning ships.
  */
 declare function createPluginMethod<const TName extends string, TSdk extends {
     context: unknown;
@@ -1552,6 +1773,9 @@ type PaginatedPluginMethodReturn<TName extends string, TInput, TItem> = {
  *     adaptPage: (res) => ({ data: res.items, nextCursor: res.next }),
  *     handler: ({ sdk, options }) => sdk.context.api.get("/things", { ... }),
  *   });
+ *
+ * @deprecated The module model replaces this exit; it logs a runtime
+ * deprecation and will be removed in a release after this warning ships.
  */
 declare function createPaginatedPluginMethod<const TName extends string, TSdk extends {
     context: unknown;
@@ -1685,6 +1909,10 @@ interface PluginStack<TRequires, TProvides extends PluginProvides> {
  * different consumers. Until the stack materializes, no plugin functions
  * run.
  */
+/**
+ * @deprecated The module model replaces this exit; it logs a runtime
+ * deprecation and will be removed in a release after this warning ships.
+ */
 declare function createPluginStack<TRequires = object>(): PluginStack<TRequires, {
     context: {
         meta: Record<string, PluginMeta>;
@@ -1710,6 +1938,10 @@ declare function defineMethod<const TName extends string, TInput, TOutput, const
     /** Validates `input` and drives its type: when given, `input` is the schema's
      * output and no `run` annotation is needed. */
     inputSchema?: z.ZodType<TInput>;
+    /** Skip the runtime parse of `input`; `run` gets it untouched (the schema
+     * stays for projection). For raw methods that validate their own input, like
+     * `fetch`. See {@link MethodPlugin.skipInputValidation}. */
+    skipInputValidation?: boolean;
     resolvers?: Record<string, Resolver>;
     formatter?: Formatter;
     output?: "raw" | {
@@ -1719,6 +1951,11 @@ declare function defineMethod<const TName extends string, TInput, TOutput, const
     setup?: (bag: {
         imports: ImportsOf<TImports>;
     }) => TState;
+    dispose?: (bag: {
+        imports: ImportsOf<TImports>;
+        state: TState;
+        input?: unknown;
+    }) => void | Promise<void>;
     run: (bag: MethodRunBag<ImportsOf<TImports>, TInput, TState>) => TOutput;
 } & LeafMetaFields): MethodPlugin<TName, TInput, TOutput, TPositional> & LeafSummary<TNamespace, TName, TImports>;
 declare function defineMethod<const TName extends string, TInput, TData, const TImports extends ImportsInput = readonly [], const TNamespace extends string = "", TState = undefined>(config: {
@@ -1734,6 +1971,11 @@ declare function defineMethod<const TName extends string, TInput, TData, const T
     setup?: (bag: {
         imports: ImportsOf<TImports>;
     }) => TState;
+    dispose?: (bag: {
+        imports: ImportsOf<TImports>;
+        state: TState;
+        input?: unknown;
+    }) => void | Promise<void>;
     run: (bag: MethodRunBag<ImportsOf<TImports>, TInput, TState>) => TData;
 } & LeafMetaFields): MethodPlugin<TName, TInput, Promise<{
     data: Awaited<TData>;
@@ -1753,6 +1995,11 @@ declare function defineMethod<const TName extends string, TInput, TResponse exte
     setup?: (bag: {
         imports: ImportsOf<TImports>;
     }) => TState;
+    dispose?: (bag: {
+        imports: ImportsOf<TImports>;
+        state: TState;
+        input?: unknown;
+    }) => void | Promise<void>;
     run: (bag: MethodRunBag<ImportsOf<TImports>, TInput & PageFetchInput, TState>) => TResponse | Promise<TResponse>;
 } & LeafMetaFields): MethodPlugin<TName, TInput & PaginatedCallInput, PaginatedSdkResult<TItem>> & LeafSummary<TNamespace, TName, TImports>;
 declare function defineMethod<const TName extends string, TInput, TResponse, TItem, const TImports extends ImportsInput = readonly [], const TNamespace extends string = "", TState = undefined>(config: {
@@ -1770,8 +2017,31 @@ declare function defineMethod<const TName extends string, TInput, TResponse, TIt
     setup?: (bag: {
         imports: ImportsOf<TImports>;
     }) => TState;
+    dispose?: (bag: {
+        imports: ImportsOf<TImports>;
+        state: TState;
+        input?: unknown;
+    }) => void | Promise<void>;
     run: (bag: MethodRunBag<ImportsOf<TImports>, TInput & PageFetchInput, TState>) => TResponse | Promise<TResponse>;
 } & LeafMetaFields): MethodPlugin<TName, TInput & PaginatedCallInput, PaginatedSdkResult<TItem>> & LeafSummary<TNamespace, TName, TImports>;
+/**
+ * Define a method override: a meta-only patch over an already-defined method.
+ * Give it the `target` method's id (its bare name if namespace-less) and any of
+ * the public {@link LeafMetaFields} (`deprecation`, `packages`, `description`,
+ * `categories`, `confirm`, ...); after the SDK materializes, those fields merge
+ * onto the target method's entry so the registry / CLI / MCP / docs project the
+ * patched values. The target's `run` and resolvers are untouched.
+ *
+ * Use it for surface-specific tweaks a base method should not carry (e.g. a CLI
+ * that deprecates `fetch` while the SDK does not). It fails loud at build if the
+ * target does not resolve to a method. Include the override in an aggregate's
+ * `imports` to apply it during `createSdk`, or `addPlugin(sdk, override)` to
+ * apply it to a built SDK.
+ */
+declare function defineMethodOverride<const TTarget extends string>(config: {
+    target: TTarget;
+    namespace?: string;
+} & LeafMetaFields): MethodOverridePlugin;
 /**
  * Define an input resolver: a method attachment for one of its parameters. Like
  * `defineMethod` it declares its own `imports`, and its callbacks receive a
@@ -1805,8 +2075,9 @@ declare function defineResolver<const TImports extends ImportsInput = readonly [
     }) => 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: {
+     * more" re-entry hook. Required: a dynamic resolver IS a candidate-lister;
+     * use `type: "static"` for a free-text field. */
+    listItems: (bag: {
         imports: ImportsOf<TImports>;
         input: TInput;
         /** The value `getContext` returned, if any. */
@@ -1930,10 +2201,18 @@ declare function defineProperty<const TName extends string, TValue, const TImpor
     setup?: (bag: {
         imports: ImportsOf<TImports>;
     }) => TState;
+    dispose?: (bag: {
+        imports: ImportsOf<TImports>;
+        state: TState;
+        input?: unknown;
+    }) => void | Promise<void>;
     get: (bag: {
         imports: ImportsOf<TImports>;
         state: TState;
     }) => TValue;
+    /** Templated registry members for this property's dynamic sub-surface (e.g.
+     * a proxy): each a bodyless declaration keyed by `path` instead of `name`. */
+    dynamicMembers?: readonly DynamicMember[];
 } & LeafMetaFields): PropertyPlugin<TName, TValue> & LeafSummary<TNamespace, TName, TImports>;
 /**
  * Declare a stand-in for a property registered elsewhere (a configured factory
@@ -1946,6 +2225,68 @@ declare function defineProperty<const TName extends string, TValue, const TImpor
 declare function declareProperty<const TId extends string, TValue = unknown>(config: {
     id: LiteralString<TId>;
 }): PropertyPlugin<LastSegment<TId>, TValue> & PluginSummary<TId, never>;
+/**
+ * Declare an OPTIONAL stand-in for a property registered elsewhere. Unlike
+ * `declareProperty`, a `declareOptionalProperty` left unsatisfied is NOT a missing
+ * dependency: dependents bind `undefined` instead of the build failing. The
+ * binding type is therefore `TValue | undefined`, so a consumer must handle the
+ * absent case (typically `{ ...DEFAULTS, ...imports.config }`).
+ *
+ * This lets a plugin own its own defaults and treat a provider as override-only:
+ * it builds standalone (no provider registered -> `undefined` -> defaults), and
+ * a registered provider layers on top. Used for the SDK's static config
+ * (defaults live with each consumer; `createZapierSdk` registers an override)
+ * and for framework capabilities a method can run without (e.g. hooks).
+ */
+declare function declareOptionalProperty<const TId extends string, TValue = unknown>(config: {
+    id: LiteralString<TId>;
+}): PropertyPlugin<LastSegment<TId>, TValue | undefined> & PluginSummary<never, never>;
+/**
+ * Define a method-lifecycle hook: a leaf whose `observe` contributes
+ * fire-and-forget observers (`onMethodStart` / `onMethodEnd`) the method
+ * boundary fires around every method, and whose `wrap` contributes
+ * contract-preserving middleware around imported methods. This is how a
+ * MODULE plugin provides cross-cutting behavior (the module-model successor
+ * to a legacy plugin writing `context.hooks` and to `definePlugin`'s
+ * deleted `middleware` map).
+ *
+ * `setup` runs once and owns the hook's state (e.g. a telemetry queue),
+ * delivered to the observers. Each observer's bag
+ * mirrors a method's `run` bag minus `next`: `{ imports, input, state }`, where
+ * `input` is the lifecycle context (`{ methodName, args, depth, ... }`). The
+ * boundary runs observers defensively, so an observer error never breaks the
+ * observed call.
+ */
+declare function defineHook<const TImports extends ImportsInput = readonly [], TState = undefined>(config: {
+    name: string;
+    namespace?: string;
+    imports?: TImports & StaticList<TImports>;
+    setup?: (bag: {
+        imports: ImportsOf<TImports>;
+    }) => TState;
+    dispose?: (bag: {
+        imports: ImportsOf<TImports>;
+        state: TState;
+        input?: unknown;
+    }) => void | Promise<void>;
+    /** Contract-preserving wraps around imported methods, keyed by the target's
+     * binding among `imports` (the middleware onion: dependents-outermost in
+     * topological order). One bag shape with `run`/`observe`; `next` is the
+     * only variant. */
+    wrap?: MiddlewareMap<ImportsOf<TImports>, TState>;
+    observe?: {
+        onMethodStart?: (bag: {
+            imports: ImportsOf<TImports>;
+            input: OnMethodStartContext;
+            state: TState;
+        }) => void;
+        onMethodEnd?: (bag: {
+            imports: ImportsOf<TImports>;
+            input: OnMethodEndContext;
+            state: TState;
+        }) => void;
+    };
+}): HookPlugin;
 /**
  * Declare a stand-in for a whole aggregate (module) registered elsewhere: the
  * aggregate twin of `declareMethod` / `declareProperty`. `exports` is an array
@@ -1960,20 +2301,15 @@ declare function declarePlugin<const TId extends string, const TExports extends
     exports?: TExports & StaticList<TExports>;
 }): AggregatePlugin<LastSegment<TId>, ArrayExports<TExports>> & PluginSummary<TId, never>;
 /**
- * Define a plugin. Two forms, one function:
- *
- * - **Object form** — a module that re-exports child plugins and may wrap
- *   imported methods with `middleware`. `exports` mirrors `imports`: an
- *   array where a leaf binds under its own name (`[greet]` binds "greet"), a
- *   module spreads its bindings, and `selectExports(dep, { hi: "greet" })`
- *   subsets/renames. It is optional, so a pure-middleware module can omit it.
- *   Re-exporting implies a dependency on the child. A middleware key names the
- *   target's binding, a direct dependency.
- * - **Function form** — the legacy function-plugin identity wrapper: it returns
- *   the function unchanged but constrains its return to `PluginProvides` and
- *   preserves the narrow inferred shape, so callers derive `*PluginProvides`
- *   via `ReturnType<typeof plugin>`. This is how the existing ~90 plugins are
- *   written; they run on the module model through the legacy bridge.
+ * Function form — the legacy function-plugin identity wrapper: it returns the
+ * function unchanged but constrains its return to `PluginProvides` and
+ * preserves the narrow inferred shape, so callers derive `*PluginProvides` via
+ * `ReturnType<typeof plugin>`. Such a plugin runs through the legacy bridge
+ * (`fromFunctionPlugin` / `createPluginStack`), deprecated with it.
+ *
+ * @deprecated Author plugins with `defineMethod` / `defineProperty` /
+ * object-form `definePlugin` instead. This form logs a runtime deprecation and
+ * will be removed in a release after the warning ships.
  */
 declare function definePlugin<TSdk, TProvides extends PluginProvides>(fn: (sdk: TSdk & {
     context: {
@@ -1984,12 +2320,19 @@ declare function definePlugin<TSdk, TProvides extends PluginProvides>(fn: (sdk:
         meta: Record<string, PluginMeta>;
     };
 }) => TProvides;
+/**
+ * Define a plugin module: an aggregate that re-exports child plugins.
+ * `exports` mirrors `imports`: an array where a leaf binds under its own name
+ * (`[greet]` binds "greet"), a module spreads its bindings, and
+ * `selectExports(dep, { hi: "greet" })` subsets/renames. It is optional, so an
+ * imports-only module can omit it. Re-exporting implies a dependency on the
+ * child. To wrap imported methods, export a `defineHook` with `wrap`.
+ */
 declare function definePlugin<const TName extends string, const TImports extends ImportsInput = readonly [], const TNamespace extends string = "", const TExports extends readonly (AnyLeafPlugin | AnyAggregatePlugin)[] = readonly []>(config: {
     name: TName;
     namespace?: TNamespace;
     imports?: TImports & StaticList<TImports>;
     exports?: TExports & StaticList<TExports>;
-    middleware?: MiddlewareMap<ImportsOf<TImports>>;
 }): AggregatePlugin<TName, ArrayExports<TExports>> & AggregateSummary<TNamespace, TName, TImports, TExports>;
 
 /**
@@ -2021,6 +2364,18 @@ type AsExports<T> = T extends Record<string, AnyLeafPlugin> ? T : Record<string,
 declare function selectExports<TExports extends Record<string, AnyLeafPlugin>, const TSpecs extends readonly SelectSpec<TExports>[]>(source: AggregatePlugin<string, TExports>, ...specs: TSpecs): AggregatePlugin<string, AsExports<UnionToIntersection<{
     [I in keyof TSpecs]: ResolveSpec<TExports, TSpecs[I]>;
 }[number]>>>;
+/**
+ * Re-export all of a module's exports EXCEPT the named ones, the denylist
+ * complement to {@link selectExports}'s allowlist (think TS `Omit` vs `Pick`).
+ * The argument is a list of SOURCE export names to drop (not resulting
+ * bindings), so there is no key-semantics ambiguity. An unknown name throws.
+ *
+ * The omitted leaves stay in the graph (the synthetic aggregate still `imports`
+ * the source, so it materializes) and remain addressable by id — they are just
+ * not surfaced under a binding. That lets a head replace an export's binding
+ * with its own plugin while still depending on the original by id.
+ */
+declare function omitExports<TExports extends Record<string, AnyLeafPlugin>, const TOmit extends readonly (keyof TExports & string)[]>(source: AggregatePlugin<string, TExports>, omit: TOmit): AggregatePlugin<string, Omit<TExports, TOmit[number]>>;
 
 /**
  * Lift a legacy function plugin into the module model. The
@@ -2028,6 +2383,9 @@ declare function selectExports<TExports extends Record<string, AnyLeafPlugin>, c
  * `createPluginStack().toPlugin()` is built on this, and `addPlugin` uses it for
  * external function plugins. `fn`'s `context` contributions merge into the live
  * `SdkContext`; its other root keys become the surface.
+ *
+ * @deprecated The module model replaces this exit; it logs a runtime
+ * deprecation and will be removed in a release after this warning ships.
  */
 declare function fromFunctionPlugin<TProvides extends PluginProvides>(fn: (sdk: any) => TProvides, config: {
     name: string;
@@ -2041,6 +2399,10 @@ declare function fromFunctionPlugin<TProvides extends PluginProvides>(fn: (sdk:
  * Build a {@link LegacyMergePlugin}: pass the collapsed legacy stack
  * (`stack.toPlugin()`) as `legacy` and the migrated module-model plugins as
  * `plugin`. `createSdk(defineLegacyMerge({...}))` surfaces both.
+ *
+ * @deprecated Build directly with `createSdk(root, { configuration })`
+ * instead; it logs a runtime deprecation and will be removed in a release
+ * after this warning ships.
  */
 declare function defineLegacyMerge<TProvides extends PluginProvides, const TPlugin extends AnyPlugin>(args: {
     name: string;
@@ -2049,17 +2411,200 @@ declare function defineLegacyMerge<TProvides extends PluginProvides, const TPlug
     plugin: TPlugin;
 }): LegacyMergePlugin<TProvides, TPlugin>;
 
+/**
+ * Core error machinery.
+ *
+ * kitcore constructs errors at two internal throw sites: input
+ * validation (`utils/validation.ts`) and non-Error normalization
+ * (`utils/function-utils.ts`'s `normalizeError`). Heads supply a
+ * `adaptError` factory via `createCorePlugin` to map kitcore's abstract
+ * `CoreErrorCode` values onto their own branded error classes; if
+ * no factory is supplied, kitcore falls back to constructing a plain
+ * `CoreError`. Either way, every kitcore-thrown error is brand-stamped
+ * with `CORE_ERROR_SYMBOL` and `coreCode` (non-enumerable),
+ * so consumers can recognize core errors via `isCoreError`
+ * without knowing the head's class identity.
+ */
+/**
+ * Cross-package brand for kitcore-constructed errors. `Symbol.for(key)`
+ * reads from the engine-global registry, so the same value resolves
+ * across realms and across multiple copies of kitcore (e.g. when one
+ * package bundles kitcore and another installs it standalone). Use
+ * `isCoreError` for cross-package checks.
+ */
+declare const CORE_ERROR_SYMBOL: unique symbol;
+/**
+ * Abstract codes for the errors kitcore can produce. Heads receive these
+ * via `AdaptErrorOptions.code` and map them onto their own named
+ * error classes (e.g. `VALIDATION_ERROR` → the head's branded
+ * `<Prefix>ValidationError`).
+ */
+declare const CoreErrorCode: {
+    readonly Validation: "VALIDATION_ERROR";
+    readonly Unknown: "UNKNOWN_ERROR";
+};
+type CoreErrorCode = (typeof CoreErrorCode)[keyof typeof CoreErrorCode];
+/**
+ * Standard error envelope. kitcore doesn't generate these
+ * itself; heads set `errors?: CoreApiError[]` on their error constructor
+ * options when surfacing structured upstream failures.
+ */
+interface CoreApiError {
+    status: number;
+    code: string;
+    title: string;
+    detail: string;
+    source?: unknown;
+    meta?: unknown;
+}
+/**
+ * Base options for the default `CoreError` fallback. Heads' own error
+ * classes typically accept a richer options bag.
+ */
+interface CoreErrorOptions {
+    statusCode?: number;
+    errors?: CoreApiError[];
+    cause?: unknown;
+    response?: unknown;
+}
+/**
+ * What `adaptError` factories receive. `code` is the abstract error
+ * code; `details` carries type-specific extras (validation issues for
+ * `VALIDATION_ERROR`, etc.).
+ */
+interface AdaptErrorOptions {
+    code: CoreErrorCode;
+    message: string;
+    cause?: unknown;
+    details?: unknown;
+}
+type AdaptError = (options: AdaptErrorOptions) => Error;
+/**
+ * Default error class kitcore constructs when no `adaptError` is
+ * supplied. Heads typically provide their own branded classes via
+ * `adaptError` and never see this. Exported so the rare head-less
+ * caller (tests, scratch scripts) can recognize the fallback.
+ */
+declare class CoreError extends Error {
+    readonly name: string;
+    statusCode?: number;
+    errors?: CoreApiError[];
+    cause?: unknown;
+    response?: unknown;
+    constructor(message: string, options?: CoreErrorOptions);
+}
+/**
+ * Construct a core error, optionally via a head-supplied factory.
+ * Stamps the core brand and the abstract `coreCode` on the
+ * returned instance (non-enumerable, so they don't pollute JSON
+ * serialization). The `instanceof <HeadErrorClass>` check on the
+ * result works as expected; `isCoreError` is the cross-package
+ * recognizer that survives bundled/standalone splits.
+ */
+declare function createCoreError(options: AdaptErrorOptions, adaptError?: AdaptError): Error;
+/**
+ * Cross-package-safe check that `value` was produced by kitcore's
+ * error construction path (i.e. through `createCoreError`). Use
+ * this in code that needs to distinguish "kitcore threw this" from
+ * "a handler threw an unrelated `Error` subclass" — `instanceof` checks
+ * on specific head classes also work, but `isCoreError` is the
+ * neutral recognizer.
+ */
+declare function isCoreError(value: unknown): boolean;
+/**
+ * Abstract `CoreErrorCode` for an error produced via
+ * `createCoreError`. Returns `undefined` for non-kitcore values.
+ */
+declare function getCoreErrorCode(value: unknown): CoreErrorCode | undefined;
+/**
+ * `cause` field accessor that doesn't trip the type system. Same as
+ * `(value as { cause?: unknown }).cause` for kitcore-produced errors;
+ * returns `undefined` for non-kitcore values.
+ */
+declare function getCoreErrorCause(value: unknown): unknown;
+
+/**
+ * Framework options (`CoreOptions`) and their well-known configuration id.
+ * Heads inject the bag under `CORE_OPTIONS_ID` via `createSdk`'s
+ * `configuration`; the method boundary resolves it by id at every invocation
+ * (`resolveCoreOptions`), and `coreOptionsPluginRef` (model/builtins) is the
+ * importable stand-in for plugins that need the same options.
+ */
+
+/**
+ * What the boundary reports when a deprecated method is called: the method
+ * plus its declared `deprecation` meta, whole, so future declaration fields
+ * ride along without a signature change. `type` makes the record
+ * self-describing (the shape a future unified event channel would carry;
+ * see docs/design/2026-06-04-unified-event-bus.md).
+ */
+interface DeprecationWarning {
+    type: "deprecation";
+    methodName: string;
+    deprecation: FunctionDeprecation;
+}
+/**
+ * The default `logDeprecation` handler: format the one-line warning and pass
+ * it through kitcore's deduping logger, so the built-in policy is
+ * once-per-process per message.
+ */
+declare function defaultLogDeprecation({ methodName, deprecation, }: DeprecationWarning): void;
+/**
+ * The well-known id for framework options: heads inject a `CoreOptions` bag
+ * under it via `createSdk`'s `configuration` (or register a property plugin),
+ * and the method boundary resolves it by id at every invocation, falling back
+ * to the legacy `context.core` write while the deprecated `createCorePlugin`
+ * path still exists.
+ */
+declare const CORE_OPTIONS_ID = "kitcore/coreOptions";
+/**
+ * Head-supplied configuration for kitcore-managed behavior. All fields are
+ * optional; absent fields fall back to kitcore's built-in behavior.
+ */
+interface CoreOptions {
+    /**
+     * Construct the head's branded error class for kitcore-thrown errors
+     * (validation failures, non-Error normalization). Receives the
+     * abstract `CoreErrorCode`, message, optional cause, and
+     * type-specific details; returns the head's `Error` subclass. The
+     * returned instance is automatically brand-stamped via
+     * `createCoreError` so `isCoreError(err)` still recognizes
+     * it across package boundaries. If absent, kitcore throws a plain
+     * `CoreError`.
+     */
+    adaptError?: AdaptError;
+    /**
+     * The deprecation HANDLER (adaptError's sibling, not an observer): the
+     * framework signals every call of a method declaring `deprecation` meta,
+     * and this gate decides what happens — policy (how often to tell; the
+     * deduping deprecation loggers make once-per-process one line) and
+     * presentation. Exactly one: absent falls back to
+     * {@link defaultLogDeprecation}, supplied replaces it. Runs isolated, so a
+     * throwing handler never breaks the observed call. Additive observation
+     * (many subscribers, e.g. telemetry counting hits) is a different concept
+     * reserved for an `on*`-named observer when the unified event bus lands.
+     */
+    logDeprecation?: (warning: DeprecationWarning) => void;
+}
+
+/**
+ * The optional stand-in for the framework-options bag (`kitcore/coreOptions`).
+ * The method boundary resolves the same id internally (for `adaptError`); a
+ * plugin that needs the options imports this ref, binding
+ * `CoreOptions | undefined` (absent means kitcore's built-in behavior). Heads
+ * supply the value via `createSdk`'s `configuration` or a registered property.
+ */
+declare const coreOptionsPluginRef: PropertyPlugin<"coreOptions", CoreOptions | undefined> & PluginSummary<never, never>;
 /**
  * Escape hatch. A built-in privileged plugin whose value is the live
- * `SdkContext`: the raw plugin graph plus the legacy compat fields. Importing it
- * (`imports.context`) lets a body reach internals the model otherwise keeps
- * private.
+ * `SdkContext` (the raw plugin graph). Importing it (`imports.context`) lets a
+ * body reach internals the model otherwise keeps private.
  *
  * Prefer not to depend on this. The `SdkContext` shape is an implementation
  * detail and may change without notice; import the specific plugins you need,
- * and use `getRegistryPlugin` for surface introspection. It exists mainly so a
- * not-yet-migrated plugin can read legacy `context.*` fields during migration.
- * Its value is injected at materialization, not authored.
+ * use `getRegistryPlugin` for surface introspection, and `resolvePlugin` for
+ * out-of-graph access to a binding. Its value is injected at materialization,
+ * not authored.
  */
 declare const dangerousContextPlugin: PropertyPlugin<"context", SdkContext>;
 /**
@@ -2081,20 +2626,60 @@ declare const getRegistryPlugin: MethodPlugin<"getRegistry", {
  * runtime but kept OUT of the public SDK type (a `unique symbol` in an exported
  * type can't be named in a consumer's emitted `.d.ts`); reach it through the
  * typed `getContext(sdk)` accessor.
+ *
+ * `Symbol.for`, not `Symbol()`: heads bundle kitcore (tsup `noExternal`), so
+ * an sdk built by one bundle's copy must still be readable by another copy's
+ * `getContext` / `resolvePlugin` (e.g. a CLI sdk inspected with helpers
+ * imported from `@zapier/zapier-sdk`). The global symbol registry makes every
+ * copy agree on the key.
  */
 declare const CONTEXT: unique symbol;
 /** The off-surface escape hatch to an SDK's `SdkContext`. */
 declare function getContext(sdk: unknown): SdkContext;
+/**
+ * Resolve a plugin's materialized value against a built SDK: a method's
+ * callable or a property's value (the same thing an importer receives), NOT
+ * the plugin descriptor. For head infrastructure that builds the SDK and
+ * needs one of its own internals; consumers use the SDK surface, and in-graph
+ * code keeps using `imports`. Read-only against the built graph; nothing
+ * materializes. A missing required ref throws; an unsatisfied optional ref
+ * resolves `undefined` (matching import behavior); a live `get` property
+ * re-reads per call (a read-time snapshot — hold the function, not the value,
+ * for liveness). Aggregate refs are not one-ref-one-binding and are
+ * unsupported.
+ */
+declare function resolvePlugin<TRef extends AnyLeafPlugin>(sdk: unknown, ref: TRef): ExportSurface<TRef>;
+/**
+ * Thrown by {@link disposeSdk} when one or more dispose callbacks failed.
+ * Every dispose was still attempted; `errors` holds the failures in teardown
+ * order.
+ */
+declare class CoreDisposeError extends Error {
+    readonly name: string;
+    readonly errors: unknown[];
+    constructor(errors: unknown[]);
+}
+/**
+ * Tear down a built SDK: run every recorded `dispose` (a leaf's `setup` dual)
+ * in reverse build order, so dependents release before their dependencies.
+ * Each dispose is awaited and run defensively; all are attempted even after a
+ * failure, then the failures reject together as {@link CoreDisposeError}.
+ * Idempotent: the first call's `input` wins and later calls return the same
+ * settled result. A top-level function like `addPlugin`, reaching internals
+ * through the `CONTEXT` symbol, so anyone holding the sdk can call it.
+ */
+declare function disposeSdk(sdk: unknown, input?: unknown): Promise<void>;
 /**
  * Materialize one plugin into an SDK whose surface is that plugin's exports.
  * A method root surfaces its callable under its bare name; a property root its
- * value; an aggregate root its export bindings.
- */
-declare function createSdk<P extends AnyMethodPlugin>(root: P & CompletenessOf<P>): MethodSdkOf<P>;
-declare function createSdk<P extends AnyPropertyPlugin>(root: P & CompletenessOf<P>): PropertySdkOf<P>;
-declare function createSdk<P extends AnyAggregatePlugin>(root: P & CompletenessOf<P>): AggregateSdkOf<P>;
-declare function createSdk<TSurface>(root: LegacyPlugin<TSurface>): TSurface & SdkInternals;
-declare function createSdk<TProvides extends PluginProvides, TPlugin extends AnyPlugin>(root: LegacyMergePlugin<TProvides, TPlugin>): TProvides & {
+ * value; an aggregate root its export bindings. `options.configuration`
+ * injects runtime values by plugin id (see {@link CreateSdkOptions}).
+ */
+declare function createSdk<P extends AnyMethodPlugin>(root: P & CompletenessOf<P>, options?: CreateSdkOptions): MethodSdkOf<P>;
+declare function createSdk<P extends AnyPropertyPlugin>(root: P & CompletenessOf<P>, options?: CreateSdkOptions): PropertySdkOf<P>;
+declare function createSdk<P extends AnyAggregatePlugin>(root: P & CompletenessOf<P>, options?: CreateSdkOptions): AggregateSdkOf<P>;
+declare function createSdk<TSurface>(root: LegacyPlugin<TSurface>, options?: CreateSdkOptions): TSurface & SdkInternals;
+declare function createSdk<TProvides extends PluginProvides, TPlugin extends AnyPlugin>(root: LegacyMergePlugin<TProvides, TPlugin>, options?: CreateSdkOptions): TProvides & {
     getRegistry: (options?: {
         package?: string;
     }) => RegistryResult;
@@ -2139,7 +2724,12 @@ interface ControllerAffordance {
     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). */
+ * the self-describing `actions` list (single source of truth, no flags).
+ * `actions` is emitted in recommended presentation order — answer directly
+ * (`choose`/`custom`/`add`), refine (`search`), paginate (`more`), decline
+ * (`skip`/`done`), and failure questions offer `retry` then `cancel` — so a
+ * minimal host can render the list verbatim, top to bottom. Hosts with richer
+ * widgets (windowed lists, filter state) may reorder. */
 type ControllerQuestion = {
     type: "select";
     message: string;
@@ -2147,12 +2737,23 @@ type ControllerQuestion = {
     description?: string;
     choices: ControllerChoice[];
     actions: ControllerAffordance[];
+    /** The active search term these `choices` were fetched for, when the
+     * resolver is search-mode and a `search` action has run. Absent means no
+     * search yet (the initial state of a search-mode resolver): a host leads
+     * with a term prompt rather than an unfiltered list. Local
+     * type-to-filter is for bounded loaded lists; search-mode does discrete
+     * server queries. */
+    search?: string;
     /** 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[];
+    /** The resolver's `placeholder`, carried so a search-mode host can show it
+     * in its lead-with-term prompt (e.g. "Enter or search app (e.g. 'slack')").
+     * Only meaningful before a search has run. */
+    placeholder?: string;
 } | {
     type: "input";
     message: string;
@@ -2164,8 +2765,27 @@ type ControllerQuestion = {
     type: "collection";
     message: string;
     description?: string;
-    count: number;
-    min: number;
+    /** 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";
+    /** 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
+     * rendering `message`. Absent on the entry gate: its fields aren't
+     * fetched until the gate is accepted. */
+    fields?: {
+        key: string;
+        label?: string;
+        valueType?: string;
+    }[];
+    /** Array only: items so far. */
+    count?: number;
+    /** Array only: `minItems`. */
+    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;
@@ -2248,6 +2868,12 @@ interface ControllerState {
     settled: string[];
     /** 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";
     /** Listing progress for the current dynamic leaf (serializable: items +
      * cursor, never a live iterator). */
     listing?: ControllerListing;
@@ -2425,8 +3051,8 @@ declare function createController(sdk: ControllerSdk): Controller;
 
 /**
  * Minimal SDK shape the function wrappers accept. The wrappers only
- * touch `context.hooks` and `context.core.*`, but we keep `context`
- * typed as `unknown` so any kitcore-built SDK (whose context type
+ * touch `context.hooks` and the resolved core options, but we keep
+ * `context` typed as `unknown` so any kitcore-built SDK (whose context type
  * widens unpredictably as plugins layer on) flows through without
  * upstream type narrowing. Each read inside is asserted at the use
  * site against the small slice we actually need.
@@ -2449,6 +3075,8 @@ declare function createFunction<TOptions, TResult, TSchemaOptions extends TOptio
     sdk: FunctionSdk;
     schema?: z.ZodSchema<TSchemaOptions>;
     name?: string;
+    /** Live read of the method's deprecation meta (see signalDeprecation). */
+    getDeprecation?: () => FunctionDeprecation | undefined;
 }): (callOptions?: TOptions) => Promise<TResult>;
 /**
  * Higher-order function that creates a paginated function that wraps
@@ -2483,6 +3111,8 @@ declare function createPaginatedFunction<TUserOptions, TResponse, TItem = ItemTy
      * would collapse `TItem` to `unknown`.
      */
     adaptPage?: (response: TResponse) => SdkPage<NoInfer<TItem>>;
+    /** Live read of the method's deprecation meta (see signalDeprecation). */
+    getDeprecation?: () => FunctionDeprecation | undefined;
 }): (options?: TUserOptions & {
     cursor?: string;
     pageSize?: number;
@@ -2490,167 +3120,13 @@ declare function createPaginatedFunction<TUserOptions, TResponse, TItem = ItemTy
 }) => PaginatedSdkResult<TItem>;
 
 /**
- * Core error machinery.
- *
- * kitcore constructs errors at two internal throw sites: input
- * validation (`utils/validation.ts`) and non-Error normalization
- * (`utils/function-utils.ts`'s `normalizeError`). Heads supply a
- * `adaptError` factory via `createCorePlugin` to map kitcore's abstract
- * `CoreErrorCode` values onto their own branded error classes; if
- * no factory is supplied, kitcore falls back to constructing a plain
- * `CoreError`. Either way, every kitcore-thrown error is brand-stamped
- * with `CORE_ERROR_SYMBOL` and `coreCode` (non-enumerable),
- * so consumers can recognize core errors via `isCoreError`
- * without knowing the head's class identity.
- */
-/**
- * Cross-package brand for kitcore-constructed errors. `Symbol.for(key)`
- * reads from the engine-global registry, so the same value resolves
- * across realms and across multiple copies of kitcore (e.g. when one
- * package bundles kitcore and another installs it standalone). Use
- * `isCoreError` for cross-package checks.
- */
-declare const CORE_ERROR_SYMBOL: unique symbol;
-/**
- * Abstract codes for the errors kitcore can produce. Heads receive these
- * via `AdaptErrorOptions.code` and map them onto their own named
- * error classes (e.g. `VALIDATION_ERROR` → the head's branded
- * `<Prefix>ValidationError`).
- */
-declare const CoreErrorCode: {
-    readonly Validation: "VALIDATION_ERROR";
-    readonly Unknown: "UNKNOWN_ERROR";
-};
-type CoreErrorCode = (typeof CoreErrorCode)[keyof typeof CoreErrorCode];
-/**
- * Standard error envelope. kitcore doesn't generate these
- * itself; heads set `errors?: CoreApiError[]` on their error constructor
- * options when surfacing structured upstream failures.
- */
-interface CoreApiError {
-    status: number;
-    code: string;
-    title: string;
-    detail: string;
-    source?: unknown;
-    meta?: unknown;
-}
-/**
- * Base options for the default `CoreError` fallback. Heads' own error
- * classes typically accept a richer options bag.
- */
-interface CoreErrorOptions {
-    statusCode?: number;
-    errors?: CoreApiError[];
-    cause?: unknown;
-    response?: unknown;
-}
-/**
- * What `adaptError` factories receive. `code` is the abstract error
- * code; `details` carries type-specific extras (validation issues for
- * `VALIDATION_ERROR`, etc.).
- */
-interface AdaptErrorOptions {
-    code: CoreErrorCode;
-    message: string;
-    cause?: unknown;
-    details?: unknown;
-}
-type AdaptError = (options: AdaptErrorOptions) => Error;
-/**
- * Default error class kitcore constructs when no `adaptError` is
- * supplied. Heads typically provide their own branded classes via
- * `adaptError` and never see this. Exported so the rare head-less
- * caller (tests, scratch scripts) can recognize the fallback.
- */
-declare class CoreError extends Error {
-    readonly name: string;
-    statusCode?: number;
-    errors?: CoreApiError[];
-    cause?: unknown;
-    response?: unknown;
-    constructor(message: string, options?: CoreErrorOptions);
-}
-/**
- * Construct a core error, optionally via a head-supplied factory.
- * Stamps the core brand and the abstract `coreCode` on the
- * returned instance (non-enumerable, so they don't pollute JSON
- * serialization). The `instanceof <HeadErrorClass>` check on the
- * result works as expected; `isCoreError` is the cross-package
- * recognizer that survives bundled/standalone splits.
- */
-declare function createCoreError(options: AdaptErrorOptions, adaptError?: AdaptError): Error;
-/**
- * Cross-package-safe check that `value` was produced by kitcore's
- * error construction path (i.e. through `createCoreError`). Use
- * this in code that needs to distinguish "kitcore threw this" from
- * "a handler threw an unrelated `Error` subclass" — `instanceof` checks
- * on specific head classes also work, but `isCoreError` is the
- * neutral recognizer.
- */
-declare function isCoreError(value: unknown): boolean;
-/**
- * Abstract `CoreErrorCode` for an error produced via
- * `createCoreError`. Returns `undefined` for non-kitcore values.
- */
-declare function getCoreErrorCode(value: unknown): CoreErrorCode | undefined;
-/**
- * `cause` field accessor that doesn't trip the type system. Same as
- * `(value as { cause?: unknown }).cause` for kitcore-produced errors;
- * returns `undefined` for non-kitcore values.
- */
-declare function getCoreErrorCause(value: unknown): unknown;
-
-/**
- * ------------------------------
- * Core configuration plugin
- * ------------------------------
- *
- * `createCorePlugin` is how a head supplies kitcore-level behavior knobs
- * (`adaptError` for branded errors, future entries similarly). The plugin
- * writes to `context.core`; kitcore reads from that path at every method
- * invocation. Consumers configure through this factory's typed `CoreOptions`,
- * never by touching the context path.
- *
- *   createPluginStack()
- *     .use(createCorePlugin({ adaptError: myAdaptError }))
- *     .use(listAppsPlugin);
- *
- * Installing this plugin is optional. Kitcore reads `context.core.*`
- * with optional chaining, so an SDK without `createCorePlugin`
- * installed just falls back to kitcore's built-in behavior.
- *
- * Note: pagination shaping is NOT configured here. Each paginated method
- * declares its own `adaptPage` on `createPaginatedPluginMethod`, so the
- * adapter travels with the plugin (and stays type-checked) rather than
- * relying on an ambient SDK-wide default.
- */
-
-/**
- * Head-supplied configuration for kitcore-managed behavior. All fields are
- * optional; absent fields fall back to kitcore's built-in behavior.
- */
-interface CoreOptions {
-    /**
-     * Construct the head's branded error class for kitcore-thrown errors
-     * (validation failures, non-Error normalization). Receives the
-     * abstract `CoreErrorCode`, message, optional cause, and
-     * type-specific details; returns the head's `Error` subclass. The
-     * returned instance is automatically brand-stamped via
-     * `createCoreError` so `isCoreError(err)` still recognizes
-     * it across package boundaries. If absent, kitcore throws a plain
-     * `CoreError`.
-     */
-    adaptError?: AdaptError;
-}
-/**
- * Register kitcore-level configuration. Writes the options to
- * `context.core` internally; consumers never reference the path.
+ * Register kitcore-level configuration by writing the options to
+ * `context.core`; the method boundary falls back to that path when no
+ * `kitcore/coreOptions` configuration value exists.
  *
- * Reads of `context.core.adaptError` are
- * live: kitcore's method wrappers consult them at every invocation,
- * not at registration time. A `createCorePlugin` registered after a
- * method plugin still applies to that method's subsequent calls.
+ * @deprecated Inject the `CoreOptions` bag under `CORE_OPTIONS_ID` via
+ * `createSdk(root, { configuration })` instead. This factory logs a runtime
+ * deprecation and will be removed in a release after the warning ships.
  */
 declare function createCorePlugin(options: CoreOptions): Plugin<object, {
     context: {
@@ -2904,4 +3380,4 @@ declare class CoreCancelledSignal extends CoreSignal {
     constructor(message?: string);
 }
 
-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_SIGNAL_SYMBOL, type CategoryDefinition, type ConstantResolver$1 as ConstantResolver, type Controller, type ControllerAction, type ControllerAffordance, type ControllerAnswerFn, type ControllerChoice, type ControllerError, type ControllerIssue, type ControllerListing, type ControllerMethodDescription, type ControllerMethodSummary, type ControllerParameterDescription, type ControllerPath, type ControllerQuestion, type ControllerResult, type ControllerSdk, type ControllerState, type CoreApiError, CoreCancelledSignal, CoreError, CoreErrorCode, type CoreErrorOptions, type CoreOptions, CoreSignal, type DeprecatedPromptConfigChoice, type DeprecationLogger, type DynamicListResolver, type DynamicResolver$1 as DynamicResolver, type DynamicSearchResolver, type FieldsResolver, type FormattedItem, type Formatter, type FunctionDeprecation, type FunctionRegistryEntry, type LeafMeta, type LegacyMergePlugin, type LegacyPlugin, type ListItemsResult, type ListPromptConfig, type MethodAttachment, type MethodHooks, type MethodPlugin, type MethodScope, 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 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, concatPaginated, createAsyncContext, createController, createCoreError, createCorePlugin, createDeprecationLogger, createFunction, createPaginatedFunction, createPaginatedPluginMethod, createPluginMethod, createPluginStack, createPrefixedCursor, createSdk, createValidator, dangerousContextPlugin, declareMethod, declarePlugin, declareProperty, decodeIncomingCursor, defineFormatter, defineLegacyMerge, defineMethod, definePlugin, defineProperty, defineResolver, fromFunctionPlugin, getContext, getCoreErrorCause, getCoreErrorCode, getCurrentDepth, getCurrentScope, getFieldDescriptions, getOutputSchema, getRegistryPlugin, getSchemaDescription, isCoreError, isCoreSignal, isNestedMethodCall, isPositional, isTelemetryNested, openEnum, paginate, paginateBuffered, paginateMaxItems, 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 ControllerListing, type ControllerMethodDescription, type ControllerMethodSummary, type ControllerParameterDescription, type ControllerPath, type ControllerQuestion, type ControllerResult, type ControllerSdk, 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, 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 };