@hey-api/openapi-ts 0.94.0 → 0.94.1

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { n as UserConfig } from "./types-Ba27ofyy.mjs";
-import { AnalysisContext, BindingKind, ExportModule, File, FromRef, ImportModule, Language, Logger, Node, NodeName as NodeName$1, NodeNameSanitizer, NodeRelationship, NodeScope, Ref, Refs, RenderContext, Renderer, Symbol, SymbolMeta } from "@hey-api/codegen-core";
-import { Casing, Context, DefinePlugin, DefinePlugin as DefinePlugin$1, FeatureToggle, IR, IR as IR$1, LinguistLanguages, NameTransformer, NamingConfig, NamingOptions, NamingRule, OpenApi, OpenApiMetaObject, OpenApiOperationObject, OpenApiParameterObject, OpenApiRequestBodyObject, OpenApiResponseObject, OpenApiSchemaObject, OpenApiV2_0_XTypes, OpenApiV3_0_XTypes, OpenApiV3_1_XTypes, OperationPath, OperationPathStrategy, OperationStrategy, OperationsStrategy, Plugin, Plugin as Plugin$1, SchemaExtractor, SchemaVisitorContext, SchemaWithType, Walker, defaultPaginationKeywords, definePluginConfig, utils } from "@hey-api/shared";
+import { AnalysisContext, BindingKind, ExportModule, File, FromRef, ImportModule, Language, Logger, Node, NodeName as NodeName$1, NodeNameSanitizer, NodeRelationship, NodeScope, Ref, RenderContext, Renderer, Symbol } from "@hey-api/codegen-core";
+import { Casing, Context, DefinePlugin, DefinePlugin as DefinePlugin$1, FeatureToggle, IR, IR as IR$1, LinguistLanguages, NameTransformer, NamingConfig, NamingOptions, NamingRule, OpenApi, OpenApiMetaObject, OpenApiOperationObject, OpenApiParameterObject, OpenApiRequestBodyObject, OpenApiResponseObject, OpenApiSchemaObject, OpenApiV2_0_XTypes, OpenApiV3_0_XTypes, OpenApiV3_1_XTypes, OperationPath, OperationPathStrategy, OperationStrategy, OperationsStrategy, Plugin, Plugin as Plugin$1, SchemaVisitorContext, SchemaWithType, Walker, defaultPaginationKeywords, definePluginConfig, utils } from "@hey-api/shared";
 import ts from "typescript";
 import { AnyString, LazyOrAsync, MaybeArray, MaybeFunc } from "@hey-api/types";
 import { HttpClient, HttpErrorResponse, HttpHeaders, HttpRequest, HttpResponse } from "@angular/common/http";
@@ -705,7 +705,7 @@ declare class TypeIdxTsDsl extends Mixed$43 {
 //#endregion
 //#region src/ts-dsl/type/operator.d.ts
 type Op = ts.SyntaxKind.KeyOfKeyword | ts.SyntaxKind.ReadonlyKeyword | ts.SyntaxKind.UniqueKeyword;
-type Type$2 = string | MaybeTsDsl<ts.TypeNode>;
+type Type$3 = string | MaybeTsDsl<ts.TypeNode>;
 type TypeOperatorCtor = () => TypeOperatorTsDsl;
 declare const Mixed$42: abstract new () => TsDsl<ts.TypeOperatorNode>;
 /**
@@ -724,23 +724,23 @@ declare class TypeOperatorTsDsl extends Mixed$42 {
   readonly '~dsl' = "TypeOperatorTsDsl";
   scope: NodeScope;
   protected _op?: Op;
-  protected _type?: Type$2;
+  protected _type?: Type$3;
   analyze(ctx: AnalysisContext): void;
   /** Shorthand: builds `keyof T`. */
-  keyof(type: Type$2): this;
+  keyof(type: Type$3): this;
   /** Sets the operator explicitly. */
   operator(op: Op): this;
   /** Shorthand: builds `readonly T`. */
-  readonly(type: Type$2): this;
+  readonly(type: Type$3): this;
   /** Sets the target type of the operator. */
-  type(type: Type$2): this;
+  type(type: Type$3): this;
   /** Shorthand: builds `unique T`. */
-  unique(type: Type$2): this;
+  unique(type: Type$3): this;
   toAst(): ts.TypeOperatorNode;
   /** Throws if required fields are not set. */
   $validate(): asserts this is this & {
     _op: Op;
-    _type: Type$2;
+    _type: Type$3;
   };
   private missingRequiredCalls;
 }
@@ -1021,16 +1021,64 @@ declare class NoteTsDsl extends TsDsl<ts.Node> {
   toAst(): any;
 }
 //#endregion
+//#region src/ts-dsl/mixins/value.d.ts
+type ValueExpr = string | MaybeTsDsl<ts.Expression>;
+interface ValueMethods extends Node {
+  $value(): ts.Expression | undefined;
+  /** Sets the initializer expression (e.g. `= expr`). */
+  assign(expr: ValueExpr): this;
+}
+//#endregion
+//#region src/ts-dsl/mixins/pattern.d.ts
+interface PatternMethods extends Node {
+  /** Renders the pattern into a `BindingName`. */
+  $pattern(): ts.BindingName | undefined;
+  /** Defines an array binding pattern. */
+  array(...props: ReadonlyArray<string> | [ReadonlyArray<string>]): this;
+  /** Defines an object binding pattern. */
+  object(...props: ReadonlyArray<MaybeArray<string> | Record<string, string>>): this;
+  /** Adds a spread element (e.g. `...args`, `...options`) to the pattern. */
+  spread(name: string): this;
+}
+//#endregion
+//#region src/ts-dsl/mixins/decorator.d.ts
+interface DecoratorMethods extends Node {
+  /** Renders the decorators into an array of `ts.Decorator`s. */
+  $decorators(): ReadonlyArray<ts.Decorator>;
+  /** Adds a decorator (e.g. `@sealed({ in: 'root' })`). */
+  decorator(name: NodeName$1 | MaybeTsDsl<ts.Expression>, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>): this;
+}
+//#endregion
+//#region src/ts-dsl/decl/param.d.ts
+type ParamName = NodeName$1 | ParamFn;
+type ParamFn = (p: ParamTsDsl) => void;
+type ParamCtor = (name: ParamName, fn?: ParamFn) => ParamTsDsl;
+declare const Mixed$37: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ParameterDeclaration>, ValueMethods>, PatternMethods>, OptionalMethods>, DecoratorMethods>;
+declare class ParamTsDsl extends Mixed$37 {
+  readonly '~dsl' = "ParamTsDsl";
+  protected _type?: TypeTsDsl;
+  constructor(name: ParamName, fn?: ParamFn);
+  analyze(ctx: AnalysisContext): void;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  /** Sets the parameter type. */
+  type(type: string | TypeTsDsl): this;
+  toAst(): ts.ParameterDeclaration;
+  $validate(): asserts this;
+  private missingRequiredCalls;
+}
+//#endregion
 //#region src/ts-dsl/type/param.d.ts
 type TypeParamExpr = NodeName$1 | boolean | MaybeTsDsl<TypeTsDsl>;
-declare const Mixed$37: abstract new () => TsDsl<ts.TypeParameterDeclaration>;
-declare class TypeParamTsDsl extends Mixed$37 {
+declare const Mixed$36: abstract new () => TsDsl<ts.TypeParameterDeclaration>;
+declare class TypeParamTsDsl extends Mixed$36 {
   readonly '~dsl' = "TypeParamTsDsl";
   scope: NodeScope;
   protected constraint?: Ref<TypeParamExpr>;
   protected defaultValue?: Ref<TypeParamExpr>;
   constructor(name?: NodeName$1, fn?: (name: TypeParamTsDsl) => void);
   analyze(ctx: AnalysisContext): void;
+  /** Sets the parameter default value. */
   default(value: TypeParamExpr): this;
   extends(constraint: TypeParamExpr): this;
   toAst(): ts.TypeParameterDeclaration;
@@ -1155,26 +1203,10 @@ interface DocMethods extends Node {
   doc(lines?: DocLines, fn?: DocFn): this;
 }
 //#endregion
-//#region src/ts-dsl/mixins/decorator.d.ts
-interface DecoratorMethods extends Node {
-  /** Renders the decorators into an array of `ts.Decorator`s. */
-  $decorators(): ReadonlyArray<ts.Decorator>;
-  /** Adds a decorator (e.g. `@sealed({ in: 'root' })`). */
-  decorator(name: NodeName$1 | MaybeTsDsl<ts.Expression>, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>): this;
-}
-//#endregion
-//#region src/ts-dsl/mixins/value.d.ts
-type ValueExpr = string | MaybeTsDsl<ts.Expression>;
-interface ValueMethods extends Node {
-  $value(): ts.Expression | undefined;
-  /** Sets the initializer expression (e.g. `= expr`). */
-  assign(expr: ValueExpr): this;
-}
-//#endregion
 //#region src/ts-dsl/decl/field.d.ts
 type FieldType = NodeName$1 | TypeTsDsl;
-declare const Mixed$36: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.PropertyDeclaration>, ValueMethods>, StaticMethods>, ReadonlyMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, OptionalMethods>, DocMethods>, DecoratorMethods>;
-declare class FieldTsDsl extends Mixed$36 {
+declare const Mixed$35: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.PropertyDeclaration>, ValueMethods>, StaticMethods>, ReadonlyMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, OptionalMethods>, DocMethods>, DecoratorMethods>;
+declare class FieldTsDsl extends Mixed$35 {
   readonly '~dsl' = "FieldTsDsl";
   readonly nameSanitizer: (name: string) => string;
   protected _type?: TypeTsDsl;
@@ -1185,35 +1217,6 @@ declare class FieldTsDsl extends Mixed$36 {
   toAst(): ts.PropertyDeclaration;
 }
 //#endregion
-//#region src/ts-dsl/mixins/pattern.d.ts
-interface PatternMethods extends Node {
-  /** Renders the pattern into a `BindingName`. */
-  $pattern(): ts.BindingName | undefined;
-  /** Defines an array binding pattern. */
-  array(...props: ReadonlyArray<string> | [ReadonlyArray<string>]): this;
-  /** Defines an object binding pattern. */
-  object(...props: ReadonlyArray<MaybeArray<string> | Record<string, string>>): this;
-  /** Adds a spread element (e.g. `...args`, `...options`) to the pattern. */
-  spread(name: string): this;
-}
-//#endregion
-//#region src/ts-dsl/decl/param.d.ts
-type ParamCtor = (name: NodeName$1 | ((p: ParamTsDsl) => void), fn?: (p: ParamTsDsl) => void) => ParamTsDsl;
-declare const Mixed$35: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ParameterDeclaration>, ValueMethods>, PatternMethods>, OptionalMethods>, DecoratorMethods>;
-declare class ParamTsDsl extends Mixed$35 {
-  readonly '~dsl' = "ParamTsDsl";
-  protected _type?: TypeTsDsl;
-  constructor(name: NodeName$1 | ((p: ParamTsDsl) => void), fn?: (p: ParamTsDsl) => void);
-  analyze(ctx: AnalysisContext): void;
-  /** Returns true when all required builder calls are present. */
-  get isValid(): boolean;
-  /** Sets the parameter type. */
-  type(type: string | TypeTsDsl): this;
-  toAst(): ts.ParameterDeclaration;
-  $validate(): asserts this;
-  private missingRequiredCalls;
-}
-//#endregion
 //#region src/ts-dsl/mixins/param.d.ts
 interface ParamMethods extends Node {
   /** Renders the parameters into an array of `ParameterDeclaration`s. */
@@ -1749,15 +1752,15 @@ declare class TypeAliasTsDsl extends Mixed$10 {
 }
 //#endregion
 //#region src/ts-dsl/type/and.d.ts
-type Type$1 = NodeName$1 | ts.TypeNode | TypeTsDsl;
+type Type$2 = NodeName$1 | ts.TypeNode | TypeTsDsl;
 declare const Mixed$9: abstract new () => TsDsl<ts.IntersectionTypeNode>;
 declare class TypeAndTsDsl extends Mixed$9 {
   readonly '~dsl' = "TypeAndTsDsl";
   scope: NodeScope;
-  protected _types: Array<Ref<Type$1>>;
-  constructor(...nodes: Array<Type$1>);
+  protected _types: Array<Ref<Type$2>>;
+  constructor(...nodes: Array<Type$2>);
   analyze(ctx: AnalysisContext): void;
-  types(...nodes: Array<Type$1>): this;
+  types(...nodes: Array<Type$2>): this;
   toAst(): ts.IntersectionTypeNode;
 }
 //#endregion
@@ -1779,8 +1782,8 @@ declare const Mixed$7: abstract new () => TsDsl<ts.LiteralTypeNode>;
 declare class TypeLiteralTsDsl extends Mixed$7 {
   readonly '~dsl' = "TypeLiteralTsDsl";
   scope: NodeScope;
-  protected value: string | number | boolean | null;
-  constructor(value: string | number | boolean | null);
+  protected value: LiteralValue;
+  constructor(value: LiteralValue);
   analyze(ctx: AnalysisContext): void;
   toAst(): ts.LiteralTypeNode;
 }
@@ -1893,15 +1896,15 @@ declare class TypeObjectTsDsl extends Mixed$3 {
 }
 //#endregion
 //#region src/ts-dsl/type/or.d.ts
-type Type = NodeName$1 | ts.TypeNode | TypeTsDsl;
+type Type$1 = NodeName$1 | ts.TypeNode | TypeTsDsl;
 declare const Mixed$2: abstract new () => TsDsl<ts.UnionTypeNode>;
 declare class TypeOrTsDsl extends Mixed$2 {
   readonly '~dsl' = "TypeOrTsDsl";
   scope: NodeScope;
-  protected _types: Array<Ref<Type>>;
-  constructor(...nodes: Array<Type>);
+  protected _types: Array<Ref<Type$1>>;
+  constructor(...nodes: Array<Type$1>);
   analyze(ctx: AnalysisContext): void;
-  types(...nodes: Array<Type>): this;
+  types(...nodes: Array<Type$1>): this;
   toAst(): ts.UnionTypeNode;
 }
 //#endregion
@@ -2134,7 +2137,7 @@ declare const $: ((id: any) => ExprTsDsl) & {
   /** Creates an object literal expression. */
   object: (...args: ConstructorParameters<typeof ObjectTsDsl>) => ObjectTsDsl;
   /** Creates a parameter declaration for functions or methods. */
-  param: (name: any, fn?: ((p: ParamTsDsl) => void) | undefined) => ParamTsDsl;
+  param: (name: any, fn?: ParamFn | undefined) => ParamTsDsl;
   /** Creates a pattern for destructuring or matching. */
   pattern: () => PatternTsDsl;
   /** Creates a prefix unary expression (e.g. `-x`, `!x`, `~x`). */
@@ -2191,7 +2194,7 @@ declare const $: ((id: any) => ExprTsDsl) & {
     /** Creates an indexed-access type (e.g. `Foo<T>[K]`). */
     idx: (base: string | ts.TypeNode | TsDsl<ts.TypeNode>, index: string | number | ts.TypeNode | TsDsl<ts.TypeNode>) => TypeIdxTsDsl;
     /** Creates a literal type node (e.g. 'foo', 42, or true). */
-    literal: (value: string | number | boolean | null) => TypeLiteralTsDsl;
+    literal: (value: LiteralValue) => TypeLiteralTsDsl;
     /** Creates a mapped type (e.g. `{ [K in keyof T]: U }`). */
     mapped: (name?: any) => TypeMappedTsDsl;
     /** Creates a type literal node (e.g. { foo: string }). */
@@ -3918,181 +3921,540 @@ type Config$12 = Plugin$1.Name<'@hey-api/transformers'> & Plugin$1.Hooks & Plugi
 type HeyApiTransformersPlugin = DefinePlugin$1<UserConfig$14, Config$12>;
 //#endregion
 //#region src/plugins/@hey-api/typescript/shared/types.d.ts
-type IrSchemaToAstOptions$1 = {
-  /** The plugin instance. */
-  plugin: HeyApiTypeScriptPlugin['Instance'];
-  /** Optional schema extractor function. */
-  schemaExtractor?: SchemaExtractor;
-  /** The plugin state references. */
-  state: Refs<PluginState$1>;
-};
-type PluginState$1 = Pick<Required<SymbolMeta>, 'path'> & Pick<Partial<SymbolMeta>, 'tags'>;
-//#endregion
-//#region src/plugins/@hey-api/typescript/v1/plugin.d.ts
-declare function irSchemaToAst({
-  plugin,
-  schema,
-  schemaExtractor,
-  state
-}: IrSchemaToAstOptions$1 & {
-  schema: IR$1.SchemaObject;
-}): MaybeTsDsl<TypeTsDsl>;
+type Type = MaybeTsDsl<TypeTsDsl>;
+/**
+ * Metadata that flows through schema walking.
+ */
+interface TypeScriptMeta {
+  /** Default value from schema. */
+  default?: unknown;
+  /** Is this schema read-only? */
+  readonly: boolean;
+}
+interface TypeScriptEnumData {
+  items: Array<{
+    key: string;
+    schema: IR$1.SchemaObject;
+  }>;
+  mode: 'javascript' | 'typescript' | 'typescript-const' | 'type';
+}
+/**
+ * Result from walking a schema node.
+ */
+interface TypeScriptResult {
+  enumData?: TypeScriptEnumData;
+  meta: TypeScriptMeta;
+  type: Type;
+}
 //#endregion
 //#region src/plugins/@hey-api/typescript/api.d.ts
 type IApi$3 = {
-  schemaToType: (args: Parameters<typeof irSchemaToAst>[0]) => MaybeTsDsl<TypeTsDsl>;
+  schemaToType: (plugin: HeyApiTypeScriptPlugin['Instance'], schema: IR$1.SchemaObject) => Type;
 };
 //#endregion
-//#region src/plugins/@hey-api/typescript/types.d.ts
-type EnumsType = 'javascript' | 'typescript' | 'typescript-const';
-type UserConfig$13 = Plugin$1.Name<'@hey-api/typescript'> & Plugin$1.Hooks & Plugin$1.UserComments & Plugin$1.UserExports & {
+//#region src/plugins/@hey-api/typescript/resolvers.d.ts
+type Resolvers$2 = Plugin$1.Resolvers<{
   /**
-   * Casing convention for generated names.
+   * Resolver for array schemas.
    *
-   * @default 'PascalCase'
+   * Allows customization of how array types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
    */
-  case?: Exclude<Casing, 'SCREAMING_SNAKE_CASE'>;
+  array?: (ctx: ArrayResolverContext$2) => Type | undefined;
   /**
-   * Configuration for reusable schema definitions.
-   *
-   * Controls generation of shared types that can be referenced across
-   * requests and responses.
+   * Resolver for boolean schemas.
    *
-   * Can be:
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
+   * Allows customization of how boolean types are rendered.
    *
-   * @default '{{name}}'
+   * Returning `undefined` will execute the default resolver logic.
    */
-  definitions?: NameTransformer | {
-    /**
-     * Casing convention for generated names.
-     *
-     * @default 'PascalCase'
-     */
-    case?: Casing;
-    /**
-     * Naming pattern for generated names.
-     *
-     * @default '{{name}}'
-     */
-    name?: NameTransformer;
-  };
+  boolean?: (ctx: BooleanResolverContext$2) => Type | undefined;
   /**
-   * By default, enums are emitted as types to preserve runtime-free output.
+   * Resolver for enum schemas.
    *
-   * However, you may want to generate enums as JavaScript objects or
-   * TypeScript enums for runtime usage, interoperability, or integration with
-   * other tools.
+   * Allows customization of how enum types are rendered.
    *
-   * @default false
+   * Returning `undefined` will execute the default resolver logic.
    */
-  enums?: boolean | EnumsType | {
-    /**
-     * Casing convention for generated names.
-     *
-     * @default 'SCREAMING_SNAKE_CASE'
-     */
-    case?: Casing;
-    /**
-     * When generating enums as JavaScript objects, they'll contain a null
-     * value if they're nullable. This might be undesirable if you want to do
-     * `Object.values(Foo)` and have all values be of the same type.
-     *
-     * This setting is disabled by default to preserve the source schemas.
-     *
-     * @default false
-     */
-    constantsIgnoreNull?: boolean;
-    /**
-     * Whether this feature is enabled.
-     *
-     * @default true
-     */
-    enabled?: boolean;
-    /**
-     * Specifies the output mode for generated enums.
-     *
-     * Can be:
-     * - `javascript`: Generates JavaScript objects
-     * - `typescript`: Generates TypeScript enums
-     * - `typescript-const`: Generates TypeScript const enums
-     *
-     * @default 'javascript'
-     */
-    mode?: EnumsType;
-  };
+  enum?: (ctx: EnumResolverContext$2) => Type | undefined;
   /**
-   * Configuration for error-specific types.
-   *
-   * Controls generation of types for error response bodies and status codes.
+   * Resolver for intersection schemas.
    *
-   * Can be:
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
+   * Allows customization of how intersection types are rendered.
    *
-   * @default '{{name}}Errors'
+   * Returning `undefined` will execute the default resolver logic.
    */
-  errors?: NameTransformer | {
-    /**
-     * Casing convention for generated names.
-     *
-     * @default 'PascalCase'
-     */
-    case?: Casing;
-    /**
-     * Naming pattern for generated names.
-     *
-     * @default '{{name}}Error'
-     */
-    error?: NameTransformer;
-    /**
-     * Naming pattern for generated names.
-     *
-     * @default '{{name}}Errors'
-     */
-    name?: NameTransformer;
-  };
+  intersection?: (ctx: IntersectionResolverContext$2) => Type | undefined;
   /**
-   * Configuration for request-specific types.
+   * Resolver for never schemas.
    *
-   * Controls generation of types for request bodies, query parameters, path
-   * parameters, and headers.
+   * Allows customization of how never types are rendered.
    *
-   * Can be:
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  never?: (ctx: NeverResolverContext$2) => Type | undefined;
+  /**
+   * Resolver for null schemas.
    *
-   * @default '{{name}}Data'
+   * Allows customization of how null types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
    */
-  requests?: NameTransformer | {
-    /**
-     * Casing convention for generated names.
-     *
-     * @default 'PascalCase'
-     */
-    case?: Casing;
-    /**
-     * Naming pattern for generated names.
-     *
-     * @default '{{name}}Data'
-     */
-    name?: NameTransformer;
-  };
+  null?: (ctx: NullResolverContext$2) => Type | undefined;
   /**
-   * Configuration for response-specific types.
+   * Resolver for number schemas.
    *
-   * Controls generation of types for response bodies and status codes.
+   * Allows customization of how number types are rendered.
    *
-   * Can be:
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  number?: (ctx: NumberResolverContext$2) => Type | undefined;
+  /**
+   * Resolver for object schemas.
    *
-   * @default '{{name}}Responses'
+   * Allows customization of how object types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
    */
-  responses?: NameTransformer | {
-    /**
-     * Casing convention for generated names.
+  object?: (ctx: ObjectResolverContext$2) => Type | undefined;
+  /**
+   * Resolver for string schemas.
+   *
+   * Allows customization of how string types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  string?: (ctx: StringResolverContext$2) => Type | undefined;
+  /**
+   * Resolver for tuple schemas.
+   *
+   * Allows customization of how tuple types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  tuple?: (ctx: TupleResolverContext$2) => Type | undefined;
+  /**
+   * Resolver for undefined schemas.
+   *
+   * Allows customization of how undefined types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  undefined?: (ctx: UndefinedResolverContext$2) => Type | undefined;
+  /**
+   * Resolver for union schemas.
+   *
+   * Allows customization of how union types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  union?: (ctx: UnionResolverContext$2) => Type | undefined;
+  /**
+   * Resolver for unknown schemas.
+   *
+   * Allows customization of how unknown types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  unknown?: (ctx: UnknownResolverContext$2) => Type | undefined;
+  /**
+   * Resolver for void schemas.
+   *
+   * Allows customization of how void types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  void?: (ctx: VoidResolverContext$2) => Type | undefined;
+}>;
+interface BaseContext$2 extends DollarTsDsl {
+  /** The plugin instance. */
+  plugin: HeyApiTypeScriptPlugin['Instance'];
+}
+interface ArrayResolverContext$2 extends BaseContext$2 {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base array type expression.
+     */
+    base: (ctx: ArrayResolverContext$2) => Type;
+  };
+  schema: SchemaWithType<'array'>;
+  walk: Walker<TypeScriptResult, HeyApiTypeScriptPlugin['Instance']>;
+  walkerCtx: SchemaVisitorContext<HeyApiTypeScriptPlugin['Instance']>;
+}
+interface BooleanResolverContext$2 extends BaseContext$2 {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base boolean type expression.
+     */
+    base: (ctx: BooleanResolverContext$2) => Type;
+    /**
+     * Returns the literal type for const values.
+     */
+    const: (ctx: BooleanResolverContext$2) => Type | undefined;
+  };
+  schema: SchemaWithType<'boolean'>;
+}
+interface EnumResolverContext$2 extends BaseContext$2 {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base enum type expression.
+     */
+    base: (ctx: EnumResolverContext$2) => Type;
+    /**
+     * Returns parsed enum items with metadata about the enum members.
+     */
+    items: (ctx: EnumResolverContext$2) => {
+      /**
+       * String literal values for use with union types.
+       */
+      enumMembers: Array<ReturnType<typeof $.type.literal>>;
+      /**
+       * Whether the enum includes a null value.
+       */
+      isNullable: boolean;
+    };
+  };
+  schema: SchemaWithType<'enum'>;
+}
+interface IntersectionResolverContext$2 extends BaseContext$2 {
+  /**
+   * The child results from walking intersection members.
+   */
+  childResults: ReadonlyArray<TypeScriptResult>;
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base intersection type expression.
+     */
+    base: (ctx: IntersectionResolverContext$2) => Type;
+  };
+  /**
+   * The parent schema containing the intersection.
+   */
+  parentSchema: IR$1.SchemaObject;
+  /**
+   * The individual schemas being intersected.
+   */
+  schemas: ReadonlyArray<IR$1.SchemaObject>;
+}
+interface NeverResolverContext$2 extends BaseContext$2 {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base never type expression.
+     */
+    base: (ctx: NeverResolverContext$2) => Type;
+  };
+  schema: SchemaWithType<'never'>;
+}
+interface NullResolverContext$2 extends BaseContext$2 {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base null type expression.
+     */
+    base: (ctx: NullResolverContext$2) => Type;
+  };
+  schema: SchemaWithType<'null'>;
+}
+interface NumberResolverContext$2 extends BaseContext$2 {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base number type expression.
+     */
+    base: (ctx: NumberResolverContext$2) => Type;
+    /**
+     * Returns the literal type for const values.
+     */
+    const: (ctx: NumberResolverContext$2) => Type | undefined;
+  };
+  schema: SchemaWithType<'integer' | 'number'>;
+}
+interface ObjectResolverContext$2 extends BaseContext$2 {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base object type expression.
+     */
+    base: (ctx: ObjectResolverContext$2) => Type;
+    /**
+     * Returns the shape (properties) of the object type.
+     */
+    shape: (ctx: ObjectResolverContext$2) => ReturnType<typeof $.type.object>;
+  };
+  schema: SchemaWithType<'object'>;
+  walk: Walker<TypeScriptResult, HeyApiTypeScriptPlugin['Instance']>;
+  walkerCtx: SchemaVisitorContext<HeyApiTypeScriptPlugin['Instance']>;
+}
+interface StringResolverContext$2 extends BaseContext$2 {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base string type expression.
+     */
+    base: (ctx: StringResolverContext$2) => Type;
+    /**
+     * Returns the literal type for const values.
+     */
+    const: (ctx: StringResolverContext$2) => Type | undefined;
+    /**
+     * Returns the format-specific type expression.
+     */
+    format: (ctx: StringResolverContext$2) => Type | undefined;
+  };
+  schema: SchemaWithType<'string'>;
+}
+interface TupleResolverContext$2 extends BaseContext$2 {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base tuple type expression.
+     */
+    base: (ctx: TupleResolverContext$2) => Type;
+    /**
+     * Returns the literal type for const tuple values.
+     */
+    const: (ctx: TupleResolverContext$2) => Type | undefined;
+  };
+  schema: SchemaWithType<'tuple'>;
+  walk: Walker<TypeScriptResult, HeyApiTypeScriptPlugin['Instance']>;
+  walkerCtx: SchemaVisitorContext<HeyApiTypeScriptPlugin['Instance']>;
+}
+interface UnionResolverContext$2 extends BaseContext$2 {
+  /**
+   * The child results from walking union members.
+   */
+  childResults: ReadonlyArray<TypeScriptResult>;
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base union type expression.
+     */
+    base: (ctx: UnionResolverContext$2) => Type;
+  };
+  /**
+   * The parent schema containing the union.
+   */
+  parentSchema: IR$1.SchemaObject;
+  /**
+   * The individual schemas being unioned.
+   */
+  schemas: ReadonlyArray<IR$1.SchemaObject>;
+}
+interface UndefinedResolverContext$2 extends BaseContext$2 {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base undefined type expression.
+     */
+    base: (ctx: UndefinedResolverContext$2) => Type;
+  };
+  schema: SchemaWithType<'undefined'>;
+}
+interface UnknownResolverContext$2 extends BaseContext$2 {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base unknown type expression.
+     */
+    base: (ctx: UnknownResolverContext$2) => Type;
+  };
+  schema: SchemaWithType<'unknown'>;
+}
+interface VoidResolverContext$2 extends BaseContext$2 {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base void type expression.
+     */
+    base: (ctx: VoidResolverContext$2) => Type;
+  };
+  schema: SchemaWithType<'void'>;
+}
+//#endregion
+//#region src/plugins/@hey-api/typescript/types.d.ts
+type EnumsType = 'javascript' | 'typescript' | 'typescript-const';
+type UserConfig$13 = Plugin$1.Name<'@hey-api/typescript'> & Plugin$1.Hooks & Plugin$1.UserComments & Plugin$1.UserExports & Resolvers$2 & {
+  /**
+   * Casing convention for generated names.
+   *
+   * @default 'PascalCase'
+   */
+  case?: Exclude<Casing, 'SCREAMING_SNAKE_CASE'>;
+  /**
+   * Configuration for reusable schema definitions.
+   *
+   * Controls generation of shared types that can be referenced across
+   * requests and responses.
+   *
+   * Can be:
+   * - `string` or `function`: Shorthand for `{ name: string | function }`
+   * - `object`: Full configuration object
+   *
+   * @default '{{name}}'
+   */
+  definitions?: NameTransformer | {
+    /**
+     * Casing convention for generated names.
+     *
+     * @default 'PascalCase'
+     */
+    case?: Casing;
+    /**
+     * Naming pattern for generated names.
+     *
+     * @default '{{name}}'
+     */
+    name?: NameTransformer;
+  };
+  /**
+   * By default, enums are emitted as types to preserve runtime-free output.
+   *
+   * However, you may want to generate enums as JavaScript objects or
+   * TypeScript enums for runtime usage, interoperability, or integration with
+   * other tools.
+   *
+   * @default false
+   */
+  enums?: boolean | EnumsType | {
+    /**
+     * Casing convention for generated names.
+     *
+     * @default 'SCREAMING_SNAKE_CASE'
+     */
+    case?: Casing;
+    /**
+     * When generating enums as JavaScript objects, they'll contain a null
+     * value if they're nullable. This might be undesirable if you want to do
+     * `Object.values(Foo)` and have all values be of the same type.
+     *
+     * This setting is disabled by default to preserve the source schemas.
+     *
+     * @default false
+     */
+    constantsIgnoreNull?: boolean;
+    /**
+     * Whether this feature is enabled.
+     *
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Specifies the output mode for generated enums.
+     *
+     * Can be:
+     * - `javascript`: Generates JavaScript objects
+     * - `typescript`: Generates TypeScript enums
+     * - `typescript-const`: Generates TypeScript const enums
+     *
+     * @default 'javascript'
+     */
+    mode?: EnumsType;
+  };
+  /**
+   * Configuration for error-specific types.
+   *
+   * Controls generation of types for error response bodies and status codes.
+   *
+   * Can be:
+   * - `string` or `function`: Shorthand for `{ name: string | function }`
+   * - `object`: Full configuration object
+   *
+   * @default '{{name}}Errors'
+   */
+  errors?: NameTransformer | {
+    /**
+     * Casing convention for generated names.
+     *
+     * @default 'PascalCase'
+     */
+    case?: Casing;
+    /**
+     * Naming pattern for generated names.
+     *
+     * @default '{{name}}Error'
+     */
+    error?: NameTransformer;
+    /**
+     * Naming pattern for generated names.
+     *
+     * @default '{{name}}Errors'
+     */
+    name?: NameTransformer;
+  };
+  /**
+   * Configuration for request-specific types.
+   *
+   * Controls generation of types for request bodies, query parameters, path
+   * parameters, and headers.
+   *
+   * Can be:
+   * - `string` or `function`: Shorthand for `{ name: string | function }`
+   * - `object`: Full configuration object
+   *
+   * @default '{{name}}Data'
+   */
+  requests?: NameTransformer | {
+    /**
+     * Casing convention for generated names.
+     *
+     * @default 'PascalCase'
+     */
+    case?: Casing;
+    /**
+     * Naming pattern for generated names.
+     *
+     * @default '{{name}}Data'
+     */
+    name?: NameTransformer;
+  };
+  /**
+   * Configuration for response-specific types.
+   *
+   * Controls generation of types for response bodies and status codes.
+   *
+   * Can be:
+   * - `string` or `function`: Shorthand for `{ name: string | function }`
+   * - `object`: Full configuration object
+   *
+   * @default '{{name}}Responses'
+   */
+  responses?: NameTransformer | {
+    /**
+     * Casing convention for generated names.
      *
      * @default 'PascalCase'
      */
@@ -4152,7 +4514,7 @@ type UserConfig$13 = Plugin$1.Name<'@hey-api/typescript'> & Plugin$1.Hooks & Plu
     payload?: NameTransformer;
   };
 };
-type Config$11 = Plugin$1.Name<'@hey-api/typescript'> & Plugin$1.Hooks & Plugin$1.Comments & Plugin$1.Exports & {
+type Config$11 = Plugin$1.Name<'@hey-api/typescript'> & Plugin$1.Hooks & Plugin$1.Comments & Plugin$1.Exports & Resolvers$2 & {
   /**
    * Casing convention for generated names.
    */
@@ -8020,8 +8382,7 @@ interface ValibotResult {
 /**
  * Finalized result after applyModifiers.
  */
-interface ValibotFinal {
-  pipes: Pipes;
+interface ValibotFinal extends Pick<ValibotResult, 'pipes'> {
   /** Type annotation for schemas requiring explicit typing (e.g., lazy). */
   typeName?: string | ts.Identifier;
 }
@@ -8048,6 +8409,22 @@ type GetIntegerLimit = (format: string | undefined) => IntegerLimit | undefined;
 //#endregion
 //#region src/plugins/valibot/resolvers.d.ts
 type Resolvers$1 = Plugin$1.Resolvers<{
+  /**
+   * Resolver for array schemas.
+   *
+   * Allows customization of how array types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  array?: (ctx: ArrayResolverContext$1) => PipeResult;
+  /**
+   * Resolver for boolean schemas.
+   *
+   * Allows customization of how boolean types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  boolean?: (ctx: BooleanResolverContext$1) => PipeResult;
   /**
    * Resolver for enum schemas.
    *
@@ -8056,6 +8433,30 @@ type Resolvers$1 = Plugin$1.Resolvers<{
    * Returning `undefined` will execute the default resolver logic.
    */
   enum?: (ctx: EnumResolverContext$1) => PipeResult;
+  /**
+   * Resolver for intersection schemas.
+   *
+   * Allows customization of how intersection types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  intersection?: (ctx: IntersectionResolverContext$1) => PipeResult;
+  /**
+   * Resolver for never schemas.
+   *
+   * Allows customization of how never types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  never?: (ctx: NeverResolverContext$1) => PipeResult;
+  /**
+   * Resolver for null schemas.
+   *
+   * Allows customization of how null types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  null?: (ctx: NullResolverContext$1) => PipeResult;
   /**
    * Resolver for number schemas.
    *
@@ -8080,6 +8481,38 @@ type Resolvers$1 = Plugin$1.Resolvers<{
    * Returning `undefined` will execute the default resolver logic.
    */
   string?: (ctx: StringResolverContext$1) => PipeResult;
+  /**
+   * Resolver for tuple schemas.
+   *
+   * Allows customization of how tuple types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  tuple?: (ctx: TupleResolverContext$1) => PipeResult;
+  /**
+   * Resolver for undefined schemas.
+   *
+   * Allows customization of how undefined types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  undefined?: (ctx: UndefinedResolverContext$1) => PipeResult;
+  /**
+   * Resolver for union schemas.
+   *
+   * Allows customization of how union types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  union?: (ctx: UnionResolverContext$1) => PipeResult;
+  /**
+   * Resolver for unknown schemas.
+   *
+   * Allows customization of how unknown types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  unknown?: (ctx: UnknownResolverContext$1) => PipeResult;
   /**
    * Resolvers for request and response validators.
    *
@@ -8103,6 +8536,14 @@ type Resolvers$1 = Plugin$1.Resolvers<{
      */
     response?: ValidatorResolver$1;
   };
+  /**
+   * Resolver for void schemas.
+   *
+   * Allows customization of how void types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  void?: (ctx: VoidResolverContext$1) => PipeResult;
 }>;
 type ValidatorResolver$1 = (ctx: ValidatorResolverContext$1) => PipeResult | null | undefined;
 interface BaseContext$1 extends DollarTsDsl {
@@ -8130,9 +8571,36 @@ interface BaseContext$1 extends DollarTsDsl {
     v: Symbol;
   };
 }
+interface ArrayResolverContext$1 extends BaseContext$1 {
+  applyModifiers: (result: ValibotResult, opts?: {
+    optional?: boolean;
+  }) => ValibotFinal;
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    base: (ctx: ArrayResolverContext$1) => PipeResult;
+    length: (ctx: ArrayResolverContext$1) => PipeResult;
+    maxLength: (ctx: ArrayResolverContext$1) => PipeResult;
+    minLength: (ctx: ArrayResolverContext$1) => PipeResult;
+  };
+  schema: SchemaWithType<'array'>;
+  walk: Walker<ValibotResult, ValibotPlugin['Instance']>;
+  walkerCtx: SchemaVisitorContext<ValibotPlugin['Instance']>;
+}
+interface BooleanResolverContext$1 extends BaseContext$1 {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    base: (ctx: BooleanResolverContext$1) => PipeResult;
+    const: (ctx: BooleanResolverContext$1) => PipeResult;
+  };
+  schema: SchemaWithType<'boolean'>;
+}
 interface EnumResolverContext$1 extends BaseContext$1 {
   /**
-   * Nodes used to build different parts of the schema.
+   * Nodes used to build different parts of the result.
    */
   nodes: {
     /**
@@ -8153,11 +8621,43 @@ interface EnumResolverContext$1 extends BaseContext$1 {
       isNullable: boolean;
     };
   };
-  schema: SchemaWithType<'enum'>;
+  schema: SchemaWithType<'enum'>;
+}
+interface IntersectionResolverContext$1 extends BaseContext$1 {
+  applyModifiers: (result: ValibotResult, opts?: {
+    optional?: boolean;
+  }) => ValibotFinal;
+  childResults: Array<ValibotResult>;
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    base: (ctx: IntersectionResolverContext$1) => PipeResult;
+  };
+  parentSchema: IR$1.SchemaObject;
+  schema: IR$1.SchemaObject;
+}
+interface NeverResolverContext$1 extends BaseContext$1 {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    base: (ctx: NeverResolverContext$1) => PipeResult;
+  };
+  schema: SchemaWithType<'never'>;
+}
+interface NullResolverContext$1 extends BaseContext$1 {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    base: (ctx: NullResolverContext$1) => PipeResult;
+  };
+  schema: SchemaWithType<'null'>;
 }
 interface NumberResolverContext$1 extends BaseContext$1 {
   /**
-   * Nodes used to build different parts of the schema.
+   * Nodes used to build different parts of the result.
    */
   nodes: {
     base: (ctx: NumberResolverContext$1) => PipeResult;
@@ -8181,7 +8681,7 @@ interface ObjectResolverContext$1 extends BaseContext$1 {
     optional?: boolean;
   }) => ValibotFinal;
   /**
-   * Nodes used to build different parts of the schema.
+   * Nodes used to build different parts of the result.
    */
   nodes: {
     additionalProperties: (ctx: ObjectResolverContext$1) => Pipe | null | undefined;
@@ -8189,20 +8689,12 @@ interface ObjectResolverContext$1 extends BaseContext$1 {
     shape: (ctx: ObjectResolverContext$1) => ReturnType<typeof $.object>;
   };
   schema: SchemaWithType<'object'>;
-  /**
-   * Utility functions for object schema processing.
-   */
-  utils: {
-    ast: Partial<{
-      hasLazy: boolean;
-    }>;
-  };
   walk: Walker<ValibotResult, ValibotPlugin['Instance']>;
   walkerCtx: SchemaVisitorContext<ValibotPlugin['Instance']>;
 }
 interface StringResolverContext$1 extends BaseContext$1 {
   /**
-   * Nodes used to build different parts of the schema.
+   * Nodes used to build different parts of the result.
    */
   nodes: {
     base: (ctx: StringResolverContext$1) => PipeResult;
@@ -8215,6 +8707,54 @@ interface StringResolverContext$1 extends BaseContext$1 {
   };
   schema: SchemaWithType<'string'>;
 }
+interface TupleResolverContext$1 extends BaseContext$1 {
+  applyModifiers: (result: ValibotResult, opts?: {
+    optional?: boolean;
+  }) => ValibotFinal;
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    base: (ctx: TupleResolverContext$1) => PipeResult;
+    const: (ctx: TupleResolverContext$1) => PipeResult;
+  };
+  schema: SchemaWithType<'tuple'>;
+  walk: Walker<ValibotResult, ValibotPlugin['Instance']>;
+  walkerCtx: SchemaVisitorContext<ValibotPlugin['Instance']>;
+}
+interface UndefinedResolverContext$1 extends BaseContext$1 {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    base: (ctx: UndefinedResolverContext$1) => PipeResult;
+  };
+  schema: SchemaWithType<'undefined'>;
+}
+interface UnionResolverContext$1 extends BaseContext$1 {
+  applyModifiers: (result: ValibotResult, opts?: {
+    optional?: boolean;
+  }) => ValibotFinal;
+  childResults: Array<ValibotResult>;
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    base: (ctx: UnionResolverContext$1) => PipeResult;
+  };
+  parentSchema: IR$1.SchemaObject;
+  schema: IR$1.SchemaObject;
+  schemas: ReadonlyArray<IR$1.SchemaObject>;
+}
+interface UnknownResolverContext$1 extends BaseContext$1 {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    base: (ctx: UnknownResolverContext$1) => PipeResult;
+  };
+  schema: SchemaWithType<'unknown'>;
+}
 interface ValidatorResolverContext$1 extends BaseContext$1 {
   operation: IR$1.OperationObject;
   /**
@@ -8224,6 +8764,15 @@ interface ValidatorResolverContext$1 extends BaseContext$1 {
     schema: Symbol;
   };
 }
+interface VoidResolverContext$1 extends BaseContext$1 {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    base: (ctx: VoidResolverContext$1) => PipeResult;
+  };
+  schema: SchemaWithType<'void'>;
+}
 //#endregion
 //#region src/plugins/valibot/types.d.ts
 type UserConfig$2 = Plugin$1.Name<'valibot'> & Plugin$1.Hooks & Plugin$1.UserComments & Plugin$1.UserExports & Resolvers$1 & {
@@ -8404,56 +8953,54 @@ type Config$1 = Plugin$1.Name<'valibot'> & Plugin$1.Hooks & Plugin$1.Comments &
 };
 type ValibotPlugin = DefinePlugin$1<UserConfig$2, Config$1, IApi$1>;
 //#endregion
+//#region src/plugins/zod/shared/chain.d.ts
+type Chain = ReturnType<typeof $.call | typeof $.expr>;
+type ChainResult = Chain | undefined;
+//#endregion
 //#region src/plugins/zod/shared/types.d.ts
-type Ast = {
-  anyType?: string;
-  expression: ReturnType<typeof $.expr | typeof $.call>;
-  hasLazyExpression?: boolean;
-  typeName?: string | ts.Identifier;
-};
-type IrSchemaToAstOptions = {
+type ValidatorArgs = {
+  operation: IR$1.OperationObject;
   /** The plugin instance. */
   plugin: ZodPlugin['Instance'];
-  /** The plugin state references. */
-  state: Refs<PluginState>;
-  walk: Walker<ZodSchemaResult, ZodPlugin['Instance']>;
-};
-type PluginState = Pick<Required<SymbolMeta>, 'path'> & Pick<Partial<SymbolMeta>, 'tags'> & {
-  anyType?: string;
-  hasLazyExpression: boolean;
 };
 type TypeOptions = {
-  /** Configuration for TypeScript type generation from Zod schemas. */
   types: {
-    /** Configuration for `infer` types. */
     infer: NamingOptions & FeatureToggle;
   };
 };
-type ValidatorArgs = {
-  operation: IR$1.OperationObject;
-  plugin: ZodPlugin['Instance'];
-};
 /**
- * The result from schema walking.
+ * Metadata that flows through schema walking.
  */
-interface ZodSchemaResult {
-  /** Default value from schema, if any. */
+interface ZodMeta {
+  /** Default value from schema. */
   default?: unknown;
-  /** The Zod expression AST. */
-  expression: {
-    expression: ReturnType<typeof $.expr | typeof $.call>;
-  };
-  /** The original schema format (for BigInt coercion). */
+  /** Original format (for BigInt coercion). */
   format?: string;
-  /** Whether any child contains a lazy expression. */
-  hasLazyExpression?: boolean;
-  /** Whether THIS result is itself lazy (not just inherited). */
-  isLazy?: boolean;
+  /** Whether this or any child contains a lazy reference. */
+  hasLazy: boolean;
+  /** Whether this schema itself is emitted as lazy. */
+  isLazy: boolean;
+  /** Whether this schema resolves to an object shape. */
+  isObject?: boolean;
   /** Does this schema explicitly allow null? */
   nullable: boolean;
   /** Is this schema read-only? */
   readonly: boolean;
 }
+/**
+ * Result from walking a schema node.
+ */
+interface ZodResult {
+  expression: Chain;
+  meta: ZodMeta;
+}
+/**
+ * Finalized result after applyModifiers.
+ */
+interface ZodFinal extends Pick<ZodResult, 'expression'> {
+  /** Type annotation for schemas requiring explicit typing (e.g., lazy). */
+  typeName?: string | ts.Identifier;
+}
 //#endregion
 //#region src/plugins/zod/api.d.ts
 type IApi = {
@@ -8461,11 +9008,24 @@ type IApi = {
   createResponseValidator: (args: ValidatorArgs) => ReturnType<typeof $.func> | undefined;
 };
 //#endregion
-//#region src/plugins/zod/shared/chain.d.ts
-type Chain = ReturnType<typeof $.call | typeof $.expr>;
-//#endregion
-//#region src/plugins/zod/resolvers/types.d.ts
+//#region src/plugins/zod/resolvers.d.ts
 type Resolvers = Plugin$1.Resolvers<{
+  /**
+   * Resolver for array schemas.
+   *
+   * Allows customization of how array types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  array?: (ctx: ArrayResolverContext) => ChainResult;
+  /**
+   * Resolver for boolean schemas.
+   *
+   * Allows customization of how boolean types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  boolean?: (ctx: BooleanResolverContext) => ChainResult;
   /**
    * Resolver for enum schemas.
    *
@@ -8473,7 +9033,31 @@ type Resolvers = Plugin$1.Resolvers<{
    *
    * Returning `undefined` will execute the default resolver logic.
    */
-  enum?: (ctx: EnumResolverContext) => Chain | undefined;
+  enum?: (ctx: EnumResolverContext) => ChainResult;
+  /**
+   * Resolver for intersection schemas.
+   *
+   * Allows customization of how intersection types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  intersection?: (ctx: IntersectionResolverContext) => ChainResult;
+  /**
+   * Resolver for never schemas.
+   *
+   * Allows customization of how never types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  never?: (ctx: NeverResolverContext) => ChainResult;
+  /**
+   * Resolver for null schemas.
+   *
+   * Allows customization of how null types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  null?: (ctx: NullResolverContext) => ChainResult;
   /**
    * Resolver for number schemas.
    *
@@ -8481,7 +9065,7 @@ type Resolvers = Plugin$1.Resolvers<{
    *
    * Returning `undefined` will execute the default resolver logic.
    */
-  number?: (ctx: NumberResolverContext) => Chain | undefined;
+  number?: (ctx: NumberResolverContext) => ChainResult;
   /**
    * Resolver for object schemas.
    *
@@ -8489,7 +9073,7 @@ type Resolvers = Plugin$1.Resolvers<{
    *
    * Returning `undefined` will execute the default resolver logic.
    */
-  object?: (ctx: ObjectResolverContext) => Chain | undefined;
+  object?: (ctx: ObjectResolverContext) => ChainResult;
   /**
    * Resolver for string schemas.
    *
@@ -8497,7 +9081,39 @@ type Resolvers = Plugin$1.Resolvers<{
    *
    * Returning `undefined` will execute the default resolver logic.
    */
-  string?: (ctx: StringResolverContext) => Chain | undefined;
+  string?: (ctx: StringResolverContext) => ChainResult;
+  /**
+   * Resolver for tuple schemas.
+   *
+   * Allows customization of how tuple types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  tuple?: (ctx: TupleResolverContext) => ChainResult;
+  /**
+   * Resolver for undefined schemas.
+   *
+   * Allows customization of how undefined types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  undefined?: (ctx: UndefinedResolverContext) => ChainResult;
+  /**
+   * Resolver for union schemas.
+   *
+   * Allows customization of how union types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  union?: (ctx: UnionResolverContext) => ChainResult;
+  /**
+   * Resolver for unknown schemas.
+   *
+   * Allows customization of how unknown types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  unknown?: (ctx: UnknownResolverContext) => ChainResult;
   /**
    * Resolvers for request and response validators.
    *
@@ -8521,9 +9137,17 @@ type Resolvers = Plugin$1.Resolvers<{
      */
     response?: ValidatorResolver;
   };
+  /**
+   * Resolver for void schemas.
+   *
+   * Allows customization of how void types are rendered.
+   *
+   * Returning `undefined` will execute the default resolver logic.
+   */
+  void?: (ctx: VoidResolverContext) => ChainResult;
 }>;
 type ValidatorResolver = (ctx: ValidatorResolverContext) => MaybeArray<TsDsl<ts.Statement>> | null | undefined;
-type BaseContext = DollarTsDsl & Pick<IrSchemaToAstOptions, 'plugin'> & {
+interface BaseContext extends DollarTsDsl {
   /**
    * Functions for working with chains.
    */
@@ -8531,28 +9155,79 @@ type BaseContext = DollarTsDsl & Pick<IrSchemaToAstOptions, 'plugin'> & {
     /**
      * The current chain.
      *
-     * In Zod, this represents a chain of call expressions ("chains")
-     * being assembled to form a schema definition.
+     * In Zod, this represents a chain of method calls being assembled
+     * to form a schema definition (e.g., `z.string().min(1).max(10)`).
      *
-     * Each chain can be extended, modified, or replaced to customize
+     * Each method can be extended, modified, or replaced to customize
      * the resulting schema.
      */
     current: Chain;
   };
+  /** The plugin instance. */
+  plugin: ZodPlugin['Instance'];
   /**
    * Provides access to commonly used symbols within the plugin.
    */
   symbols: {
     z: Symbol;
   };
-};
+}
+interface ArrayResolverContext extends BaseContext {
+  applyModifiers: (result: ZodResult, opts?: {
+    optional?: boolean;
+  }) => ZodFinal;
+  /**
+   * Child results from processing array items.
+   */
+  childResults: Array<ZodResult>;
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base array expression (z.array(...)).
+     */
+    base: (ctx: ArrayResolverContext) => Chain;
+    /**
+     * Returns a length constraint (when minItems === maxItems), if applicable.
+     */
+    length: (ctx: ArrayResolverContext) => ChainResult;
+    /**
+     * Returns a maxItems constraint, if applicable.
+     */
+    maxLength: (ctx: ArrayResolverContext) => ChainResult;
+    /**
+     * Returns a minItems constraint, if applicable.
+     */
+    minLength: (ctx: ArrayResolverContext) => ChainResult;
+  };
+  schema: SchemaWithType<'array'>;
+  walk: Walker<ZodResult, ZodPlugin['Instance']>;
+  walkerCtx: SchemaVisitorContext<ZodPlugin['Instance']>;
+}
+interface BooleanResolverContext extends BaseContext {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base boolean expression (z.boolean()).
+     */
+    base: (ctx: BooleanResolverContext) => Chain;
+    /**
+     * Returns a literal expression for the const value, if present.
+     */
+    const: (ctx: BooleanResolverContext) => ChainResult;
+  };
+  schema: SchemaWithType<'boolean'>;
+}
 interface EnumResolverContext extends BaseContext {
   /**
-   * Nodes used to build different parts of the enum schema.
+   * Nodes used to build different parts of the result.
    */
   nodes: {
     /**
-     * Returns the base enum expression (z.enum([...]) or z.union([...]) for mixed types).
+     * Returns the base enum expression (z.enum([...]) or z.union([...])).
      */
     base: (ctx: EnumResolverContext) => Chain;
     /**
@@ -8560,7 +9235,7 @@ interface EnumResolverContext extends BaseContext {
      */
     items: (ctx: EnumResolverContext) => {
       /**
-       * Whether all enum items are strings (determines if z.enum can be used).
+       * Whether all enum members are strings.
        */
       allStrings: boolean;
       /**
@@ -8572,84 +9247,214 @@ interface EnumResolverContext extends BaseContext {
        */
       isNullable: boolean;
       /**
-       * z.literal(...) expressions for each non-null enum value.
+       * Zod literal expressions for each enum member.
        */
       literalMembers: Array<Chain>;
     };
   };
   schema: SchemaWithType<'enum'>;
+}
+interface IntersectionResolverContext extends BaseContext {
+  childResults: Array<ZodResult>;
   /**
-   * Utility functions for enum schema processing.
+   * Nodes used to build different parts of the result.
    */
-  utils: {
-    ast: Partial<Omit<Ast, 'typeName'>>;
-    state: Refs<PluginState>;
+  nodes: {
+    /**
+     * Returns the base intersection expression.
+     */
+    base: (ctx: IntersectionResolverContext) => Chain;
+  };
+  parentSchema: IR$1.SchemaObject;
+  schema: IR$1.SchemaObject;
+  walk: Walker<ZodResult, ZodPlugin['Instance']>;
+  walkerCtx: SchemaVisitorContext<ZodPlugin['Instance']>;
+}
+interface NeverResolverContext extends BaseContext {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base never expression (z.never()).
+     */
+    base: (ctx: NeverResolverContext) => Chain;
   };
+  schema: SchemaWithType<'never'>;
+}
+interface NullResolverContext extends BaseContext {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base null expression (z.null()).
+     */
+    base: (ctx: NullResolverContext) => Chain;
+  };
+  schema: SchemaWithType<'null'>;
 }
 interface NumberResolverContext extends BaseContext {
   /**
-   * Nodes used to build different parts of the number schema.
+   * Nodes used to build different parts of the result.
    */
   nodes: {
+    /**
+     * Returns the base number expression (z.number() or z.coerce.number()).
+     */
     base: (ctx: NumberResolverContext) => Chain;
-    const: (ctx: NumberResolverContext) => Chain | undefined;
-    max: (ctx: NumberResolverContext) => Chain | undefined;
-    min: (ctx: NumberResolverContext) => Chain | undefined;
+    /**
+     * Returns a literal expression for the const value, if present.
+     */
+    const: (ctx: NumberResolverContext) => ChainResult;
+    /**
+     * Returns the maximum value constraint.
+     */
+    max: (ctx: NumberResolverContext) => ChainResult;
+    /**
+     * Returns the minimum value constraint.
+     */
+    min: (ctx: NumberResolverContext) => ChainResult;
   };
   schema: SchemaWithType<'integer' | 'number'>;
   /**
    * Utility functions for number schema processing.
    */
   utils: {
-    ast: Partial<Omit<Ast, 'typeName'>>;
     getIntegerLimit: GetIntegerLimit;
     maybeBigInt: MaybeBigInt;
     shouldCoerceToBigInt: ShouldCoerceToBigInt;
-    state: Refs<PluginState>;
   };
 }
 interface ObjectResolverContext extends BaseContext {
-  applyModifiers: (result: ZodSchemaResult, opts: {
+  /**
+   * Child results from processing object properties.
+   * Used for metadata composition.
+   */
+  _childResults: Array<ZodResult>;
+  applyModifiers: (result: ZodResult, opts: {
     optional?: boolean;
-  }) => Ast;
+  }) => ZodFinal;
   /**
-   * Nodes used to build different parts of the object schema.
+   * Nodes used to build different parts of the result.
    */
   nodes: {
     /**
-     * If `additionalProperties` is `false` or `{ type: 'never' }`, returns `null`
-     * to indicate no additional properties are allowed.
+     * Returns the additional properties expression, if any.
      */
     additionalProperties: (ctx: ObjectResolverContext) => Chain | null | undefined;
+    /**
+     * Returns the base object expression (z.object({...}) or z.record(...)).
+     */
     base: (ctx: ObjectResolverContext) => Chain;
+    /**
+     * Returns the object shape (property definitions).
+     */
     shape: (ctx: ObjectResolverContext) => ReturnType<typeof $.object>;
   };
   schema: SchemaWithType<'object'>;
-  /**
-   * Utility functions for object schema processing.
-   */
-  utils: {
-    ast: Partial<Omit<Ast, 'typeName'>>;
-    state: Refs<PluginState>;
-  };
-  walk: Walker<ZodSchemaResult, ZodPlugin['Instance']>;
+  walk: Walker<ZodResult, ZodPlugin['Instance']>;
   walkerCtx: SchemaVisitorContext<ZodPlugin['Instance']>;
 }
 interface StringResolverContext extends BaseContext {
   /**
-   * Nodes used to build different parts of the string schema.
+   * Nodes used to build different parts of the result.
    */
   nodes: {
+    /**
+     * Returns the base string expression (z.string()).
+     */
     base: (ctx: StringResolverContext) => Chain;
-    const: (ctx: StringResolverContext) => Chain | undefined;
-    format: (ctx: StringResolverContext) => Chain | undefined;
-    length: (ctx: StringResolverContext) => Chain | undefined;
-    maxLength: (ctx: StringResolverContext) => Chain | undefined;
-    minLength: (ctx: StringResolverContext) => Chain | undefined;
-    pattern: (ctx: StringResolverContext) => Chain | undefined;
+    /**
+     * Returns a literal expression for the const value, if present.
+     */
+    const: (ctx: StringResolverContext) => ChainResult;
+    /**
+     * Returns a format validation expression, if applicable.
+     */
+    format: (ctx: StringResolverContext) => ChainResult;
+    /**
+     * Returns a length constraint (when min === max), if applicable.
+     */
+    length: (ctx: StringResolverContext) => ChainResult;
+    /**
+     * Returns a maxLength constraint, if applicable.
+     */
+    maxLength: (ctx: StringResolverContext) => ChainResult;
+    /**
+     * Returns a minLength constraint, if applicable.
+     */
+    minLength: (ctx: StringResolverContext) => ChainResult;
+    /**
+     * Returns a pattern (regex) constraint, if applicable.
+     */
+    pattern: (ctx: StringResolverContext) => ChainResult;
   };
   schema: SchemaWithType<'string'>;
 }
+interface TupleResolverContext extends BaseContext {
+  applyModifiers: (result: ZodResult, opts?: {
+    optional?: boolean;
+  }) => ZodFinal;
+  childResults: Array<ZodResult>;
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base tuple expression (z.tuple([...])).
+     */
+    base: (ctx: TupleResolverContext) => Chain;
+    /**
+     * Returns a literal expression for the const value, if present.
+     */
+    const: (ctx: TupleResolverContext) => ChainResult;
+  };
+  schema: SchemaWithType<'tuple'>;
+  walk: Walker<ZodResult, ZodPlugin['Instance']>;
+  walkerCtx: SchemaVisitorContext<ZodPlugin['Instance']>;
+}
+interface UndefinedResolverContext extends BaseContext {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base undefined expression (z.undefined()).
+     */
+    base: (ctx: UndefinedResolverContext) => Chain;
+  };
+  schema: SchemaWithType<'undefined'>;
+}
+interface UnionResolverContext extends BaseContext {
+  childResults: Array<ZodResult>;
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base union expression.
+     */
+    base: (ctx: UnionResolverContext) => Chain;
+  };
+  parentSchema: IR$1.SchemaObject;
+  schema: IR$1.SchemaObject;
+  schemas: ReadonlyArray<IR$1.SchemaObject>;
+  walk: Walker<ZodResult, ZodPlugin['Instance']>;
+  walkerCtx: SchemaVisitorContext<ZodPlugin['Instance']>;
+}
+interface UnknownResolverContext extends BaseContext {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base unknown expression (z.unknown()).
+     */
+    base: (ctx: UnknownResolverContext) => Chain;
+  };
+  schema: SchemaWithType<'unknown'>;
+}
 interface ValidatorResolverContext extends BaseContext {
   operation: IR$1.OperationObject;
   /**
@@ -8659,6 +9464,18 @@ interface ValidatorResolverContext extends BaseContext {
     schema: Symbol;
   };
 }
+interface VoidResolverContext extends BaseContext {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the base void expression (z.void()).
+     */
+    base: (ctx: VoidResolverContext) => Chain;
+  };
+  schema: SchemaWithType<'void'>;
+}
 //#endregion
 //#region src/plugins/zod/types.d.ts
 type UserConfig$1 = Plugin$1.Name<'zod'> & Plugin$1.Hooks & Plugin$1.UserComments & Plugin$1.UserExports & Resolvers & {