@hey-api/openapi-ts 0.94.4 → 0.95.0

package/dist/index.d.mts

@@ -1,7 +1,6 @@
 import { n as UserConfig } from "./types-DAEl4_a4.mjs";
-import * as _hey_api_codegen_core0 from "@hey-api/codegen-core";
 import { AnalysisContext, BindingKind, ExportModule, File, FromRef, ImportModule, Language, Logger, Logger as Logger$1, Node, NodeName, NodeNameSanitizer, NodeRelationship, NodeScope, Ref, RenderContext, Renderer, Symbol } from "@hey-api/codegen-core";
-import { BaseOutput, 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 { BaseOutput, Casing, Context, DefinePlugin, DefinePlugin as DefinePlugin$1, FeatureToggle, IR, IR as IR$1, NameTransformer, NamingConfig, NamingOptions, NamingRule, OpenApi, OpenApiMetaObject, OpenApiOperationObject, OpenApiParameterObject, OpenApiRequestBodyObject, OpenApiResponseObject, OpenApiSchemaObject, OperationPath, OperationPathStrategy, OperationStrategy, OperationsStrategy, Plugin, Plugin as Plugin$1, RequestSchemaContext, ResolvedRequestValidatorLayer, 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";
@@ -11,6 +10,7 @@ import { AsyncDataOptions, UseFetchOptions, useAsyncData, useFetch, useLazyAsync
 import { Ref as Ref$1 } from "vue";
 import { FetchOptions, ResponseType, ofetch } from "ofetch";
 import ky, { Options } from "ky";
+import { LinguistLanguages, OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from "@hey-api/spec-types";
 
 //#region src/plugins/@angular/common/httpRequests/types.d.ts
 interface UserHttpRequestsConfig {
@@ -409,15 +409,271 @@ type Arg$1 = NodeName | MaybeTsDsl<TypeTsDsl>;
 interface TypeArgsMethods extends Node {
   /** Returns the type arguments as an array of ts.TypeNode nodes. */
   $generics(): ReadonlyArray<ts.TypeNode> | undefined;
-  /** Adds a single type argument (e.g. `string` in `Foo<string>`). */
+  /** Adds a single type argument (e.g., `string` in `Foo<string>`). */
   generic(arg: Arg$1): this;
-  /** Adds type arguments (e.g. `Map<string, number>`). */
+  /** Adds type arguments (e.g., `Map<string, number>`). */
   generics(...args: ReadonlyArray<Arg$1>): this;
 }
 //#endregion
+//#region src/ts-dsl/mixins/type-returns.d.ts
+interface TypeReturnsMethods extends Node {
+  /** Returns the return type node. */
+  $returns(): ts.TypeNode | undefined;
+  /** Sets the return type. */
+  returns(type: NodeName | TypeTsDsl): this;
+}
+//#endregion
+//#region src/ts-dsl/type/param.d.ts
+type TypeParamExpr = NodeName | boolean | MaybeTsDsl<TypeTsDsl>;
+declare const Mixed$56: abstract new () => TsDsl<ts.TypeParameterDeclaration>;
+declare class TypeParamTsDsl extends Mixed$56 {
+  readonly '~dsl' = "TypeParamTsDsl";
+  scope: NodeScope;
+  protected constraint?: Ref<TypeParamExpr>;
+  protected defaultValue?: Ref<TypeParamExpr>;
+  constructor(name?: NodeName, fn?: (name: TypeParamTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
+  /** Sets the parameter default value. */
+  default(value: TypeParamExpr): this;
+  extends(constraint: TypeParamExpr): this;
+  toAst(): ts.TypeParameterDeclaration;
+}
+//#endregion
+//#region src/ts-dsl/mixins/type-params.d.ts
+interface TypeParamsMethods extends Node {
+  /** Returns the type parameters as an array of ts.TypeParameterDeclaration nodes. */
+  $generics(): ReadonlyArray<ts.TypeParameterDeclaration> | undefined;
+  /** Adds a single type parameter (e.g., `T` in `Array<T>`). */
+  generic(...args: ConstructorParameters<typeof TypeParamTsDsl>): this;
+  /** Adds type parameters (e.g., `Map<string, T>`). */
+  generics(...args: ReadonlyArray<NodeName | MaybeTsDsl<TypeParamTsDsl>>): this;
+}
+//#endregion
+//#region src/ts-dsl/mixins/modifiers.d.ts
+type Modifiers = {
+  /**
+   * Checks if the specified modifier is present.
+   *
+   * @param modifier - The modifier to check.
+   * @returns True if the modifier is present, false otherwise.
+   */
+  hasModifier(modifier: Modifier): boolean;
+  modifiers: Array<ts.Modifier>;
+};
+type Modifier = 'abstract' | 'async' | 'const' | 'declare' | 'default' | 'export' | 'override' | 'private' | 'protected' | 'public' | 'readonly' | 'static';
+interface AbstractMethods extends Modifiers {
+  /**
+   * Adds the `abstract` keyword modifier if the condition is true.
+   *
+   * @param condition - Whether to add the modifier (default: true).
+   * @returns The target object for chaining.
+   */
+  abstract(condition?: boolean): this;
+}
+interface AsyncMethods extends Modifiers {
+  /**
+   * Adds the `async` keyword modifier if the condition is true.
+   *
+   * @param condition - Whether to add the modifier (default: true).
+   * @returns The target object for chaining.
+   */
+  async(condition?: boolean): this;
+}
+interface ConstMethods extends Modifiers {
+  /**
+   * Adds the `const` keyword modifier if the condition is true.
+   *
+   * @param condition - Whether to add the modifier (default: true).
+   * @returns The target object for chaining.
+   */
+  const(condition?: boolean): this;
+}
+interface DefaultMethods extends Modifiers {
+  /**
+   * Adds the `default` keyword modifier if the condition is true.
+   *
+   * @param condition - Whether to add the modifier (default: true).
+   * @returns The target object for chaining.
+   */
+  default(condition?: boolean): this;
+}
+interface ExportMethods extends Modifiers {
+  /**
+   * Adds the `export` keyword modifier if the condition is true.
+   *
+   * @param condition - Whether to add the modifier (default: true).
+   * @returns The target object for chaining.
+   */
+  export(condition?: boolean): this;
+}
+interface PrivateMethods extends Modifiers {
+  /**
+   * Adds the `private` keyword modifier if the condition is true.
+   *
+   * @param condition - Whether to add the modifier (default: true).
+   * @returns The target object for chaining.
+   */
+  private(condition?: boolean): this;
+}
+interface ProtectedMethods extends Modifiers {
+  /**
+   * Adds the `protected` keyword modifier if the condition is true.
+   *
+   * @param condition - Whether to add the modifier (default: true).
+   * @returns The target object for chaining.
+   */
+  protected(condition?: boolean): this;
+}
+interface PublicMethods extends Modifiers {
+  /**
+   * Adds the `public` keyword modifier if the condition is true.
+   *
+   * @param condition - Whether to add the modifier (default: true).
+   * @returns The target object for chaining.
+   */
+  public(condition?: boolean): this;
+}
+interface ReadonlyMethods extends Modifiers {
+  /**
+   * Adds the `readonly` keyword modifier if the condition is true.
+   *
+   * @param condition - Whether to add the modifier (default: true).
+   * @returns The target object for chaining.
+   */
+  readonly(condition?: boolean): this;
+}
+interface StaticMethods extends Modifiers {
+  /**
+   * Adds the `static` keyword modifier if the condition is true.
+   *
+   * @param condition - Whether to add the modifier (default: true).
+   * @returns The target object for chaining.
+   */
+  static(condition?: boolean): 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/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/optional.d.ts
+interface OptionalMethods extends Node {
+  _optional?: boolean;
+  /** Marks the node as optional when the condition is true. */
+  optional(condition?: boolean): this;
+  /** Marks the node as required when the condition is true. */
+  required(condition?: boolean): 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 | MaybeTsDsl<ts.Expression>, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>): this;
+}
+//#endregion
+//#region src/ts-dsl/decl/param.d.ts
+type ParamName = NodeName | ParamFn;
+type ParamFn = (p: ParamTsDsl) => void;
+type ParamCtor = (name: ParamName, fn?: ParamFn) => ParamTsDsl;
+declare const Mixed$55: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ParameterDeclaration>, ValueMethods>, PatternMethods>, OptionalMethods>, DecoratorMethods>;
+declare class ParamTsDsl extends Mixed$55 {
+  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(node: NodeName | 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. */
+  $params(): ReadonlyArray<ts.ParameterDeclaration>;
+  /** Adds a parameter. */
+  param(...args: Parameters<ParamCtor>): this;
+  /** Adds multiple parameters. */
+  params(...params: ReadonlyArray<MaybeTsDsl<ts.ParameterDeclaration>>): this;
+}
+//#endregion
+//#region src/ts-dsl/layout/doc.d.ts
+type DocMaybeLazy<T> = ((ctx: TsDslContext) => T) | T;
+type DocFn = (d: DocTsDsl) => void;
+type DocLines = DocMaybeLazy<MaybeArray<string>>;
+declare class DocTsDsl extends TsDsl<ts.Node> {
+  readonly '~dsl' = "DocTsDsl";
+  protected _lines: Array<DocLines>;
+  constructor(lines?: DocLines, fn?: DocFn);
+  analyze(ctx: AnalysisContext): void;
+  add(lines: DocLines): this;
+  apply<T extends ts.Node>(node: T): T;
+  toAst(): ts.Identifier;
+}
+//#endregion
+//#region src/ts-dsl/mixins/doc.d.ts
+interface DocMethods extends Node {
+  $docs<T extends ts.Node>(node: T): T;
+  doc(lines?: DocLines, fn?: DocFn): this;
+}
+//#endregion
+//#region src/ts-dsl/mixins/do.d.ts
+type DoExpr = MaybeTsDsl<ts.Expression | ts.Statement>;
+interface DoMethods extends Node {
+  /** Renders the collected `.do()` calls into an array of `Statement` nodes. */
+  $do(): ReadonlyArray<ts.Statement>;
+  _do: Array<DoExpr>;
+  /** Adds one or more expressions/statements to the body. */
+  do(...items: ReadonlyArray<DoExpr>): this;
+}
+//#endregion
+//#region src/ts-dsl/decl/method.d.ts
+type MethodCtor = (name: NodeName, fn?: (m: MethodTsDsl) => void) => MethodTsDsl;
+declare const Mixed$54: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.MethodDeclaration>, TypeReturnsMethods>, TypeParamsMethods>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, OptionalMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AbstractMethods>;
+declare class MethodTsDsl extends Mixed$54 {
+  readonly '~dsl' = "MethodTsDsl";
+  readonly nameSanitizer: (name: string) => string;
+  constructor(name: NodeName, fn?: (m: MethodTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.MethodDeclaration;
+}
+//#endregion
+//#region src/ts-dsl/mixins/expr.d.ts
+interface ExprMethods extends Node {
+  /** Accesses a property on the current expression (e.g., `this.foo`). */
+  attr(...args: DropFirst<Parameters<typeof f.attr>>): ReturnType<typeof f.attr>;
+  /** Awaits the current expression (e.g., `await expr`). */
+  await(): ReturnType<typeof f.await>;
+  /** Calls the current expression (e.g., `fn(arg1, arg2)`). */
+  call(...args: DropFirst<Parameters<typeof f.call>>): ReturnType<typeof f.call>;
+  /** Produces a `return` statement returning the current expression. */
+  return(): ReturnType<typeof f.return>;
+}
+//#endregion
 //#region src/ts-dsl/mixins/as.d.ts
 interface AsMethods extends Node {
-  /** Creates an `as` type assertion expression (e.g. `value as Type`). */
+  /** Creates an `as` type assertion expression (e.g., `value as Type`). */
   as(...args: DropFirst<Parameters<typeof f.as>>): ReturnType<typeof f.as>;
 }
 //#endregion
@@ -425,8 +681,8 @@ interface AsMethods extends Node {
 type AsExpr = NodeName | MaybeTsDsl<ts.Expression>;
 type AsType = NodeName | TypeTsDsl;
 type AsCtor = (expr: AsExpr, type: AsType) => AsTsDsl;
-declare const Mixed$52: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.AsExpression>, ExprMethods>, AsMethods>;
-declare class AsTsDsl extends Mixed$52 {
+declare const Mixed$53: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.AsExpression>, ExprMethods>, AsMethods>;
+declare class AsTsDsl extends Mixed$53 {
   readonly '~dsl' = "AsTsDsl";
   protected expr: Ref<AsExpr>;
   protected type: Ref<AsType>;
@@ -435,66 +691,57 @@ declare class AsTsDsl extends Mixed$52 {
   toAst(): ts.AsExpression;
 }
 //#endregion
-//#region src/ts-dsl/mixins/optional.d.ts
-interface OptionalMethods extends Node {
-  _optional?: boolean;
-  /** Marks the node as optional when the condition is true. */
-  optional(condition?: boolean): this;
-  /** Marks the node as required when the condition is true. */
-  required(condition?: boolean): this;
-}
-//#endregion
 //#region src/ts-dsl/expr/binary.d.ts
-type Expr$3 = NodeName | MaybeTsDsl<ts.Expression>;
+type Expr$2 = NodeName | MaybeTsDsl<ts.Expression>;
 type Op$1 = Operator | ts.BinaryOperator;
 type Operator = '!=' | '!==' | '&&' | '*' | '+' | '-' | '/' | '<' | '<=' | '=' | '==' | '===' | '>' | '>=' | '??' | '??=' | '||';
-declare const Mixed$51: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.BinaryExpression>, ExprMethods>, AsMethods>;
-declare class BinaryTsDsl extends Mixed$51 {
+declare const Mixed$52: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.BinaryExpression>, ExprMethods>, AsMethods>;
+declare class BinaryTsDsl extends Mixed$52 {
   readonly '~dsl' = "BinaryTsDsl";
-  protected _base: Ref<Expr$3>;
-  protected _expr?: Ref<Expr$3>;
+  protected _base: Ref<Expr$2>;
+  protected _expr?: Ref<Expr$2>;
   protected _op?: Op$1;
-  constructor(base: Expr$3, op?: Op$1, expr?: Expr$3);
+  constructor(base: Expr$2, op?: Op$1, expr?: Expr$2);
   analyze(ctx: AnalysisContext): void;
   /** Returns true when all required builder calls are present. */
   get isValid(): boolean;
   /** Logical AND — `this && expr` */
-  and(expr: Expr$3): this;
-  /** Creates an assignment expression (e.g. `this = expr`). */
-  assign(expr: Expr$3): this;
+  and(expr: Expr$2): this;
+  /** Creates an assignment expression (e.g., `this = expr`). */
+  assign(expr: Expr$2): this;
   /** Nullish coalescing — `this ?? expr` */
-  coalesce(expr: Expr$3): this;
+  coalesce(expr: Expr$2): this;
   /** Division — `this / expr` */
-  div(expr: Expr$3): this;
+  div(expr: Expr$2): this;
   /** Strict equality — `this === expr` */
-  eq(expr: Expr$3): this;
+  eq(expr: Expr$2): this;
   /** Greater than — `this > expr` */
-  gt(expr: Expr$3): this;
+  gt(expr: Expr$2): this;
   /** Greater than or equal — `this >= expr` */
-  gte(expr: Expr$3): this;
+  gte(expr: Expr$2): this;
   /** Loose equality — `this == expr` */
-  looseEq(expr: Expr$3): this;
+  looseEq(expr: Expr$2): this;
   /** Loose inequality — `this != expr` */
-  looseNeq(expr: Expr$3): this;
+  looseNeq(expr: Expr$2): this;
   /** Less than — `this < expr` */
-  lt(expr: Expr$3): this;
+  lt(expr: Expr$2): this;
   /** Less than or equal — `this <= expr` */
-  lte(expr: Expr$3): this;
+  lte(expr: Expr$2): this;
   /** Subtraction — `this - expr` */
-  minus(expr: Expr$3): this;
+  minus(expr: Expr$2): this;
   /** Strict inequality — `this !== expr` */
-  neq(expr: Expr$3): this;
+  neq(expr: Expr$2): this;
   /** Nullish assignment — `this ??= expr` */
-  nullishAssign(expr: Expr$3): this;
+  nullishAssign(expr: Expr$2): this;
   /** Logical OR — `this || expr` */
-  or(expr: Expr$3): this;
+  or(expr: Expr$2): this;
   /** Addition — `this + expr` */
-  plus(expr: Expr$3): this;
+  plus(expr: Expr$2): this;
   /** Multiplication — `this * expr` */
-  times(expr: Expr$3): this;
+  times(expr: Expr$2): this;
   toAst(): ts.BinaryExpression;
   $validate(): asserts this is this & {
-    _expr: Ref<Expr$3>;
+    _expr: Ref<Expr$2>;
     _op: Op$1;
   };
   private missingRequiredCalls;
@@ -504,61 +751,64 @@ declare class BinaryTsDsl extends Mixed$51 {
 }
 //#endregion
 //#region src/ts-dsl/mixins/operator.d.ts
-type Expr$2 = NodeName | MaybeTsDsl<ts.Expression>;
+type Expr$1 = NodeName | MaybeTsDsl<ts.Expression>;
 interface OperatorMethods extends Node {
   /** Logical AND — `this && expr` */
-  and(expr: Expr$2): BinaryTsDsl;
-  /** Creates an assignment expression (e.g. `this = expr`). */
-  assign(expr: Expr$2): BinaryTsDsl;
+  and(expr: Expr$1): BinaryTsDsl;
+  /** Creates an assignment expression (e.g., `this = expr`). */
+  assign(expr: Expr$1): BinaryTsDsl;
   /** Nullish coalescing — `this ?? expr` */
-  coalesce(expr: Expr$2): BinaryTsDsl;
+  coalesce(expr: Expr$1): BinaryTsDsl;
   /** Division — `this / expr` */
-  div(expr: Expr$2): BinaryTsDsl;
+  div(expr: Expr$1): BinaryTsDsl;
   /** Strict equality — `this === expr` */
-  eq(expr: Expr$2): BinaryTsDsl;
+  eq(expr: Expr$1): BinaryTsDsl;
   /** Greater than — `this > expr` */
-  gt(expr: Expr$2): BinaryTsDsl;
+  gt(expr: Expr$1): BinaryTsDsl;
   /** Greater than or equal — `this >= expr` */
-  gte(expr: Expr$2): BinaryTsDsl;
+  gte(expr: Expr$1): BinaryTsDsl;
   /** Loose equality — `this == expr` */
-  looseEq(expr: Expr$2): BinaryTsDsl;
+  looseEq(expr: Expr$1): BinaryTsDsl;
   /** Loose inequality — `this != expr` */
-  looseNeq(expr: Expr$2): BinaryTsDsl;
+  looseNeq(expr: Expr$1): BinaryTsDsl;
   /** Less than — `this < expr` */
-  lt(expr: Expr$2): BinaryTsDsl;
+  lt(expr: Expr$1): BinaryTsDsl;
   /** Less than or equal — `this <= expr` */
-  lte(expr: Expr$2): BinaryTsDsl;
+  lte(expr: Expr$1): BinaryTsDsl;
   /** Subtraction — `this - expr` */
-  minus(expr: Expr$2): BinaryTsDsl;
+  minus(expr: Expr$1): BinaryTsDsl;
   /** Strict inequality — `this !== expr` */
-  neq(expr: Expr$2): BinaryTsDsl;
+  neq(expr: Expr$1): BinaryTsDsl;
   /** Nullish assignment — `this ??= expr` */
-  nullishAssign(expr: Expr$2): BinaryTsDsl;
+  nullishAssign(expr: Expr$1): BinaryTsDsl;
   /** Logical OR — `this || expr` */
-  or(expr: Expr$2): BinaryTsDsl;
+  or(expr: Expr$1): BinaryTsDsl;
   /** Addition — `this + expr` */
-  plus(expr: Expr$2): BinaryTsDsl;
+  plus(expr: Expr$1): BinaryTsDsl;
   /** Multiplication — `this * expr` */
-  times(expr: Expr$2): BinaryTsDsl;
+  times(expr: Expr$1): BinaryTsDsl;
 }
 //#endregion
 //#region src/ts-dsl/expr/attr.d.ts
 type AttrLeft = NodeName | MaybeTsDsl<ts.Expression>;
 type AttrCtor = (left: AttrLeft, right: NodeName) => AttrTsDsl;
-declare const Mixed$50: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.PropertyAccessExpression | ts.ElementAccessExpression>, OptionalMethods>, OperatorMethods>, ExprMethods>, AsMethods>;
-declare class AttrTsDsl extends Mixed$50 {
+declare const Mixed$51: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.PropertyAccessExpression | ts.ElementAccessExpression>, SpreadMethods>, OptionalMethods>, OperatorMethods>, ExprMethods>, AsMethods>;
+declare class AttrTsDsl extends Mixed$51 {
   readonly '~dsl' = "AttrTsDsl";
-  protected left: Ref<AttrLeft>;
+  protected _computed: boolean;
+  protected _left: Ref<AttrLeft>;
   constructor(left: AttrLeft, right: NodeName);
   analyze(ctx: AnalysisContext): void;
+  /** Use computed property access (e.g., `obj[expr]`)? */
+  computed(condition?: boolean): this;
   toAst(): ts.PropertyAccessExpression | ts.ElementAccessExpression;
 }
 //#endregion
 //#region src/ts-dsl/expr/await.d.ts
 type AwaitExpr = NodeName | MaybeTsDsl<ts.Expression>;
 type AwaitCtor = (expr: AwaitExpr) => AwaitTsDsl;
-declare const Mixed$49: MixinCtor<abstract new () => TsDsl<ts.AwaitExpression>, ExprMethods>;
-declare class AwaitTsDsl extends Mixed$49 {
+declare const Mixed$50: MixinCtor<abstract new () => TsDsl<ts.AwaitExpression>, ExprMethods>;
+declare class AwaitTsDsl extends Mixed$50 {
   readonly '~dsl' = "AwaitTsDsl";
   protected _awaitExpr: Ref<AwaitExpr>;
   constructor(expr: AwaitExpr);
@@ -567,10 +817,10 @@ declare class AwaitTsDsl extends Mixed$49 {
 }
 //#endregion
 //#region src/ts-dsl/mixins/args.d.ts
-type Arg = NodeName | MaybeTsDsl<ts.Expression>;
+type Arg = NodeName | MaybeTsDsl<ts.Expression | ts.SpreadElement>;
 interface ArgsMethods extends Node {
-  /** Renders the arguments into an array of `Expression`s. */
-  $args(): ReadonlyArray<ts.Expression>;
+  /** Renders the arguments into an array of `Expression`s or `SpreadElement`s. */
+  $args(): ReadonlyArray<ts.Expression | ts.SpreadElement>;
   /** Adds a single expression argument. */
   arg(arg: Arg | undefined): this;
   /** Adds one or more expression arguments. */
@@ -581,8 +831,8 @@ interface ArgsMethods extends Node {
 type NewArgs = ReadonlyArray<NewExpr | undefined>;
 type NewExpr = NodeName | MaybeTsDsl<ts.Expression>;
 type NewCtor = (expr: NewExpr, ...args: NewArgs) => NewTsDsl;
-declare const Mixed$48: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.NewExpression>, TypeArgsMethods>, ExprMethods>, AsMethods>, ArgsMethods>;
-declare class NewTsDsl extends Mixed$48 {
+declare const Mixed$49: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.NewExpression>, TypeArgsMethods>, SpreadMethods>, ExprMethods>, AsMethods>, ArgsMethods>;
+declare class NewTsDsl extends Mixed$49 {
   readonly '~dsl' = "NewTsDsl";
   protected _newExpr: Ref<NewExpr>;
   constructor(expr: NewExpr, ...args: NewArgs);
@@ -590,8 +840,20 @@ declare class NewTsDsl extends Mixed$48 {
   toAst(): ts.NewExpression;
 }
 //#endregion
+//#region src/ts-dsl/expr/spread.d.ts
+type SpreadExpr = NodeName | MaybeTsDsl<ts.Expression>;
+type SpreadCtor = (expr: SpreadExpr) => SpreadTsDsl;
+declare const Mixed$48: abstract new () => TsDsl<ts.SpreadElement>;
+declare class SpreadTsDsl extends Mixed$48 {
+  readonly '~dsl' = "SpreadTsDsl";
+  protected _expr: Ref<SpreadExpr>;
+  constructor(expr: SpreadExpr);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.SpreadElement;
+}
+//#endregion
 //#region src/ts-dsl/expr/typeof.d.ts
-type TypeOfExpr = string | MaybeTsDsl<ts.Expression>;
+type TypeOfExpr = NodeName | MaybeTsDsl<ts.Expression>;
 type TypeOfExprCtor = (expr: TypeOfExpr) => TypeOfExprTsDsl;
 declare const Mixed$47: MixinCtor<abstract new () => TsDsl<ts.TypeOfExpression>, OperatorMethods>;
 declare class TypeOfExprTsDsl extends Mixed$47 {
@@ -616,7 +878,7 @@ declare class ReturnTsDsl extends Mixed$46 {
 //#endregion
 //#region src/ts-dsl/mixins/type-expr.d.ts
 interface TypeExprMethods extends Node {
-  /** Creates an indexed-access type (e.g. `Foo<T>[K]`). */
+  /** Creates an indexed-access type (e.g., `Foo<T>[K]`). */
   idx(this: Parameters<typeof f.type.idx>[0], ...args: DropFirst<Parameters<typeof f.type.idx>>): ReturnType<typeof f.type.idx>;
   /** Shorthand: builds `keyof T`. */
   keyof(this: MaybeTsDsl<TypeTsDsl>): ReturnType<typeof f.type.operator>;
@@ -672,7 +934,7 @@ declare class TypeExprTsDsl extends Mixed$44 {
   analyze(ctx: AnalysisContext): void;
   /** Returns true when all required builder calls are present. */
   get isValid(): boolean;
-  /** Accesses a nested type (e.g. `Foo.Bar`). */
+  /** Accesses a nested type (e.g., `Foo.Bar`). */
   attr(right: string | ts.Identifier | TypeAttrTsDsl): this;
   toAst(): ts.TypeReferenceNode;
   $validate(): asserts this is this & {
@@ -760,6 +1022,23 @@ declare class TypeQueryTsDsl extends Mixed$41 {
   toAst(): ts.TypeQueryNode;
 }
 //#endregion
+//#region src/ts-dsl/type/tuple-member.d.ts
+type TypeTupleMemberCtor = (name: NodeName) => TypeTupleMemberTsDsl;
+declare const Mixed$40: MixinCtor<abstract new () => TsDsl<ts.NamedTupleMember>, OptionalMethods>;
+declare class TypeTupleMemberTsDsl extends Mixed$40 {
+  readonly '~dsl' = "TypeTupleMemberTsDsl";
+  scope: NodeScope;
+  protected _type?: Ref<NodeName | TypeTsDsl>;
+  constructor(name: NodeName);
+  analyze(ctx: AnalysisContext): void;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  type(node: NodeName | TypeTsDsl): this;
+  toAst(): ts.NamedTupleMember;
+  $validate(): asserts this;
+  private missingRequiredCalls;
+}
+//#endregion
 //#region src/ts-dsl/utils/factories.d.ts
 type Ctor = (...args: Array<any>) => any;
 type Factory<T extends Ctor> = {
@@ -767,39 +1046,36 @@ type Factory<T extends Ctor> = {
   set(fn: T): void;
 };
 declare const f: {
-  /** Factory for creating `as` type assertion expressions (e.g. `value as Type`). */as: Factory<AsCtor>; /** Factory for creating property access expressions (e.g. `obj.foo`). */
-  attr: Factory<AttrCtor>; /** Factory for creating await expressions (e.g. `await promise`). */
-  await: Factory<AwaitCtor>; /** Factory for creating function or method call expressions (e.g. `fn(arg)`). */
-  call: Factory<CallCtor>; /** Factory for creating new expressions (e.g. `new ClassName()`). */
+  /** Factory for creating `as` type assertion expressions (e.g., `value as Type`). */as: Factory<AsCtor>; /** Factory for creating property access expressions (e.g., `obj.foo`). */
+  attr: Factory<AttrCtor>; /** Factory for creating await expressions (e.g., `await promise`). */
+  await: Factory<AwaitCtor>; /** Factory for creating function or method call expressions (e.g., `fn(arg)`). */
+  call: Factory<CallCtor>; /** Factory for creating method declarations (e.g., `{ foo() { ... } }`). */
+  method: Factory<MethodCtor>; /** Factory for creating new expressions (e.g., `new ClassName()`). */
   new: Factory<NewCtor>; /** Factory for creating return statements. */
-  return: Factory<ReturnCtor>; /** Factories for creating type nodes. */
+  return: Factory<ReturnCtor>; /** Factory for creating spread expressions (e.g., `...expr`). */
+  spread: Factory<SpreadCtor>; /** Factories for creating type nodes. */
   type: {
-    /** Factory for creating basic type references or type expressions (e.g. Foo or Foo<T>). */expr: Factory<TypeExprCtor>; /** Factory for creating indexed-access types (e.g. `Foo<T>[K]`). */
-    idx: Factory<TypeIdxCtor>; /** Factory for creating type operator nodes (e.g. `readonly T`, `keyof T`, `unique T`). */
-    operator: Factory<TypeOperatorCtor>; /** Factory for creating type query nodes (e.g. `typeof Foo`). */
-    query: Factory<TypeQueryCtor>;
-  }; /** Factory for creating `typeof` expressions (e.g. `typeof value`). */
+    /** Factory for creating basic type references or type expressions (e.g., Foo or Foo<T>). */expr: Factory<TypeExprCtor>; /** Factory for creating indexed-access types (e.g., `Foo<T>[K]`). */
+    idx: Factory<TypeIdxCtor>; /** Factory for creating type operator nodes (e.g., `readonly T`, `keyof T`, `unique T`). */
+    operator: Factory<TypeOperatorCtor>; /** Factory for creating type query nodes (e.g., `typeof Foo`). */
+    query: Factory<TypeQueryCtor>; /** Factory for creating named tuple elements (e.g., `[resolver?: R]`). */
+    tupleMember: Factory<TypeTupleMemberCtor>;
+  }; /** Factory for creating `typeof` expressions (e.g., `typeof value`). */
   typeofExpr: Factory<TypeOfExprCtor>;
 };
 //#endregion
-//#region src/ts-dsl/mixins/expr.d.ts
-interface ExprMethods extends Node {
-  /** Accesses a property on the current expression (e.g. `this.foo`). */
-  attr(...args: DropFirst<Parameters<typeof f.attr>>): ReturnType<typeof f.attr>;
-  /** Awaits the current expression (e.g. `await expr`). */
-  await(): ReturnType<typeof f.await>;
-  /** Calls the current expression (e.g. `fn(arg1, arg2)`). */
-  call(...args: DropFirst<Parameters<typeof f.call>>): ReturnType<typeof f.call>;
-  /** Produces a `return` statement returning the current expression. */
-  return(): ReturnType<typeof f.return>;
+//#region src/ts-dsl/mixins/spread.d.ts
+interface SpreadMethods extends Node {
+  /** Produces a spread element from the current expression (e.g., `...expr`). */
+  spread(): ReturnType<typeof f.spread>;
 }
 //#endregion
 //#region src/ts-dsl/expr/call.d.ts
 type CallArgs = ReadonlyArray<CallCallee | undefined>;
 type CallCallee = NodeName | MaybeTsDsl<ts.Expression>;
 type CallCtor = (callee: CallCallee, ...args: CallArgs) => CallTsDsl;
-declare const Mixed$40: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.CallExpression>, TypeArgsMethods>, ExprMethods>, AsMethods>, ArgsMethods>;
-declare class CallTsDsl extends Mixed$40 {
+declare const Mixed$39: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.CallExpression>, TypeArgsMethods>, SpreadMethods>, ExprMethods>, AsMethods>, ArgsMethods>;
+declare class CallTsDsl extends Mixed$39 {
   readonly '~dsl' = "CallTsDsl";
   protected _callee: Ref<CallCallee>;
   constructor(callee: CallCallee, ...args: CallArgs);
@@ -910,18 +1186,32 @@ declare abstract class TypeTsDsl<T extends ts.LiteralTypeNode | ts.QualifiedName
 type TypeOfMaybe<I> = undefined extends I ? TypeOf<NonNullable<FromRef<I>>> | undefined : TypeOf<FromRef<I>>;
 type TypeOf<I> = I extends ReadonlyArray<infer U> ? ReadonlyArray<TypeOf<U>> : I extends string ? ts.TypeNode : I extends boolean ? ts.LiteralTypeNode : I extends TsDsl<infer N> ? N : I extends ts.TypeNode ? I : never;
 //#endregion
-//#region src/ts-dsl/layout/doc.d.ts
-type DocMaybeLazy<T> = ((ctx: TsDslContext) => T) | T;
-type DocFn = (d: DocTsDsl) => void;
-type DocLines = DocMaybeLazy<MaybeArray<string>>;
-declare class DocTsDsl extends TsDsl<ts.Node> {
-  readonly '~dsl' = "DocTsDsl";
-  protected _lines: Array<DocLines>;
-  constructor(lines?: DocLines, fn?: DocFn);
+//#region src/ts-dsl/expr/postfix.d.ts
+type PostfixExpr = string | MaybeTsDsl<ts.Expression>;
+type PostfixOp = ts.PostfixUnaryOperator;
+declare const Mixed$38: abstract new () => TsDsl<ts.PostfixUnaryExpression>;
+declare class PostfixTsDsl extends Mixed$38 {
+  readonly '~dsl' = "PostfixTsDsl";
+  protected _expr?: PostfixExpr;
+  protected _op?: PostfixOp;
+  constructor(expr?: PostfixExpr, op?: PostfixOp);
   analyze(ctx: AnalysisContext): void;
-  add(lines: DocLines): this;
-  apply<T extends ts.Node>(node: T): T;
-  toAst(): ts.Identifier;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  /** Sets the operator to MinusMinusToken for decrement (`--`). */
+  dec(): this;
+  /** Sets the operand (the expression being postfixed). */
+  expr(expr: PostfixExpr): this;
+  /** Sets the operator to PlusPlusToken for increment (`++`). */
+  inc(): this;
+  /** Sets the operator (e.g., `ts.SyntaxKind.PlusPlusToken` for `++`). */
+  op(op: PostfixOp): this;
+  toAst(): ts.PostfixUnaryExpression;
+  $validate(): asserts this is this & {
+    _expr: PostfixExpr;
+    _op: PostfixOp;
+  };
+  private missingRequiredCalls;
 }
 //#endregion
 //#region src/ts-dsl/layout/hint.d.ts
@@ -938,20 +1228,10 @@ declare class HintTsDsl extends TsDsl<ts.Node> {
   toAst(): ts.Identifier;
 }
 //#endregion
-//#region src/ts-dsl/mixins/do.d.ts
-type DoExpr = MaybeTsDsl<ts.Expression | ts.Statement>;
-interface DoMethods extends Node {
-  /** Renders the collected `.do()` calls into an array of `Statement` nodes. */
-  $do(): ReadonlyArray<ts.Statement>;
-  _do: Array<DoExpr>;
-  /** Adds one or more expressions/statements to the body. */
-  do(...items: ReadonlyArray<DoExpr>): this;
-}
-//#endregion
 //#region src/ts-dsl/stmt/if.d.ts
-type IfCondition = string | MaybeTsDsl<ts.Expression>;
-declare const Mixed$39: MixinCtor<abstract new () => TsDsl<ts.IfStatement>, DoMethods>;
-declare class IfTsDsl extends Mixed$39 {
+type IfCondition = NodeName | MaybeTsDsl<ts.Expression>;
+declare const Mixed$37: MixinCtor<abstract new () => TsDsl<ts.IfStatement>, DoMethods>;
+declare class IfTsDsl extends Mixed$37 {
   readonly '~dsl' = "IfTsDsl";
   protected _condition?: IfCondition;
   protected _else?: Array<DoExpr>;
@@ -1029,236 +1309,82 @@ interface TsSourceFile extends TsNodeBase {
   kind: TsNodeKind.SourceFile;
   statements: ReadonlyArray<TsNode>;
 }
-declare function createSourceFile(statements: ReadonlyArray<TsNode>, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): TsSourceFile;
-//#endregion
-//#region src/ts-compiler/nodes/base.d.ts
-interface TsNodeBase {
-  kind: TsNodeKind;
-  leadingComments?: ReadonlyArray<string>;
-  trailingComments?: ReadonlyArray<string>;
-}
-type TsNode = TsExpression | TsSourceFile | TsStatement;
-//#endregion
-//#region src/ts-compiler/nodes/expressions/literal.d.ts
-type TsLiteralValue = string | number | boolean | bigint | null;
-interface TsLiteral extends TsNodeBase {
-  kind: TsNodeKind.Literal;
-  value: TsLiteralValue;
-}
-declare function createLiteral(value: TsLiteralValue, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): TsLiteral;
-//#endregion
-//#region src/ts-dsl/layout/note.d.ts
-type NoteMaybeLazy<T> = ((ctx: TsDslContext) => T) | T;
-type NoteFn = (d: NoteTsDsl) => void;
-type NoteLines = NoteMaybeLazy<MaybeArray<string>>;
-declare class NoteTsDsl extends TsDsl<ts.Node> {
-  readonly '~dsl' = "NoteTsDsl";
-  protected _lines: Array<NoteLines>;
-  constructor(lines?: NoteLines, fn?: NoteFn);
-  analyze(ctx: AnalysisContext): void;
-  add(lines: NoteLines): this;
-  apply<T extends ts.Node>(node: T): T;
-  toAst(): ts.Identifier;
-}
-//#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 | MaybeTsDsl<ts.Expression>, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>): this;
-}
-//#endregion
-//#region src/ts-dsl/decl/param.d.ts
-type ParamName = NodeName | ParamFn;
-type ParamFn = (p: ParamTsDsl) => void;
-type ParamCtor = (name: ParamName, fn?: ParamFn) => ParamTsDsl;
-declare const Mixed$38: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ParameterDeclaration>, ValueMethods>, PatternMethods>, OptionalMethods>, DecoratorMethods>;
-declare class ParamTsDsl extends Mixed$38 {
-  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/expr/template.d.ts
-type TemplatePart = NodeName | MaybeTsDsl<ts.Expression>;
-declare const Mixed$37: abstract new () => TsDsl<ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral>;
-declare class TemplateTsDsl extends Mixed$37 {
-  readonly '~dsl' = "TemplateTsDsl";
-  protected parts: Array<Ref<TemplatePart>>;
-  constructor(value?: TemplatePart);
-  analyze(ctx: AnalysisContext): void;
-  add(value: TemplatePart): this;
-  toAst(): ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral;
-}
-//#endregion
-//#region src/ts-dsl/type/param.d.ts
-type TypeParamExpr = NodeName | boolean | MaybeTsDsl<TypeTsDsl>;
-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, fn?: (name: TypeParamTsDsl) => void);
-  analyze(ctx: AnalysisContext): void;
-  /** Sets the parameter default value. */
-  default(value: TypeParamExpr): this;
-  extends(constraint: TypeParamExpr): this;
-  toAst(): ts.TypeParameterDeclaration;
-}
-//#endregion
-//#region src/ts-dsl/mixins/type-params.d.ts
-interface TypeParamsMethods extends Node {
-  /** Returns the type parameters as an array of ts.TypeParameterDeclaration nodes. */
-  $generics(): ReadonlyArray<ts.TypeParameterDeclaration> | undefined;
-  /** Adds a single type parameter (e.g. `T` in `Array<T>`). */
-  generic(...args: ConstructorParameters<typeof TypeParamTsDsl>): this;
-  /** Adds type parameters (e.g. `Map<string, T>`). */
-  generics(...args: ReadonlyArray<NodeName | MaybeTsDsl<TypeParamTsDsl>>): this;
-}
-//#endregion
-//#region src/ts-dsl/mixins/modifiers.d.ts
-type Modifiers = {
-  /**
-   * Checks if the specified modifier is present.
-   *
-   * @param modifier - The modifier to check.
-   * @returns True if the modifier is present, false otherwise.
-   */
-  hasModifier(modifier: Modifier): boolean;
-  modifiers: Array<ts.Modifier>;
-};
-type Modifier = 'abstract' | 'async' | 'const' | 'declare' | 'default' | 'export' | 'override' | 'private' | 'protected' | 'public' | 'readonly' | 'static';
-interface AbstractMethods extends Modifiers {
-  /**
-   * Adds the `abstract` keyword modifier if the condition is true.
-   *
-   * @param condition - Whether to add the modifier (default: true).
-   * @returns The target object for chaining.
-   */
-  abstract(condition?: boolean): this;
-}
-interface AsyncMethods extends Modifiers {
-  /**
-   * Adds the `async` keyword modifier if the condition is true.
-   *
-   * @param condition - Whether to add the modifier (default: true).
-   * @returns The target object for chaining.
-   */
-  async(condition?: boolean): this;
-}
-interface ConstMethods extends Modifiers {
-  /**
-   * Adds the `const` keyword modifier if the condition is true.
-   *
-   * @param condition - Whether to add the modifier (default: true).
-   * @returns The target object for chaining.
-   */
-  const(condition?: boolean): this;
-}
-interface DefaultMethods extends Modifiers {
-  /**
-   * Adds the `default` keyword modifier if the condition is true.
-   *
-   * @param condition - Whether to add the modifier (default: true).
-   * @returns The target object for chaining.
-   */
-  default(condition?: boolean): this;
-}
-interface ExportMethods extends Modifiers {
-  /**
-   * Adds the `export` keyword modifier if the condition is true.
-   *
-   * @param condition - Whether to add the modifier (default: true).
-   * @returns The target object for chaining.
-   */
-  export(condition?: boolean): this;
-}
-interface PrivateMethods extends Modifiers {
-  /**
-   * Adds the `private` keyword modifier if the condition is true.
-   *
-   * @param condition - Whether to add the modifier (default: true).
-   * @returns The target object for chaining.
-   */
-  private(condition?: boolean): this;
-}
-interface ProtectedMethods extends Modifiers {
-  /**
-   * Adds the `protected` keyword modifier if the condition is true.
-   *
-   * @param condition - Whether to add the modifier (default: true).
-   * @returns The target object for chaining.
-   */
-  protected(condition?: boolean): this;
+declare function createSourceFile(statements: ReadonlyArray<TsNode>, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): TsSourceFile;
+//#endregion
+//#region src/ts-compiler/nodes/base.d.ts
+interface TsNodeBase {
+  kind: TsNodeKind;
+  leadingComments?: ReadonlyArray<string>;
+  trailingComments?: ReadonlyArray<string>;
 }
-interface PublicMethods extends Modifiers {
-  /**
-   * Adds the `public` keyword modifier if the condition is true.
-   *
-   * @param condition - Whether to add the modifier (default: true).
-   * @returns The target object for chaining.
-   */
-  public(condition?: boolean): this;
+type TsNode = TsExpression | TsSourceFile | TsStatement;
+//#endregion
+//#region src/ts-compiler/nodes/expressions/literal.d.ts
+type TsLiteralValue = string | number | boolean | bigint | null;
+interface TsLiteral extends TsNodeBase {
+  kind: TsNodeKind.Literal;
+  value: TsLiteralValue;
 }
-interface ReadonlyMethods extends Modifiers {
-  /**
-   * Adds the `readonly` keyword modifier if the condition is true.
-   *
-   * @param condition - Whether to add the modifier (default: true).
-   * @returns The target object for chaining.
-   */
-  readonly(condition?: boolean): this;
+declare function createLiteral(value: TsLiteralValue, leadingComments?: ReadonlyArray<string>, trailingComments?: ReadonlyArray<string>): TsLiteral;
+//#endregion
+//#region src/ts-dsl/expr/prefix.d.ts
+type PrefixExpr = string | MaybeTsDsl<ts.Expression>;
+type PrefixOp = ts.PrefixUnaryOperator;
+declare const Mixed$36: abstract new () => TsDsl<ts.PrefixUnaryExpression>;
+declare class PrefixTsDsl extends Mixed$36 {
+  readonly '~dsl' = "PrefixTsDsl";
+  protected _expr?: PrefixExpr;
+  protected _op?: PrefixOp;
+  constructor(expr?: PrefixExpr, op?: PrefixOp);
+  analyze(ctx: AnalysisContext): void;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  /** Sets the operand (the expression being prefixed). */
+  expr(expr: PrefixExpr): this;
+  /** Sets the operator to MinusToken for negation (`-`). */
+  neg(): this;
+  /** Sets the operator to ExclamationToken for logical NOT (`!`). */
+  not(): this;
+  /** Sets the operator (e.g., `ts.SyntaxKind.ExclamationToken` for `!`). */
+  op(op: PrefixOp): this;
+  toAst(): ts.PrefixUnaryExpression;
+  $validate(): asserts this is this & {
+    _expr: PrefixExpr;
+    _op: PrefixOp;
+  };
+  private missingRequiredCalls;
 }
-interface StaticMethods extends Modifiers {
-  /**
-   * Adds the `static` keyword modifier if the condition is true.
-   *
-   * @param condition - Whether to add the modifier (default: true).
-   * @returns The target object for chaining.
-   */
-  static(condition?: boolean): this;
+//#endregion
+//#region src/ts-dsl/layout/note.d.ts
+type NoteMaybeLazy<T> = ((ctx: TsDslContext) => T) | T;
+type NoteFn = (d: NoteTsDsl) => void;
+type NoteLines = NoteMaybeLazy<MaybeArray<string>>;
+declare class NoteTsDsl extends TsDsl<ts.Node> {
+  readonly '~dsl' = "NoteTsDsl";
+  protected _lines: Array<NoteLines>;
+  constructor(lines?: NoteLines, fn?: NoteFn);
+  analyze(ctx: AnalysisContext): void;
+  add(lines: NoteLines): this;
+  apply<T extends ts.Node>(node: T): T;
+  toAst(): ts.Identifier;
 }
 //#endregion
-//#region src/ts-dsl/mixins/doc.d.ts
-interface DocMethods extends Node {
-  $docs<T extends ts.Node>(node: T): T;
-  doc(lines?: DocLines, fn?: DocFn): this;
+//#region src/ts-dsl/expr/template.d.ts
+type TemplatePart = NodeName | MaybeTsDsl<ts.Expression>;
+declare const Mixed$35: abstract new () => TsDsl<ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral>;
+declare class TemplateTsDsl extends Mixed$35 {
+  readonly '~dsl' = "TemplateTsDsl";
+  protected parts: Array<Ref<TemplatePart>>;
+  constructor(value?: TemplatePart);
+  analyze(ctx: AnalysisContext): void;
+  add(value: TemplatePart): this;
+  toAst(): ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral;
 }
 //#endregion
 //#region src/ts-dsl/decl/field.d.ts
 type FieldType = NodeName | TypeTsDsl;
-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 {
+declare const Mixed$34: 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$34 {
   readonly '~dsl' = "FieldTsDsl";
   readonly nameSanitizer: (name: string) => string;
   protected _type?: TypeTsDsl;
@@ -1269,43 +1395,15 @@ declare class FieldTsDsl extends Mixed$35 {
   toAst(): ts.PropertyDeclaration;
 }
 //#endregion
-//#region src/ts-dsl/mixins/param.d.ts
-interface ParamMethods extends Node {
-  /** Renders the parameters into an array of `ParameterDeclaration`s. */
-  $params(): ReadonlyArray<ts.ParameterDeclaration>;
-  /** Adds a parameter. */
-  param(...args: Parameters<ParamCtor>): this;
-  /** Adds multiple parameters. */
-  params(...params: ReadonlyArray<MaybeTsDsl<ts.ParameterDeclaration>>): this;
-}
-//#endregion
 //#region src/ts-dsl/decl/init.d.ts
-declare const Mixed$34: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ConstructorDeclaration>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>;
-declare class InitTsDsl extends Mixed$34 {
+declare const Mixed$33: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ConstructorDeclaration>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>;
+declare class InitTsDsl extends Mixed$33 {
   readonly '~dsl' = "InitTsDsl";
   constructor(fn?: (i: InitTsDsl) => void);
   analyze(ctx: AnalysisContext): void;
   toAst(): ts.ConstructorDeclaration;
 }
 //#endregion
-//#region src/ts-dsl/mixins/type-returns.d.ts
-interface TypeReturnsMethods extends Node {
-  /** Returns the return type node. */
-  $returns(): ts.TypeNode | undefined;
-  /** Sets the return type. */
-  returns(type: NodeName | TypeTsDsl): this;
-}
-//#endregion
-//#region src/ts-dsl/decl/method.d.ts
-declare const Mixed$33: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.MethodDeclaration>, TypeReturnsMethods>, TypeParamsMethods>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, OptionalMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AbstractMethods>;
-declare class MethodTsDsl extends Mixed$33 {
-  readonly '~dsl' = "MethodTsDsl";
-  readonly nameSanitizer: (name: string) => string;
-  constructor(name: NodeName, fn?: (m: MethodTsDsl) => void);
-  analyze(ctx: AnalysisContext): void;
-  toAst(): ts.MethodDeclaration;
-}
-//#endregion
 //#region src/ts-dsl/decl/class.d.ts
 type Body = Array<MaybeTsDsl<ts.ClassElement | ts.Node>>;
 declare const Mixed$32: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ClassDeclaration>, TypeParamsMethods>, ExportMethods>, DocMethods>, DefaultMethods>, DecoratorMethods>, AbstractMethods>;
@@ -1378,7 +1476,7 @@ declare class EnumTsDsl extends Mixed$29 {
 //#endregion
 //#region src/ts-dsl/decl/func.d.ts
 type FuncMode = 'arrow' | 'decl' | 'expr';
-declare const Mixed$28: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ArrowFunction>, TypeReturnsMethods>, TypeParamsMethods>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AsMethods>, AbstractMethods>;
+declare const Mixed$28: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ArrowFunction>, TypeReturnsMethods>, TypeParamsMethods>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, ExportMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AsMethods>, AbstractMethods>;
 declare class ImplFuncTsDsl<M extends FuncMode = 'arrow'> extends Mixed$28 {
   readonly '~dsl' = "FuncTsDsl";
   readonly nameSanitizer: (name: string) => string;
@@ -1421,7 +1519,7 @@ declare class GetterTsDsl extends Mixed$27 {
 //#region src/ts-dsl/decl/pattern.d.ts
 declare const Mixed$26: abstract new () => TsDsl<ts.BindingName>;
 /**
- * Builds binding patterns (e.g. `{ foo, bar }`, `[a, b, ...rest]`).
+ * Builds binding patterns (e.g., `{ foo, bar }`, `[a, b, ...rest]`).
  */
 declare class PatternTsDsl extends Mixed$26 {
   readonly '~dsl' = "PatternTsDsl";
@@ -1436,11 +1534,11 @@ declare class PatternTsDsl extends Mixed$26 {
   analyze(ctx: AnalysisContext): void;
   /** Returns true when all required builder calls are present. */
   get isValid(): boolean;
-  /** Defines an array pattern (e.g. `[a, b, c]`). */
+  /** Defines an array pattern (e.g., `[a, b, c]`). */
   array(...props: ReadonlyArray<string> | [ReadonlyArray<string>]): this;
-  /** Defines an object pattern (e.g. `{ a, b: alias }`). */
+  /** Defines an object pattern (e.g., `{ a, b: alias }`). */
   object(...props: ReadonlyArray<MaybeArray<string> | Record<string, string>>): this;
-  /** Adds a spread element (e.g. `...rest`, `...options`, `...args`). */
+  /** Adds a spread element (e.g., `...rest`, `...options`, `...args`). */
   spread(name: string): this;
   toAst(): ts.ObjectBindingPattern | ts.ArrayBindingPattern;
   $validate(): asserts this is this & {
@@ -1479,30 +1577,23 @@ interface LayoutMethods extends Node {
 }
 //#endregion
 //#region src/ts-dsl/expr/array.d.ts
-declare const Mixed$24: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ArrayLiteralExpression>, LayoutMethods>, AsMethods>;
+type ArrayExpr = string | number | boolean | MaybeTsDsl<ts.Expression>;
+declare const Mixed$24: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ArrayLiteralExpression>, SpreadMethods>, LayoutMethods>, ExprMethods>, AsMethods>;
 declare class ArrayTsDsl extends Mixed$24 {
   readonly '~dsl' = "ArrayTsDsl";
-  protected _elements: Array<{
-    expr: MaybeTsDsl<ts.Expression>;
-    kind: 'element';
-  } | {
-    expr: MaybeTsDsl<ts.Expression>;
-    kind: 'spread';
-  }>;
-  constructor(...exprs: Array<string | number | boolean | MaybeTsDsl<ts.Expression>>);
+  protected _elements: Array<MaybeTsDsl<ts.Expression>>;
+  constructor(...exprs: Array<ArrayExpr>);
   analyze(ctx: AnalysisContext): void;
   /** Adds a single array element. */
-  element(expr: string | number | boolean | MaybeTsDsl<ts.Expression>): this;
+  element(expr: ArrayExpr): this;
   /** Adds multiple array elements. */
-  elements(...exprs: ReadonlyArray<string | number | boolean | MaybeTsDsl<ts.Expression>>): this;
-  /** Adds a spread element (`...expr`). */
-  spread(expr: MaybeTsDsl<ts.Expression>): this;
+  elements(...exprs: ReadonlyArray<ArrayExpr>): this;
   toAst(): ts.ArrayLiteralExpression;
 }
 //#endregion
 //#region src/ts-dsl/expr/expr.d.ts
 type Id = NodeName | MaybeTsDsl<ts.Expression>;
-declare const Mixed$23: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.Expression>, TypeExprMethods>, OperatorMethods>, ExprMethods>, AsMethods>;
+declare const Mixed$23: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.Expression>, TypeExprMethods>, SpreadMethods>, OperatorMethods>, ExprMethods>, AsMethods>;
 declare class ExprTsDsl extends Mixed$23 {
   readonly '~dsl' = "ExprTsDsl";
   protected _exprInput: Ref<Id>;
@@ -1586,15 +1677,17 @@ interface HintMethods extends Node {
 }
 //#endregion
 //#region src/ts-dsl/expr/prop.d.ts
-type Expr$1 = NodeName | MaybeTsDsl<ts.Expression>;
-type Stmt$1 = NodeName | MaybeTsDsl<ts.Statement>;
-type ObjectPropKind = 'computed' | 'getter' | 'prop' | 'setter' | 'spread';
+type ObjectPropKind = 'computed' | 'getter' | 'method' | 'prop' | 'setter' | 'spread';
+type ObjectPropValue = NodeName | MaybeTsDsl<ts.Expression | ts.Statement> | ReturnType<typeof f.method>;
 type Meta = {
   kind: 'computed';
   name: string;
 } | {
   kind: 'getter';
   name: string;
+} | {
+  kind: 'method';
+  name: string;
 } | {
   kind: 'prop';
   name: string;
@@ -1608,17 +1701,17 @@ type Meta = {
 declare const Mixed$20: MixinCtor<abstract new () => TsDsl<ts.ObjectLiteralElementLike>, DocMethods>;
 declare class ObjectPropTsDsl extends Mixed$20 {
   readonly '~dsl' = "ObjectPropTsDsl";
-  protected _value?: Ref<Expr$1 | Stmt$1>;
+  protected _value?: Ref<ObjectPropValue>;
   protected _meta: Meta;
   constructor(meta: Meta);
-  get kind(): ObjectPropKind;
-  get propName(): string | undefined;
   analyze(ctx: AnalysisContext): void;
   get isValid(): boolean;
-  value(value: Expr$1 | Stmt$1 | ((p: ObjectPropTsDsl) => void)): this;
-  toAst(): ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ts.PropertyAssignment | ts.ShorthandPropertyAssignment | ts.SpreadAssignment;
+  get kind(): ObjectPropKind;
+  get propName(): string | undefined;
+  value(value: ObjectPropValue): this;
+  toAst(): ts.MethodDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ts.PropertyAssignment | ts.ShorthandPropertyAssignment | ts.SpreadAssignment;
   $validate(): asserts this is this & {
-    _value: Expr$1 | Stmt$1;
+    _value: ObjectPropValue;
     kind: ObjectPropKind;
   };
   private missingRequiredCalls;
@@ -1627,67 +1720,41 @@ declare class ObjectPropTsDsl extends Mixed$20 {
 //#region src/ts-dsl/expr/object.d.ts
 type Expr = NodeName | MaybeTsDsl<ts.Expression>;
 type Stmt = NodeName | MaybeTsDsl<ts.Statement>;
-type ExprFn = Expr | ((p: ObjectPropTsDsl) => void);
-type StmtFn = Stmt | ((p: ObjectPropTsDsl) => void);
 declare const Mixed$19: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ObjectLiteralExpression>, LayoutMethods>, HintMethods>, ExprMethods>, AsMethods>;
 declare class ObjectTsDsl extends Mixed$19 {
   readonly '~dsl' = "ObjectTsDsl";
   protected _props: Map<string, ObjectPropTsDsl>;
   protected _spreadCounter: number;
-  constructor(...props: Array<ObjectPropTsDsl>);
+  constructor(...props: Array<ObjectPropTsDsl> | [(o: ObjectTsDsl) => void]);
   analyze(ctx: AnalysisContext): void;
   /** Returns composite key for the property. */
   private _propKey;
-  /** Adds a computed property (e.g. `{ [expr]: value }`), or removes if null. */
-  computed(name: string, expr: ExprFn | null): this;
-  /** Adds a getter property (e.g. `{ get foo() { ... } }`), or removes if null. */
-  getter(name: string, stmt: StmtFn | null): this;
+  /** Adds a computed property (e.g., `{ [expr]: value }`), or removes if null. */
+  computed(name: string, expr: Expr | null): this;
+  /** Adds a getter property (e.g., `{ get foo() { ... } }`), or removes if null. */
+  getter(name: string, stmt: Stmt | null): this;
   /** Returns true if object has at least one property or spread. */
   hasProps(): boolean;
   /** Returns true if object has no properties or spreads. */
   get isEmpty(): boolean;
+  /** Adds a method property (e.g., `{ foo() { ... } }`), or removes if null. */
+  method(name: string, fn: ((m: MethodTsDsl) => void) | null): this;
   /** Adds a property assignment, or removes if null. */
-  prop(name: string, expr: ExprFn | null): this;
+  prop(name: string, expr: Expr | null): this;
   /** Adds multiple properties. */
   props(...props: ReadonlyArray<ObjectPropTsDsl>): this;
-  /** Adds a setter property (e.g. `{ set foo(v) { ... } }`), or removes if null. */
-  setter(name: string, stmt: StmtFn | null): this;
-  /** Adds a spread property (e.g. `{ ...options }`). */
-  spread(expr: ExprFn): this;
+  /** Adds a setter property (e.g., `{ set foo(v) { ... } }`), or removes if null. */
+  setter(name: string, stmt: Stmt | null): this;
+  /** Adds a spread property (e.g., `{ ...options }`). */
+  spread(expr: Expr): this;
   toAst(): ts.ObjectLiteralExpression;
 }
 //#endregion
-//#region src/ts-dsl/expr/prefix.d.ts
-declare const Mixed$18: abstract new () => TsDsl<ts.PrefixUnaryExpression>;
-declare class PrefixTsDsl extends Mixed$18 {
-  readonly '~dsl' = "PrefixTsDsl";
-  protected _expr?: string | MaybeTsDsl<ts.Expression>;
-  protected _op?: ts.PrefixUnaryOperator;
-  constructor(expr?: string | MaybeTsDsl<ts.Expression>, op?: ts.PrefixUnaryOperator);
-  analyze(ctx: AnalysisContext): void;
-  /** Returns true when all required builder calls are present. */
-  get isValid(): boolean;
-  /** Sets the operand (the expression being prefixed). */
-  expr(expr: string | MaybeTsDsl<ts.Expression>): this;
-  /** Sets the operator to MinusToken for negation (`-`). */
-  neg(): this;
-  /** Sets the operator to ExclamationToken for logical NOT (`!`). */
-  not(): this;
-  /** Sets the operator (e.g. `ts.SyntaxKind.ExclamationToken` for `!`). */
-  op(op: ts.PrefixUnaryOperator): this;
-  toAst(): ts.PrefixUnaryExpression;
-  $validate(): asserts this is this & {
-    _expr: string | MaybeTsDsl<ts.Expression>;
-    _op: ts.PrefixUnaryOperator;
-  };
-  private missingRequiredCalls;
-}
-//#endregion
 //#region src/ts-dsl/expr/regexp.d.ts
 type RegexFlag = 'g' | 'i' | 'm' | 's' | 'u' | 'y';
 type RegexFlags<Avail extends string = RegexFlag> = '' | { [K in Avail]: `${K}${RegexFlags<Exclude<Avail, K>>}` }[Avail];
-declare const Mixed$17: abstract new () => TsDsl<ts.RegularExpressionLiteral>;
-declare class RegExpTsDsl extends Mixed$17 {
+declare const Mixed$18: abstract new () => TsDsl<ts.RegularExpressionLiteral>;
+declare class RegExpTsDsl extends Mixed$18 {
   readonly '~dsl' = "RegExpTsDsl";
   protected pattern: string;
   protected flags?: RegexFlags;
@@ -1697,8 +1764,8 @@ declare class RegExpTsDsl extends Mixed$17 {
 }
 //#endregion
 //#region src/ts-dsl/expr/ternary.d.ts
-declare const Mixed$16: abstract new () => TsDsl<ts.ConditionalExpression>;
-declare class TernaryTsDsl extends Mixed$16 {
+declare const Mixed$17: abstract new () => TsDsl<ts.ConditionalExpression>;
+declare class TernaryTsDsl extends Mixed$17 {
   readonly '~dsl' = "TernaryTsDsl";
   protected _condition?: string | MaybeTsDsl<ts.Expression>;
   protected _then?: string | MaybeTsDsl<ts.Expression>;
@@ -1727,17 +1794,84 @@ declare class NewlineTsDsl extends TsDsl<ts.Identifier> {
 }
 //#endregion
 //#region src/ts-dsl/stmt/block.d.ts
-declare const Mixed$15: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.Block>, LayoutMethods>, DoMethods>;
-declare class BlockTsDsl extends Mixed$15 {
+declare const Mixed$16: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.Block>, LayoutMethods>, DoMethods>;
+declare class BlockTsDsl extends Mixed$16 {
   readonly '~dsl' = "BlockTsDsl";
   constructor(...items: Array<DoExpr>);
   analyze(ctx: AnalysisContext): void;
   toAst(): ts.Block;
 }
 //#endregion
+//#region src/ts-dsl/stmt/var.d.ts
+declare const Mixed$15: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.VariableStatement>, ValueMethods>, PatternMethods>, HintMethods>, ExportMethods>, DocMethods>, DefaultMethods>;
+declare class VarTsDsl extends Mixed$15 {
+  readonly '~dsl' = "VarTsDsl";
+  readonly nameSanitizer: (name: string) => string;
+  protected kind: ts.NodeFlags;
+  protected _type?: TypeTsDsl;
+  constructor(name?: NodeName);
+  analyze(ctx: AnalysisContext): void;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  const(): this;
+  let(): this;
+  /** Sets the variable type. */
+  type(node: NodeName | TypeTsDsl): this;
+  var(): this;
+  toAst(): ts.VariableStatement;
+  $validate(): asserts this;
+  private missingRequiredCalls;
+}
+//#endregion
+//#region src/ts-dsl/stmt/for.d.ts
+type ForMode = 'for' | 'in' | 'of';
+type ForCondition = MaybeTsDsl<ts.Expression>;
+type ForIterable = MaybeTsDsl<ts.Expression>;
+declare const Mixed$14: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ForStatement>, LayoutMethods>, DoMethods>;
+declare class ImplForTsDsl<M extends ForMode = 'for'> extends Mixed$14 {
+  readonly '~dsl' = "ForTsDsl";
+  protected _await?: boolean;
+  protected _condition?: ForCondition;
+  protected _iterableOrUpdate?: ForIterable;
+  protected _mode: ForMode;
+  protected _variableOrInit?: VarTsDsl;
+  constructor();
+  analyze(ctx: AnalysisContext): void;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  /** Enables async iteration (`for await...of`). Can only be called on for...of. */
+  await(): ForTsDsl<'of'>;
+  /** Sets the condition (e.g., `i < n`). */
+  condition(condition: ForCondition): this;
+  /** Sets the iteration variable (e.g., `$.const('item')`). */
+  each(variable: VarTsDsl): this;
+  /** Sets the object to iterate over and switches to for...in. */
+  in(iterable?: ForIterable): ForTsDsl<'in'>;
+  /** Sets the initialization (e.g., `let i = 0`). */
+  init(init: VarTsDsl): this;
+  /** Sets the iterable to iterate over. */
+  iterable(iterable: ForIterable): this;
+  /** Sets the iterable to iterate over and switches to for...of. */
+  of(iterable?: ForIterable): ForTsDsl<'of'>;
+  /** Sets the update expression (e.g., `i++`). */
+  update(update: ForIterable): this;
+  toAst(): M extends 'for' ? ts.ForStatement : M extends 'of' ? ts.ForOfStatement : ts.ForInStatement;
+  $validate(): asserts this is this & {
+    _iterableOrUpdate: ForIterable;
+    _variableOrInit: VarTsDsl;
+  };
+  private missingRequiredCalls;
+}
+declare const ForTsDsl: {
+  new (variableOrInit?: VarTsDsl): ForTsDsl<ForMode>;
+  new (variableOrInit: VarTsDsl, condition: ForCondition, iterableOrUpdate?: ForIterable): ForTsDsl<"for">;
+  new <T extends ForMode>(variableOrInit: VarTsDsl, mode: T, iterableOrUpdate?: ForIterable): ForTsDsl<T>;
+} & typeof ImplForTsDsl;
+type ForTsDsl<M extends ForMode = 'for'> = ImplForTsDsl<M>;
+//#endregion
 //#region src/ts-dsl/stmt/stmt.d.ts
-declare const Mixed$14: abstract new () => TsDsl<ts.Statement>;
-declare class StmtTsDsl extends Mixed$14 {
+declare const Mixed$13: abstract new () => TsDsl<ts.Statement>;
+declare class StmtTsDsl extends Mixed$13 {
   readonly '~dsl' = "StmtTsDsl";
   protected _inner: ts.Expression | ts.Statement | TsDsl<any>;
   constructor(inner: ts.Expression | ts.Statement | TsDsl<any>);
@@ -1746,8 +1880,8 @@ declare class StmtTsDsl extends Mixed$14 {
 }
 //#endregion
 //#region src/ts-dsl/stmt/throw.d.ts
-declare const Mixed$13: abstract new () => TsDsl<ts.ThrowStatement>;
-declare class ThrowTsDsl extends Mixed$13 {
+declare const Mixed$12: abstract new () => TsDsl<ts.ThrowStatement>;
+declare class ThrowTsDsl extends Mixed$12 {
   readonly '~dsl' = "ThrowTsDsl";
   protected error: string | MaybeTsDsl<ts.Expression>;
   protected msg?: string | MaybeTsDsl<ts.Expression>;
@@ -1759,8 +1893,8 @@ declare class ThrowTsDsl extends Mixed$13 {
 }
 //#endregion
 //#region src/ts-dsl/stmt/try.d.ts
-declare const Mixed$12: abstract new () => TsDsl<ts.TryStatement>;
-declare class TryTsDsl extends Mixed$12 {
+declare const Mixed$11: abstract new () => TsDsl<ts.TryStatement>;
+declare class TryTsDsl extends Mixed$11 {
   readonly '~dsl' = "TryTsDsl";
   protected _catch?: Array<DoExpr>;
   protected _catchArg?: NodeName;
@@ -1781,27 +1915,6 @@ declare class TryTsDsl extends Mixed$12 {
   private missingRequiredCalls;
 }
 //#endregion
-//#region src/ts-dsl/stmt/var.d.ts
-declare const Mixed$11: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.VariableStatement>, ValueMethods>, PatternMethods>, HintMethods>, ExportMethods>, DocMethods>, DefaultMethods>;
-declare class VarTsDsl extends Mixed$11 {
-  readonly '~dsl' = "VarTsDsl";
-  readonly nameSanitizer: (name: string) => string;
-  protected kind: ts.NodeFlags;
-  protected _type?: TypeTsDsl;
-  constructor(name?: NodeName);
-  analyze(ctx: AnalysisContext): void;
-  /** Returns true when all required builder calls are present. */
-  get isValid(): boolean;
-  const(): this;
-  let(): this;
-  /** Sets the variable type. */
-  type(type: string | TypeTsDsl): this;
-  var(): this;
-  toAst(): ts.VariableStatement;
-  $validate(): asserts this;
-  private missingRequiredCalls;
-}
-//#endregion
 //#region src/ts-dsl/token.d.ts
 declare class TokenTsDsl<K extends ts.SyntaxKind = never> extends TsDsl<ts.Token<K>> {
   readonly '~dsl' = "TokenTsDsl";
@@ -2021,14 +2134,15 @@ declare class TypeTemplateTsDsl extends Mixed$1 {
 }
 //#endregion
 //#region src/ts-dsl/type/tuple.d.ts
+type TupleElement = string | ts.TypeNode | TypeTsDsl;
 declare const Mixed: abstract new () => TsDsl<ts.TupleTypeNode>;
 declare class TypeTupleTsDsl extends Mixed {
   readonly '~dsl' = "TypeTupleTsDsl";
   scope: NodeScope;
-  protected _elements: Array<string | ts.TypeNode | TypeTsDsl>;
-  constructor(...nodes: Array<string | ts.TypeNode | TypeTsDsl>);
+  protected _elements: Array<TupleElement>;
+  constructor(...nodes: Array<TupleElement>);
   analyze(ctx: AnalysisContext): void;
-  elements(...types: Array<string | ts.TypeNode | TypeTsDsl>): this;
+  elements(...types: Array<TupleElement>): this;
   toAst(): ts.TupleTypeNode;
 }
 //#endregion
@@ -2061,10 +2175,10 @@ declare const regexp: {
 //#endregion
 //#region src/ts-dsl/utils/render-utils.d.ts
 type ModuleExport = Omit<ExportModule, 'from'> & {
-  /** Module specifier for re-exports, e.g. `./foo`. */modulePath: string;
+  /** Module specifier for re-exports, e.g., `./foo`. */modulePath: string;
 };
 type ModuleImport = Omit<ImportModule, 'from'> & {
-  /** Module specifier for imports, e.g. `./foo`. */modulePath: string;
+  /** Module specifier for imports, e.g., `./foo`. */modulePath: string;
 };
 //#endregion
 //#region src/ts-dsl/utils/render.d.ts
@@ -2153,56 +2267,66 @@ declare const reserved: {
 };
 //#endregion
 //#region src/ts-dsl/index.d.ts
-declare const $: ((id: ts.Expression | TsDsl<ts.Expression> | _hey_api_codegen_core0.NodeName) => ExprTsDsl) & {
-  /** Creates an array literal expression (e.g. `[1, 2, 3]`). */array: (...args: ConstructorParameters<typeof ArrayTsDsl>) => ArrayTsDsl; /** Creates an `as` type assertion expression (e.g. `value as Type`). */
-  as: (expr: AsExpr, type: AsType) => AsTsDsl; /** Creates a property access expression (e.g. `obj.foo`). */
-  attr: (left: AttrLeft, right: _hey_api_codegen_core0.NodeName) => AttrTsDsl; /** Creates an await expression (e.g. `await promise`). */
-  await: (expr: AwaitExpr) => AwaitTsDsl; /** Creates a binary expression (e.g. `a + b`). */
-  binary: (base: ts.Expression | TsDsl<ts.Expression> | _hey_api_codegen_core0.NodeName, op?: (("!=" | "!==" | "&&" | "*" | "+" | "-" | "/" | "<" | "<=" | "=" | "==" | "===" | ">" | ">=" | "??" | "??=" | "||") | ts.BinaryOperator) | undefined, expr?: (ts.Expression | TsDsl<ts.Expression> | _hey_api_codegen_core0.NodeName) | undefined) => BinaryTsDsl; /** Creates a statement block (`{ ... }`). */
-  block: (...args: ConstructorParameters<typeof BlockTsDsl>) => BlockTsDsl; /** Creates a function or method call expression (e.g. `fn(arg)`). */
+declare const $: ((id: ts.Expression | TsDsl<ts.Expression> | NodeName) => ExprTsDsl) & {
+  /** Creates an array literal expression (e.g., `[1, 2, 3]`). */array: (...args: ConstructorParameters<typeof ArrayTsDsl>) => ArrayTsDsl; /** Creates an `as` type assertion expression (e.g., `value as Type`). */
+  as: (expr: AsExpr, type: AsType) => AsTsDsl; /** Creates a property access expression (e.g., `obj.foo`). */
+  attr: (left: AttrLeft, right: NodeName) => AttrTsDsl; /** Creates an await expression (e.g., `await promise`). */
+  await: (expr: AwaitExpr) => AwaitTsDsl; /** Creates a binary expression (e.g., `a + b`). */
+  binary: (base: ts.Expression | TsDsl<ts.Expression> | NodeName, op?: (("!=" | "!==" | "&&" | "*" | "+" | "-" | "/" | "<" | "<=" | "=" | "==" | "===" | ">" | ">=" | "??" | "??=" | "||") | ts.BinaryOperator) | undefined, expr?: (ts.Expression | TsDsl<ts.Expression> | NodeName) | undefined) => BinaryTsDsl; /** Creates a statement block (`{ ... }`). */
+  block: (...args: ConstructorParameters<typeof BlockTsDsl>) => BlockTsDsl; /** Creates a function or method call expression (e.g., `fn(arg)`). */
   call: (callee: CallCallee, ...args: (CallCallee | undefined)[]) => CallTsDsl; /** Creates a class declaration or expression. */
-  class: (name: _hey_api_codegen_core0.NodeName) => ClassTsDsl; /** Creates a constant variable declaration (`const`). */
-  const: (name?: _hey_api_codegen_core0.NodeName | undefined) => VarTsDsl; /** Creates a decorator expression (e.g. `@decorator`). */
-  decorator: (name: _hey_api_codegen_core0.NodeName, ...args: (string | ts.Expression | TsDsl<ts.Expression>)[]) => DecoratorTsDsl; /** Creates a JSDoc documentation block. */
+  class: (name: NodeName) => ClassTsDsl; /** Creates a constant variable declaration (`const`). */
+  const: (name?: NodeName | undefined) => VarTsDsl; /** Creates a postfix decrement expression (`i--`). */
+  dec: (expr?: PostfixExpr | undefined, op?: ts.PostfixUnaryOperator | undefined) => PostfixTsDsl; /** Creates a decorator expression (e.g., `@decorator`). */
+  decorator: (name: NodeName, ...args: (string | ts.Expression | TsDsl<ts.Expression>)[]) => DecoratorTsDsl; /** Creates a JSDoc documentation block. */
   doc: (lines?: DocLines | undefined, fn?: DocFn | undefined) => DocTsDsl; /** Creates an enum declaration. */
-  enum: (name: _hey_api_codegen_core0.NodeName, fn?: ((e: EnumTsDsl) => void) | undefined) => EnumTsDsl; /** Creates a general expression node. */
-  expr: (id: ts.Expression | TsDsl<ts.Expression> | _hey_api_codegen_core0.NodeName) => ExprTsDsl; /** Creates a field declaration in a class or object. */
-  field: (name: _hey_api_codegen_core0.NodeName, fn?: ((f: FieldTsDsl) => void) | undefined) => FieldTsDsl; /** Converts a runtime value into a corresponding expression node. */
+  enum: (name: NodeName, fn?: ((e: EnumTsDsl) => void) | undefined) => EnumTsDsl; /** Creates a general expression node. */
+  expr: (id: ts.Expression | TsDsl<ts.Expression> | NodeName) => ExprTsDsl; /** Creates a field declaration in a class or object. */
+  field: (name: NodeName, fn?: ((f: FieldTsDsl) => void) | undefined) => FieldTsDsl; /** Creates a for loop (for, for...of, for...in, or for await...of). */
+  for: {
+    (variableOrInit?: VarTsDsl): ForTsDsl<ForMode>;
+    (variableOrInit: VarTsDsl, condition: ForCondition, iterableOrUpdate?: ForIterable): ForTsDsl<"for">;
+    <T extends ForMode>(variableOrInit: VarTsDsl, mode: T, iterableOrUpdate?: ForIterable): ForTsDsl<T>;
+  }; /** Converts a runtime value into a corresponding expression node. */
   fromValue: (input: unknown, options?: {
     layout?: "pretty";
   } | undefined) => TsDsl<ts.Expression>; /** Creates a function expression or declaration. */
   func: {
     (): FuncTsDsl<"arrow">;
     (fn: (f: FuncTsDsl<"arrow">) => void): FuncTsDsl<"arrow">;
-    (name: string): FuncTsDsl<"decl">;
-    (name: string, fn: (f: FuncTsDsl<"decl">) => void): FuncTsDsl<"decl">;
-    (name?: string, fn?: (f: FuncTsDsl<"decl">) => void): FuncTsDsl<"arrow"> | FuncTsDsl<"decl">;
+    (name: NodeName): FuncTsDsl<"decl">;
+    (name: NodeName, fn: (f: FuncTsDsl<"decl">) => void): FuncTsDsl<"decl">;
+    (name?: NodeName, fn?: (f: FuncTsDsl<"decl">) => void): FuncTsDsl<"arrow"> | FuncTsDsl<"decl">;
   }; /** Creates a getter method declaration. */
-  getter: (name: _hey_api_codegen_core0.NodeName, fn?: ((g: GetterTsDsl) => void) | undefined) => GetterTsDsl; /** Creates a single-line comment (//). */
-  hint: (lines?: HintLines | undefined, fn?: HintFn | undefined) => HintTsDsl; /** Creates an identifier (e.g. `foo`). */
+  getter: (name: NodeName, fn?: ((g: GetterTsDsl) => void) | undefined) => GetterTsDsl; /** Creates a single-line comment (//). */
+  hint: (lines?: HintLines | undefined, fn?: HintFn | undefined) => HintTsDsl; /** Creates an identifier (e.g., `foo`). */
   id: (name: string) => IdTsDsl; /** Creates an if statement. */
-  if: (condition?: IfCondition | undefined) => IfTsDsl; /** Creates an initialization block or statement. */
+  if: (condition?: IfCondition | undefined) => IfTsDsl; /** Creates a postfix increment expression (`i++`). */
+  inc: (expr?: PostfixExpr | undefined, op?: ts.PostfixUnaryOperator | undefined) => PostfixTsDsl; /** Creates an initialization block or statement. */
   init: (fn?: ((i: InitTsDsl) => void) | undefined) => InitTsDsl; /** Creates a lazy, context-aware node with deferred evaluation. */
   lazy: <T extends ts.Node>(thunk: LazyThunk<T>) => LazyTsDsl<T>; /** Creates a let variable declaration (`let`). */
-  let: (name?: _hey_api_codegen_core0.NodeName | undefined) => VarTsDsl; /** Creates a literal value (e.g. string, number, boolean). */
+  let: (name?: NodeName | undefined) => VarTsDsl; /** Creates a literal value (e.g., string, number, boolean). */
   literal: (value: TsLiteralValue) => LiteralTsDsl; /** Creates an enum member declaration. */
-  member: (name: _hey_api_codegen_core0.NodeName, value?: ((string | number | ts.Expression | TsDsl<ts.Expression>) | ((m: EnumMemberTsDsl) => void)) | undefined) => EnumMemberTsDsl; /** Creates a method declaration inside a class or object. */
-  method: (name: _hey_api_codegen_core0.NodeName, fn?: ((m: MethodTsDsl) => void) | undefined) => MethodTsDsl; /** Creates a negation expression (`-x`). */
-  neg: (expr?: string | ts.Expression | TsDsl<ts.Expression> | undefined, op?: ts.PrefixUnaryOperator | undefined) => PrefixTsDsl; /** Creates a new expression (e.g. `new ClassName()`). */
+  member: (name: NodeName, value?: ((string | number | ts.Expression | TsDsl<ts.Expression>) | ((m: EnumMemberTsDsl) => void)) | undefined) => EnumMemberTsDsl; /** Creates a method declaration inside a class or object. */
+  method: (name: NodeName, fn?: ((m: MethodTsDsl) => void) | undefined) => MethodTsDsl; /** Creates a negation expression (`-x`). */
+  neg: (expr?: PrefixExpr | undefined, op?: ts.PrefixUnaryOperator | undefined) => PrefixTsDsl; /** Creates a new expression (e.g., `new ClassName()`). */
   new: (expr: NewExpr, ...args: (NewExpr | undefined)[]) => NewTsDsl; /** Creates a newline (for formatting purposes). */
   newline: () => NewlineTsDsl; /** Creates a logical NOT expression (`!x`). */
-  not: (expr?: string | ts.Expression | TsDsl<ts.Expression> | undefined, op?: ts.PrefixUnaryOperator | undefined) => PrefixTsDsl; /** Creates a block comment (/* ... *\/). */
+  not: (expr?: PrefixExpr | undefined, op?: ts.PrefixUnaryOperator | undefined) => PrefixTsDsl; /** Creates a block comment (/* ... *\/). */
   note: (lines?: NoteLines | undefined, fn?: NoteFn | undefined) => NoteTsDsl; /** Creates an object literal expression. */
   object: (...args: ConstructorParameters<typeof ObjectTsDsl>) => ObjectTsDsl; /** Creates a parameter declaration for functions or methods. */
   param: (name: ParamName, fn?: ParamFn | undefined) => ParamTsDsl; /** Creates a pattern for destructuring or matching. */
-  pattern: () => PatternTsDsl; /** Creates a prefix unary expression (e.g. `-x`, `!x`, `~x`). */
-  prefix: (expr?: string | ts.Expression | TsDsl<ts.Expression> | undefined, op?: ts.PrefixUnaryOperator | undefined) => PrefixTsDsl; /** Creates an object literal property (e.g. `{ foo: bar }`). */
+  pattern: () => PatternTsDsl; /** Creates a prefix unary expression (e.g., `-x`, `!x`, `~x`). */
+  prefix: (expr?: PrefixExpr | undefined, op?: ts.PrefixUnaryOperator | undefined) => PrefixTsDsl; /** Creates an object literal property (e.g., `{ foo: bar }`). */
   prop: (meta: {
     kind: "computed";
     name: string;
   } | {
     kind: "getter";
     name: string;
+  } | {
+    kind: "method";
+    name: string;
   } | {
     kind: "prop";
     name: string;
@@ -2212,36 +2336,38 @@ declare const $: ((id: ts.Expression | TsDsl<ts.Expression> | _hey_api_codegen_c
   } | {
     kind: "spread";
     name?: undefined;
-  }) => ObjectPropTsDsl; /** Creates a regular expression literal (e.g. `/foo/gi`). */
+  }) => ObjectPropTsDsl; /** Creates a regular expression literal (e.g., `/foo/gi`). */
   regexp: (pattern: string, flags?: ("" | "g" | "i" | "m" | "s" | "u" | "y" | "uy" | "yu" | "su" | "sy" | "suy" | "syu" | "ys" | "us" | "usy" | "uys" | "ysu" | "yus" | "ms" | "mu" | "my" | "muy" | "myu" | "msu" | "msy" | "msuy" | "msyu" | "mys" | "mus" | "musy" | "muys" | "mysu" | "myus" | "ym" | "um" | "umy" | "uym" | "ymu" | "yum" | "sm" | "smu" | "smy" | "smuy" | "smyu" | "sym" | "sum" | "sumy" | "suym" | "symu" | "syum" | "yms" | "ysm" | "ums" | "umsy" | "umys" | "usm" | "usmy" | "usym" | "uyms" | "uysm" | "ymsu" | "ymus" | "ysmu" | "ysum" | "yums" | "yusm" | "im" | "is" | "iu" | "iy" | "iuy" | "iyu" | "isu" | "isy" | "isuy" | "isyu" | "iys" | "ius" | "iusy" | "iuys" | "iysu" | "iyus" | "ims" | "imu" | "imy" | "imuy" | "imyu" | "imsu" | "imsy" | "imsuy" | "imsyu" | "imys" | "imus" | "imusy" | "imuys" | "imysu" | "imyus" | "iym" | "ium" | "iumy" | "iuym" | "iymu" | "iyum" | "ism" | "ismu" | "ismy" | "ismuy" | "ismyu" | "isym" | "isum" | "isumy" | "isuym" | "isymu" | "isyum" | "iyms" | "iysm" | "iums" | "iumsy" | "iumys" | "iusm" | "iusmy" | "iusym" | "iuyms" | "iuysm" | "iymsu" | "iymus" | "iysmu" | "iysum" | "iyums" | "iyusm" | "yi" | "ui" | "uiy" | "uyi" | "yiu" | "yui" | "si" | "siu" | "siy" | "siuy" | "siyu" | "syi" | "sui" | "suiy" | "suyi" | "syiu" | "syui" | "yis" | "ysi" | "uis" | "uisy" | "uiys" | "usi" | "usiy" | "usyi" | "uyis" | "uysi" | "yisu" | "yius" | "ysiu" | "ysui" | "yuis" | "yusi" | "mi" | "mis" | "miu" | "miy" | "miuy" | "miyu" | "misu" | "misy" | "misuy" | "misyu" | "miys" | "mius" | "miusy" | "miuys" | "miysu" | "miyus" | "myi" | "mui" | "muiy" | "muyi" | "myiu" | "myui" | "msi" | "msiu" | "msiy" | "msiuy" | "msiyu" | "msyi" | "msui" | "msuiy" | "msuyi" | "msyiu" | "msyui" | "myis" | "mysi" | "muis" | "muisy" | "muiys" | "musi" | "musiy" | "musyi" | "muyis" | "muysi" | "myisu" | "myius" | "mysiu" | "mysui" | "myuis" | "myusi" | "yim" | "ymi" | "uim" | "uimy" | "uiym" | "umi" | "umiy" | "umyi" | "uyim" | "uymi" | "yimu" | "yium" | "ymiu" | "ymui" | "yuim" | "yumi" | "sim" | "simu" | "simy" | "simuy" | "simyu" | "siym" | "sium" | "siumy" | "siuym" | "siymu" | "siyum" | "smi" | "smiu" | "smiy" | "smiuy" | "smiyu" | "smyi" | "smui" | "smuiy" | "smuyi" | "smyiu" | "smyui" | "syim" | "symi" | "suim" | "suimy" | "suiym" | "sumi" | "sumiy" | "sumyi" | "suyim" | "suymi" | "syimu" | "syium" | "symiu" | "symui" | "syuim" | "syumi" | "yims" | "yism" | "ymis" | "ymsi" | "ysim" | "ysmi" | "uims" | "uimsy" | "uimys" | "uism" | "uismy" | "uisym" | "uiyms" | "uiysm" | "umis" | "umisy" | "umiys" | "umsi" | "umsiy" | "umsyi" | "umyis" | "umysi" | "usim" | "usimy" | "usiym" | "usmi" | "usmiy" | "usmyi" | "usyim" | "usymi" | "uyims" | "uyism" | "uymis" | "uymsi" | "uysim" | "uysmi" | "yimsu" | "yimus" | "yismu" | "yisum" | "yiums" | "yiusm" | "ymisu" | "ymius" | "ymsiu" | "ymsui" | "ymuis" | "ymusi" | "ysimu" | "ysium" | "ysmiu" | "ysmui" | "ysuim" | "ysumi" | "yuims" | "yuism" | "yumis" | "yumsi" | "yusim" | "yusmi" | "gi" | "gm" | "gs" | "gu" | "gy" | "guy" | "gyu" | "gsu" | "gsy" | "gsuy" | "gsyu" | "gys" | "gus" | "gusy" | "guys" | "gysu" | "gyus" | "gms" | "gmu" | "gmy" | "gmuy" | "gmyu" | "gmsu" | "gmsy" | "gmsuy" | "gmsyu" | "gmys" | "gmus" | "gmusy" | "gmuys" | "gmysu" | "gmyus" | "gym" | "gum" | "gumy" | "guym" | "gymu" | "gyum" | "gsm" | "gsmu" | "gsmy" | "gsmuy" | "gsmyu" | "gsym" | "gsum" | "gsumy" | "gsuym" | "gsymu" | "gsyum" | "gyms" | "gysm" | "gums" | "gumsy" | "gumys" | "gusm" | "gusmy" | "gusym" | "guyms" | "guysm" | "gymsu" | "gymus" | "gysmu" | "gysum" | "gyums" | "gyusm" | "gim" | "gis" | "giu" | "giy" | "giuy" | "giyu" | "gisu" | "gisy" | "gisuy" | "gisyu" | "giys" | "gius" | "giusy" | "giuys" | "giysu" | "giyus" | "gims" | "gimu" | "gimy" | "gimuy" | "gimyu" | "gimsu" | "gimsy" | "gimsuy" | "gimsyu" | "gimys" | "gimus" | "gimusy" | "gimuys" | "gimysu" | "gimyus" | "giym" | "gium" | "giumy" | "giuym" | "giymu" | "giyum" | "gism" | "gismu" | "gismy" | "gismuy" | "gismyu" | "gisym" | "gisum" | "gisumy" | "gisuym" | "gisymu" | "gisyum" | "giyms" | "giysm" | "giums" | "giumsy" | "giumys" | "giusm" | "giusmy" | "giusym" | "giuyms" | "giuysm" | "giymsu" | "giymus" | "giysmu" | "giysum" | "giyums" | "giyusm" | "gyi" | "gui" | "guiy" | "guyi" | "gyiu" | "gyui" | "gsi" | "gsiu" | "gsiy" | "gsiuy" | "gsiyu" | "gsyi" | "gsui" | "gsuiy" | "gsuyi" | "gsyiu" | "gsyui" | "gyis" | "gysi" | "guis" | "guisy" | "guiys" | "gusi" | "gusiy" | "gusyi" | "guyis" | "guysi" | "gyisu" | "gyius" | "gysiu" | "gysui" | "gyuis" | "gyusi" | "gmi" | "gmis" | "gmiu" | "gmiy" | "gmiuy" | "gmiyu" | "gmisu" | "gmisy" | "gmisuy" | "gmisyu" | "gmiys" | "gmius" | "gmiusy" | "gmiuys" | "gmiysu" | "gmiyus" | "gmyi" | "gmui" | "gmuiy" | "gmuyi" | "gmyiu" | "gmyui" | "gmsi" | "gmsiu" | "gmsiy" | "gmsiuy" | "gmsiyu" | "gmsyi" | "gmsui" | "gmsuiy" | "gmsuyi" | "gmsyiu" | "gmsyui" | "gmyis" | "gmysi" | "gmuis" | "gmuisy" | "gmuiys" | "gmusi" | "gmusiy" | "gmusyi" | "gmuyis" | "gmuysi" | "gmyisu" | "gmyius" | "gmysiu" | "gmysui" | "gmyuis" | "gmyusi" | "gyim" | "gymi" | "guim" | "guimy" | "guiym" | "gumi" | "gumiy" | "gumyi" | "guyim" | "guymi" | "gyimu" | "gyium" | "gymiu" | "gymui" | "gyuim" | "gyumi" | "gsim" | "gsimu" | "gsimy" | "gsimuy" | "gsimyu" | "gsiym" | "gsium" | "gsiumy" | "gsiuym" | "gsiymu" | "gsiyum" | "gsmi" | "gsmiu" | "gsmiy" | "gsmiuy" | "gsmiyu" | "gsmyi" | "gsmui" | "gsmuiy" | "gsmuyi" | "gsmyiu" | "gsmyui" | "gsyim" | "gsymi" | "gsuim" | "gsuimy" | "gsuiym" | "gsumi" | "gsumiy" | "gsumyi" | "gsuyim" | "gsuymi" | "gsyimu" | "gsyium" | "gsymiu" | "gsymui" | "gsyuim" | "gsyumi" | "gyims" | "gyism" | "gymis" | "gymsi" | "gysim" | "gysmi" | "guims" | "guimsy" | "guimys" | "guism" | "guismy" | "guisym" | "guiyms" | "guiysm" | "gumis" | "gumisy" | "gumiys" | "gumsi" | "gumsiy" | "gumsyi" | "gumyis" | "gumysi" | "gusim" | "gusimy" | "gusiym" | "gusmi" | "gusmiy" | "gusmyi" | "gusyim" | "gusymi" | "guyims" | "guyism" | "guymis" | "guymsi" | "guysim" | "guysmi" | "gyimsu" | "gyimus" | "gyismu" | "gyisum" | "gyiums" | "gyiusm" | "gymisu" | "gymius" | "gymsiu" | "gymsui" | "gymuis" | "gymusi" | "gysimu" | "gysium" | "gysmiu" | "gysmui" | "gysuim" | "gysumi" | "gyuims" | "gyuism" | "gyumis" | "gyumsi" | "gyusim" | "gyusmi" | "yg" | "ug" | "ugy" | "uyg" | "ygu" | "yug" | "sg" | "sgu" | "sgy" | "sguy" | "sgyu" | "syg" | "sug" | "sugy" | "suyg" | "sygu" | "syug" | "ygs" | "ysg" | "ugs" | "ugsy" | "ugys" | "usg" | "usgy" | "usyg" | "uygs" | "uysg" | "ygsu" | "ygus" | "ysgu" | "ysug" | "yugs" | "yusg" | "mg" | "mgs" | "mgu" | "mgy" | "mguy" | "mgyu" | "mgsu" | "mgsy" | "mgsuy" | "mgsyu" | "mgys" | "mgus" | "mgusy" | "mguys" | "mgysu" | "mgyus" | "myg" | "mug" | "mugy" | "muyg" | "mygu" | "myug" | "msg" | "msgu" | "msgy" | "msguy" | "msgyu" | "msyg" | "msug" | "msugy" | "msuyg" | "msygu" | "msyug" | "mygs" | "mysg" | "mugs" | "mugsy" | "mugys" | "musg" | "musgy" | "musyg" | "muygs" | "muysg" | "mygsu" | "mygus" | "mysgu" | "mysug" | "myugs" | "myusg" | "ygm" | "ymg" | "ugm" | "ugmy" | "ugym" | "umg" | "umgy" | "umyg" | "uygm" | "uymg" | "ygmu" | "ygum" | "ymgu" | "ymug" | "yugm" | "yumg" | "sgm" | "sgmu" | "sgmy" | "sgmuy" | "sgmyu" | "sgym" | "sgum" | "sgumy" | "sguym" | "sgymu" | "sgyum" | "smg" | "smgu" | "smgy" | "smguy" | "smgyu" | "smyg" | "smug" | "smugy" | "smuyg" | "smygu" | "smyug" | "sygm" | "symg" | "sugm" | "sugmy" | "sugym" | "sumg" | "sumgy" | "sumyg" | "suygm" | "suymg" | "sygmu" | "sygum" | "symgu" | "symug" | "syugm" | "syumg" | "ygms" | "ygsm" | "ymgs" | "ymsg" | "ysgm" | "ysmg" | "ugms" | "ugmsy" | "ugmys" | "ugsm" | "ugsmy" | "ugsym" | "ugyms" | "ugysm" | "umgs" | "umgsy" | "umgys" | "umsg" | "umsgy" | "umsyg" | "umygs" | "umysg" | "usgm" | "usgmy" | "usgym" | "usmg" | "usmgy" | "usmyg" | "usygm" | "usymg" | "uygms" | "uygsm" | "uymgs" | "uymsg" | "uysgm" | "uysmg" | "ygmsu" | "ygmus" | "ygsmu" | "ygsum" | "ygums" | "ygusm" | "ymgsu" | "ymgus" | "ymsgu" | "ymsug" | "ymugs" | "ymusg" | "ysgmu" | "ysgum" | "ysmgu" | "ysmug" | "ysugm" | "ysumg" | "yugms" | "yugsm" | "yumgs" | "yumsg" | "yusgm" | "yusmg" | "ig" | "igm" | "igs" | "igu" | "igy" | "iguy" | "igyu" | "igsu" | "igsy" | "igsuy" | "igsyu" | "igys" | "igus" | "igusy" | "iguys" | "igysu" | "igyus" | "igms" | "igmu" | "igmy" | "igmuy" | "igmyu" | "igmsu" | "igmsy" | "igmsuy" | "igmsyu" | "igmys" | "igmus" | "igmusy" | "igmuys" | "igmysu" | "igmyus" | "igym" | "igum" | "igumy" | "iguym" | "igymu" | "igyum" | "igsm" | "igsmu" | "igsmy" | "igsmuy" | "igsmyu" | "igsym" | "igsum" | "igsumy" | "igsuym" | "igsymu" | "igsyum" | "igyms" | "igysm" | "igums" | "igumsy" | "igumys" | "igusm" | "igusmy" | "igusym" | "iguyms" | "iguysm" | "igymsu" | "igymus" | "igysmu" | "igysum" | "igyums" | "igyusm" | "iyg" | "iug" | "iugy" | "iuyg" | "iygu" | "iyug" | "isg" | "isgu" | "isgy" | "isguy" | "isgyu" | "isyg" | "isug" | "isugy" | "isuyg" | "isygu" | "isyug" | "iygs" | "iysg" | "iugs" | "iugsy" | "iugys" | "iusg" | "iusgy" | "iusyg" | "iuygs" | "iuysg" | "iygsu" | "iygus" | "iysgu" | "iysug" | "iyugs" | "iyusg" | "img" | "imgs" | "imgu" | "imgy" | "imguy" | "imgyu" | "imgsu" | "imgsy" | "imgsuy" | "imgsyu" | "imgys" | "imgus" | "imgusy" | "imguys" | "imgysu" | "imgyus" | "imyg" | "imug" | "imugy" | "imuyg" | "imygu" | "imyug" | "imsg" | "imsgu" | "imsgy" | "imsguy" | "imsgyu" | "imsyg" | "imsug" | "imsugy" | "imsuyg" | "imsygu" | "imsyug" | "imygs" | "imysg" | "imugs" | "imugsy" | "imugys" | "imusg" | "imusgy" | "imusyg" | "imuygs" | "imuysg" | "imygsu" | "imygus" | "imysgu" | "imysug" | "imyugs" | "imyusg" | "iygm" | "iymg" | "iugm" | "iugmy" | "iugym" | "iumg" | "iumgy" | "iumyg" | "iuygm" | "iuymg" | "iygmu" | "iygum" | "iymgu" | "iymug" | "iyugm" | "iyumg" | "isgm" | "isgmu" | "isgmy" | "isgmuy" | "isgmyu" | "isgym" | "isgum" | "isgumy" | "isguym" | "isgymu" | "isgyum" | "ismg" | "ismgu" | "ismgy" | "ismguy" | "ismgyu" | "ismyg" | "ismug" | "ismugy" | "ismuyg" | "ismygu" | "ismyug" | "isygm" | "isymg" | "isugm" | "isugmy" | "isugym" | "isumg" | "isumgy" | "isumyg" | "isuygm" | "isuymg" | "isygmu" | "isygum" | "isymgu" | "isymug" | "isyugm" | "isyumg" | "iygms" | "iygsm" | "iymgs" | "iymsg" | "iysgm" | "iysmg" | "iugms" | "iugmsy" | "iugmys" | "iugsm" | "iugsmy" | "iugsym" | "iugyms" | "iugysm" | "iumgs" | "iumgsy" | "iumgys" | "iumsg" | "iumsgy" | "iumsyg" | "iumygs" | "iumysg" | "iusgm" | "iusgmy" | "iusgym" | "iusmg" | "iusmgy" | "iusmyg" | "iusygm" | "iusymg" | "iuygms" | "iuygsm" | "iuymgs" | "iuymsg" | "iuysgm" | "iuysmg" | "iygmsu" | "iygmus" | "iygsmu" | "iygsum" | "iygums" | "iygusm" | "iymgsu" | "iymgus" | "iymsgu" | "iymsug" | "iymugs" | "iymusg" | "iysgmu" | "iysgum" | "iysmgu" | "iysmug" | "iysugm" | "iysumg" | "iyugms" | "iyugsm" | "iyumgs" | "iyumsg" | "iyusgm" | "iyusmg" | "ygi" | "yig" | "ugi" | "ugiy" | "ugyi" | "uig" | "uigy" | "uiyg" | "uygi" | "uyig" | "ygiu" | "ygui" | "yigu" | "yiug" | "yugi" | "yuig" | "sgi" | "sgiu" | "sgiy" | "sgiuy" | "sgiyu" | "sgyi" | "sgui" | "sguiy" | "sguyi" | "sgyiu" | "sgyui" | "sig" | "sigu" | "sigy" | "siguy" | "sigyu" | "siyg" | "siug" | "siugy" | "siuyg" | "siygu" | "siyug" | "sygi" | "syig" | "sugi" | "sugiy" | "sugyi" | "suig" | "suigy" | "suiyg" | "suygi" | "suyig" | "sygiu" | "sygui" | "syigu" | "syiug" | "syugi" | "syuig" | "ygis" | "ygsi" | "yigs" | "yisg" | "ysgi" | "ysig" | "ugis" | "ugisy" | "ugiys" | "ugsi" | "ugsiy" | "ugsyi" | "ugyis" | "ugysi" | "uigs" | "uigsy" | "uigys" | "uisg" | "uisgy" | "uisyg" | "uiygs" | "uiysg" | "usgi" | "usgiy" | "usgyi" | "usig" | "usigy" | "usiyg" | "usygi" | "usyig" | "uygis" | "uygsi" | "uyigs" | "uyisg" | "uysgi" | "uysig" | "ygisu" | "ygius" | "ygsiu" | "ygsui" | "yguis" | "ygusi" | "yigsu" | "yigus" | "yisgu" | "yisug" | "yiugs" | "yiusg" | "ysgiu" | "ysgui" | "ysigu" | "ysiug" | "ysugi" | "ysuig" | "yugis" | "yugsi" | "yuigs" | "yuisg" | "yusgi" | "yusig" | "mgi" | "mgis" | "mgiu" | "mgiy" | "mgiuy" | "mgiyu" | "mgisu" | "mgisy" | "mgisuy" | "mgisyu" | "mgiys" | "mgius" | "mgiusy" | "mgiuys" | "mgiysu" | "mgiyus" | "mgyi" | "mgui" | "mguiy" | "mguyi" | "mgyiu" | "mgyui" | "mgsi" | "mgsiu" | "mgsiy" | "mgsiuy" | "mgsiyu" | "mgsyi" | "mgsui" | "mgsuiy" | "mgsuyi" | "mgsyiu" | "mgsyui" | "mgyis" | "mgysi" | "mguis" | "mguisy" | "mguiys" | "mgusi" | "mgusiy" | "mgusyi" | "mguyis" | "mguysi" | "mgyisu" | "mgyius" | "mgysiu" | "mgysui" | "mgyuis" | "mgyusi" | "mig" | "migs" | "migu" | "migy" | "miguy" | "migyu" | "migsu" | "migsy" | "migsuy" | "migsyu" | "migys" | "migus" | "migusy" | "miguys" | "migysu" | "migyus" | "miyg" | "miug" | "miugy" | "miuyg" | "miygu" | "miyug" | "misg" | "misgu" | "misgy" | "misguy" | "misgyu" | "misyg" | "misug" | "misugy" | "misuyg" | "misygu" | "misyug" | "miygs" | "miysg" | "miugs" | "miugsy" | "miugys" | "miusg" | "miusgy" | "miusyg" | "miuygs" | "miuysg" | "miygsu" | "miygus" | "miysgu" | "miysug" | "miyugs" | "miyusg" | "mygi" | "myig" | "mugi" | "mugiy" | "mugyi" | "muig" | "muigy" | "muiyg" | "muygi" | "muyig" | "mygiu" | "mygui" | "myigu" | "myiug" | "myugi" | "myuig" | "msgi" | "msgiu" | "msgiy" | "msgiuy" | "msgiyu" | "msgyi" | "msgui" | "msguiy" | "msguyi" | "msgyiu" | "msgyui" | "msig" | "msigu" | "msigy" | "msiguy" | "msigyu" | "msiyg" | "msiug" | "msiugy" | "msiuyg" | "msiygu" | "msiyug" | "msygi" | "msyig" | "msugi" | "msugiy" | "msugyi" | "msuig" | "msuigy" | "msuiyg" | "msuygi" | "msuyig" | "msygiu" | "msygui" | "msyigu" | "msyiug" | "msyugi" | "msyuig" | "mygis" | "mygsi" | "myigs" | "myisg" | "mysgi" | "mysig" | "mugis" | "mugisy" | "mugiys" | "mugsi" | "mugsiy" | "mugsyi" | "mugyis" | "mugysi" | "muigs" | "muigsy" | "muigys" | "muisg" | "muisgy" | "muisyg" | "muiygs" | "muiysg" | "musgi" | "musgiy" | "musgyi" | "musig" | "musigy" | "musiyg" | "musygi" | "musyig" | "muygis" | "muygsi" | "muyigs" | "muyisg" | "muysgi" | "muysig" | "mygisu" | "mygius" | "mygsiu" | "mygsui" | "myguis" | "mygusi" | "myigsu" | "myigus" | "myisgu" | "myisug" | "myiugs" | "myiusg" | "mysgiu" | "mysgui" | "mysigu" | "mysiug" | "mysugi" | "mysuig" | "myugis" | "myugsi" | "myuigs" | "myuisg" | "myusgi" | "myusig" | "ygim" | "ygmi" | "yigm" | "yimg" | "ymgi" | "ymig" | "ugim" | "ugimy" | "ugiym" | "ugmi" | "ugmiy" | "ugmyi" | "ugyim" | "ugymi" | "uigm" | "uigmy" | "uigym" | "uimg" | "uimgy" | "uimyg" | "uiygm" | "uiymg" | "umgi" | "umgiy" | "umgyi" | "umig" | "umigy" | "umiyg" | "umygi" | "umyig" | "uygim" | "uygmi" | "uyigm" | "uyimg" | "uymgi" | "uymig" | "ygimu" | "ygium" | "ygmiu" | "ygmui" | "yguim" | "ygumi" | "yigmu" | "yigum" | "yimgu" | "yimug" | "yiugm" | "yiumg" | "ymgiu" | "ymgui" | "ymigu" | "ymiug" | "ymugi" | "ymuig" | "yugim" | "yugmi" | "yuigm" | "yuimg" | "yumgi" | "yumig" | "sgim" | "sgimu" | "sgimy" | "sgimuy" | "sgimyu" | "sgiym" | "sgium" | "sgiumy" | "sgiuym" | "sgiymu" | "sgiyum" | "sgmi" | "sgmiu" | "sgmiy" | "sgmiuy" | "sgmiyu" | "sgmyi" | "sgmui" | "sgmuiy" | "sgmuyi" | "sgmyiu" | "sgmyui" | "sgyim" | "sgymi" | "sguim" | "sguimy" | "sguiym" | "sgumi" | "sgumiy" | "sgumyi" | "sguyim" | "sguymi" | "sgyimu" | "sgyium" | "sgymiu" | "sgymui" | "sgyuim" | "sgyumi" | "sigm" | "sigmu" | "sigmy" | "sigmuy" | "sigmyu" | "sigym" | "sigum" | "sigumy" | "siguym" | "sigymu" | "sigyum" | "simg" | "simgu" | "simgy" | "simguy" | "simgyu" | "simyg" | "simug" | "simugy" | "simuyg" | "simygu" | "simyug" | "siygm" | "siymg" | "siugm" | "siugmy" | "siugym" | "siumg" | "siumgy" | "siumyg" | "siuygm" | "siuymg" | "siygmu" | "siygum" | "siymgu" | "siymug" | "siyugm" | "siyumg" | "smgi" | "smgiu" | "smgiy" | "smgiuy" | "smgiyu" | "smgyi" | "smgui" | "smguiy" | "smguyi" | "smgyiu" | "smgyui" | "smig" | "smigu" | "smigy" | "smiguy" | "smigyu" | "smiyg" | "smiug" | "smiugy" | "smiuyg" | "smiygu" | "smiyug" | "smygi" | "smyig" | "smugi" | "smugiy" | "smugyi" | "smuig" | "smuigy" | "smuiyg" | "smuygi" | "smuyig" | "smygiu" | "smygui" | "smyigu" | "smyiug" | "smyugi" | "smyuig" | "sygim" | "sygmi" | "syigm" | "syimg" | "symgi" | "symig" | "sugim" | "sugimy" | "sugiym" | "sugmi" | "sugmiy" | "sugmyi" | "sugyim" | "sugymi" | "suigm" | "suigmy" | "suigym" | "suimg" | "suimgy" | "suimyg" | "suiygm" | "suiymg" | "sumgi" | "sumgiy" | "sumgyi" | "sumig" | "sumigy" | "sumiyg" | "sumygi" | "sumyig" | "suygim" | "suygmi" | "suyigm" | "suyimg" | "suymgi" | "suymig" | "sygimu" | "sygium" | "sygmiu" | "sygmui" | "syguim" | "sygumi" | "syigmu" | "syigum" | "syimgu" | "syimug" | "syiugm" | "syiumg" | "symgiu" | "symgui" | "symigu" | "symiug" | "symugi" | "symuig" | "syugim" | "syugmi" | "syuigm" | "syuimg" | "syumgi" | "syumig" | "ygims" | "ygism" | "ygmis" | "ygmsi" | "ygsim" | "ygsmi" | "yigms" | "yigsm" | "yimgs" | "yimsg" | "yisgm" | "yismg" | "ymgis" | "ymgsi" | "ymigs" | "ymisg" | "ymsgi" | "ymsig" | "ysgim" | "ysgmi" | "ysigm" | "ysimg" | "ysmgi" | "ysmig" | "ugims" | "ugimsy" | "ugimys" | "ugism" | "ugismy" | "ugisym" | "ugiyms" | "ugiysm" | "ugmis" | "ugmisy" | "ugmiys" | "ugmsi" | "ugmsiy" | "ugmsyi" | "ugmyis" | "ugmysi" | "ugsim" | "ugsimy" | "ugsiym" | "ugsmi" | "ugsmiy" | "ugsmyi" | "ugsyim" | "ugsymi" | "ugyims" | "ugyism" | "ugymis" | "ugymsi" | "ugysim" | "ugysmi" | "uigms" | "uigmsy" | "uigmys" | "uigsm" | "uigsmy" | "uigsym" | "uigyms" | "uigysm" | "uimgs" | "uimgsy" | "uimgys" | "uimsg" | "uimsgy" | "uimsyg" | "uimygs" | "uimysg" | "uisgm" | "uisgmy" | "uisgym" | "uismg" | "uismgy" | "uismyg" | "uisygm" | "uisymg" | "uiygms" | "uiygsm" | "uiymgs" | "uiymsg" | "uiysgm" | "uiysmg" | "umgis" | "umgisy" | "umgiys" | "umgsi" | "umgsiy" | "umgsyi" | "umgyis" | "umgysi" | "umigs" | "umigsy" | "umigys" | "umisg" | "umisgy" | "umisyg" | "umiygs" | "umiysg" | "umsgi" | "umsgiy" | "umsgyi" | "umsig" | "umsigy" | "umsiyg" | "umsygi" | "umsyig" | "umygis" | "umygsi" | "umyigs" | "umyisg" | "umysgi" | "umysig" | "usgim" | "usgimy" | "usgiym" | "usgmi" | "usgmiy" | "usgmyi" | "usgyim" | "usgymi" | "usigm" | "usigmy" | "usigym" | "usimg" | "usimgy" | "usimyg" | "usiygm" | "usiymg" | "usmgi" | "usmgiy" | "usmgyi" | "usmig" | "usmigy" | "usmiyg" | "usmygi" | "usmyig" | "usygim" | "usygmi" | "usyigm" | "usyimg" | "usymgi" | "usymig" | "uygims" | "uygism" | "uygmis" | "uygmsi" | "uygsim" | "uygsmi" | "uyigms" | "uyigsm" | "uyimgs" | "uyimsg" | "uyisgm" | "uyismg" | "uymgis" | "uymgsi" | "uymigs" | "uymisg" | "uymsgi" | "uymsig" | "uysgim" | "uysgmi" | "uysigm" | "uysimg" | "uysmgi" | "uysmig" | "ygimsu" | "ygimus" | "ygismu" | "ygisum" | "ygiums" | "ygiusm" | "ygmisu" | "ygmius" | "ygmsiu" | "ygmsui" | "ygmuis" | "ygmusi" | "ygsimu" | "ygsium" | "ygsmiu" | "ygsmui" | "ygsuim" | "ygsumi" | "yguims" | "yguism" | "ygumis" | "ygumsi" | "ygusim" | "ygusmi" | "yigmsu" | "yigmus" | "yigsmu" | "yigsum" | "yigums" | "yigusm" | "yimgsu" | "yimgus" | "yimsgu" | "yimsug" | "yimugs" | "yimusg" | "yisgmu" | "yisgum" | "yismgu" | "yismug" | "yisugm" | "yisumg" | "yiugms" | "yiugsm" | "yiumgs" | "yiumsg" | "yiusgm" | "yiusmg" | "ymgisu" | "ymgius" | "ymgsiu" | "ymgsui" | "ymguis" | "ymgusi" | "ymigsu" | "ymigus" | "ymisgu" | "ymisug" | "ymiugs" | "ymiusg" | "ymsgiu" | "ymsgui" | "ymsigu" | "ymsiug" | "ymsugi" | "ymsuig" | "ymugis" | "ymugsi" | "ymuigs" | "ymuisg" | "ymusgi" | "ymusig" | "ysgimu" | "ysgium" | "ysgmiu" | "ysgmui" | "ysguim" | "ysgumi" | "ysigmu" | "ysigum" | "ysimgu" | "ysimug" | "ysiugm" | "ysiumg" | "ysmgiu" | "ysmgui" | "ysmigu" | "ysmiug" | "ysmugi" | "ysmuig" | "ysugim" | "ysugmi" | "ysuigm" | "ysuimg" | "ysumgi" | "ysumig" | "yugims" | "yugism" | "yugmis" | "yugmsi" | "yugsim" | "yugsmi" | "yuigms" | "yuigsm" | "yuimgs" | "yuimsg" | "yuisgm" | "yuismg" | "yumgis" | "yumgsi" | "yumigs" | "yumisg" | "yumsgi" | "yumsig" | "yusgim" | "yusgmi" | "yusigm" | "yusimg" | "yusmgi" | "yusmig") | undefined) => RegExpTsDsl; /** Creates a return statement. */
   return: (expr?: ReturnExpr | undefined) => ReturnTsDsl; /** Creates a setter method declaration. */
-  setter: (name: _hey_api_codegen_core0.NodeName, fn?: ((s: SetterTsDsl) => void) | undefined) => SetterTsDsl; /** Wraps an expression or statement-like value into a `StmtTsDsl`. */
+  setter: (name: NodeName, fn?: ((s: SetterTsDsl) => void) | undefined) => SetterTsDsl; /** Creates a spread element from an expression (e.g., `...expr`). */
+  spread: (expr: SpreadExpr) => SpreadTsDsl; /** Wraps an expression or statement-like value into a `StmtTsDsl`. */
   stmt: (inner: ts.Expression | ts.Statement | TsDsl<any>) => StmtTsDsl; /** Creates a template literal expression. */
   template: (value?: TemplatePart | undefined) => TemplateTsDsl; /** Creates a ternary conditional expression (if ? then : else). */
   ternary: (condition?: string | ts.Expression | TsDsl<ts.Expression> | undefined) => TernaryTsDsl; /** Creates a throw statement. */
-  throw: (error: string | ts.Expression | TsDsl<ts.Expression>, useNew?: boolean | undefined) => ThrowTsDsl; /** Creates a syntax token (e.g. `?`, `readonly`, `+`, `-`). */
+  throw: (error: string | ts.Expression | TsDsl<ts.Expression>, useNew?: boolean | undefined) => ThrowTsDsl; /** Creates a syntax token (e.g., `?`, `readonly`, `+`, `-`). */
   token: () => TokenTsDsl<never>; /** Creates a try/catch/finally statement. */
-  try: (...args: ConstructorParameters<typeof TryTsDsl>) => TryTsDsl; /** Creates a basic type reference or type expression (e.g. Foo or Foo<T>). */
-  type: ((name: _hey_api_codegen_core0.NodeName, fn?: TypeExprFn | undefined) => TypeExprTsDsl) & {
-    /** Creates a type alias declaration (e.g. `type Foo = Bar`). */alias: (name: _hey_api_codegen_core0.NodeName, fn?: ((t: TypeAliasTsDsl) => void) | undefined) => TypeAliasTsDsl; /** Creates an intersection type (e.g. `A & B`). */
-    and: (...args: ConstructorParameters<typeof TypeAndTsDsl>) => TypeAndTsDsl; /** Creates a qualified type reference (e.g. Foo.Bar). */
-    attr: (right: _hey_api_codegen_core0.NodeName | ts.Identifier) => TypeAttrTsDsl; /** Creates a basic type reference or type expression (e.g. Foo or Foo<T>). */
-    expr: (name: _hey_api_codegen_core0.NodeName, fn?: TypeExprFn | undefined) => TypeExprTsDsl; /** Converts a runtime value into a corresponding type expression node. */
-    fromValue: (input: unknown) => TsDsl<ts.TypeNode>; /** Creates a function type node (e.g. `(a: string) => number`). */
-    func: (...args: ConstructorParameters<typeof TypeFuncTsDsl>) => TypeFuncTsDsl; /** 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: TsLiteralValue) => TypeLiteralTsDsl; /** Creates a mapped type (e.g. `{ [K in keyof T]: U }`). */
-    mapped: (name?: _hey_api_codegen_core0.NodeName | undefined) => TypeMappedTsDsl; /** Creates a type literal node (e.g. { foo: string }). */
-    object: () => TypeObjectTsDsl; /** Creates a type operator node (e.g. `readonly T`, `keyof T`, `unique T`). */
-    operator: () => TypeOperatorTsDsl; /** Represents a union type (e.g. `A | B | C`). */
-    or: (...args: ConstructorParameters<typeof TypeOrTsDsl>) => TypeOrTsDsl; /** Creates a type parameter (e.g. `<T>`). */
-    param: (name?: _hey_api_codegen_core0.NodeName | undefined, fn?: ((name: TypeParamTsDsl) => void) | undefined) => TypeParamTsDsl; /** Creates a type query node (e.g. `typeof Foo`). */
-    query: (expr: TypeQueryExpr) => TypeQueryTsDsl; /** Builds a TypeScript template literal *type* (e.g. `${Foo}-${Bar}` as a type). */
-    template: (value?: string | ts.TypeNode | TsDsl<ts.TypeNode> | undefined) => TypeTemplateTsDsl; /** Creates a tuple type (e.g. [A, B, C]). */
-    tuple: (...args: ConstructorParameters<typeof TypeTupleTsDsl>) => TypeTupleTsDsl;
-  }; /** Creates a `typeof` expression (e.g. `typeof value`). */
+  try: (...args: ConstructorParameters<typeof TryTsDsl>) => TryTsDsl; /** Creates a basic type reference or type expression (e.g., Foo or Foo<T>). */
+  type: ((name: NodeName, fn?: TypeExprFn | undefined) => TypeExprTsDsl) & {
+    /** Creates a type alias declaration (e.g., `type Foo = Bar`). */alias: (name: NodeName, fn?: ((t: TypeAliasTsDsl) => void) | undefined) => TypeAliasTsDsl; /** Creates an intersection type (e.g., `A & B`). */
+    and: (...args: ConstructorParameters<typeof TypeAndTsDsl>) => TypeAndTsDsl; /** Creates a qualified type reference (e.g., Foo.Bar). */
+    attr: (right: NodeName | ts.Identifier) => TypeAttrTsDsl; /** Creates a basic type reference or type expression (e.g., Foo or Foo<T>). */
+    expr: (name: NodeName, fn?: TypeExprFn | undefined) => TypeExprTsDsl; /** Converts a runtime value into a corresponding type expression node. */
+    fromValue: (input: unknown) => TsDsl<ts.TypeNode>; /** Creates a function type node (e.g., `(a: string) => number`). */
+    func: (...args: ConstructorParameters<typeof TypeFuncTsDsl>) => TypeFuncTsDsl; /** 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: TsLiteralValue) => TypeLiteralTsDsl; /** Creates a mapped type (e.g., `{ [K in keyof T]: U }`). */
+    mapped: (name?: NodeName | undefined) => TypeMappedTsDsl; /** Creates a type literal node (e.g., { foo: string }). */
+    object: () => TypeObjectTsDsl; /** Creates a type operator node (e.g., `readonly T`, `keyof T`, `unique T`). */
+    operator: () => TypeOperatorTsDsl; /** Represents a union type (e.g., `A | B | C`). */
+    or: (...args: ConstructorParameters<typeof TypeOrTsDsl>) => TypeOrTsDsl; /** Creates a type parameter (e.g., `<T>`). */
+    param: (name?: NodeName | undefined, fn?: ((name: TypeParamTsDsl) => void) | undefined) => TypeParamTsDsl; /** Creates a type query node (e.g., `typeof Foo`). */
+    query: (expr: TypeQueryExpr) => TypeQueryTsDsl; /** Builds a TypeScript template literal *type* (e.g., `${Foo}-${Bar}` as a type). */
+    template: (value?: string | ts.TypeNode | TsDsl<ts.TypeNode> | undefined) => TypeTemplateTsDsl; /** Creates a tuple type (e.g., [A, B, C]). */
+    tuple: (...args: ConstructorParameters<typeof TypeTupleTsDsl>) => TypeTupleTsDsl; /** Creates a named tuple element (e.g., `[resolver?: R]`). */
+    tupleMember: (name: NodeName) => TypeTupleMemberTsDsl;
+  }; /** Creates a `typeof` expression (e.g., `typeof value`). */
   typeofExpr: (expr: TypeOfExpr) => TypeOfExprTsDsl; /** Creates a variable declaration (`var`). */
-  var: (name?: _hey_api_codegen_core0.NodeName | undefined) => VarTsDsl;
+  var: (name?: NodeName | undefined) => VarTsDsl;
 };
 type DollarTsDsl = {
   /**
@@ -2342,22 +2468,9 @@ type UserConfig$26 = Plugin$1.Name<'@faker-js/faker'> & Plugin$1.Hooks & Plugin$
   seed?: number;
 };
 type Config$23 = Plugin$1.Name<'@faker-js/faker'> & Plugin$1.Hooks & Plugin$1.Exports & {
-  /**
-   * Casing convention for generated names.
-   */
-  case: Casing;
-  /**
-   * Configuration for reusable schema definitions.
-   */
-  definitions: NamingOptions & FeatureToggle;
-  /**
-   * Faker locale for generated data.
-   */
-  locale: string;
-  /**
-   * Seed for deterministic output. When set, Faker will produce
-   * the same values across runs.
-   */
+  /** Casing convention for generated names. */case: Casing; /** Configuration for reusable schema definitions. */
+  definitions: NamingOptions & FeatureToggle; /** Faker locale for generated data. */
+  locale: string; /** Seed for deterministic output. */
   seed?: number;
 };
 type FakerJsFakerPlugin = DefinePlugin$1<UserConfig$26, Config$23, IApi$4>;
@@ -2510,7 +2623,7 @@ interface Config$22 {
   requestValidator?: (data: unknown) => Promise<unknown>;
   /**
    * A function transforming response data before it's returned. This is useful
-   * for post-processing data, e.g. converting ISO strings into Date objects.
+   * for post-processing data, e.g., converting ISO strings into Date objects.
    */
   responseTransformer?: (data: unknown) => Promise<unknown>;
   /**
@@ -2690,7 +2803,7 @@ interface ClientOptions$6 {
   throwOnError?: boolean;
 }
 type MethodFn$6 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$3 = 'fields'>(options: Omit<RequestOptions$6<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult$6<TData, TError, ThrowOnError, TResponseStyle>;
-type SseFn$6 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$3 = 'fields'>(options: Omit<RequestOptions$6<TData, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type SseFn$6 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$3 = 'fields'>(options: Omit<RequestOptions$6<never, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
 type RequestFn$6 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$3 = 'fields'>(options: Omit<RequestOptions$6<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions$6<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult$6<TData, TError, ThrowOnError, TResponseStyle>;
 type RequestOptionsFn = <T, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$3 = 'fields'>(options: RequestOptions$6<T, TResponseStyle, ThrowOnError>) => HttpRequest<T>;
 type BuildUrlFn$6 = <TData extends {
@@ -2698,20 +2811,20 @@ type BuildUrlFn$6 = <TData extends {
   path?: Record<string, unknown>;
   query?: Record<string, unknown>;
   url: string;
-}>(options: TData & Options$7<TData>) => string;
+}>(options: TData & Options$6<TData>) => string;
 type Client$7 = Client$8<RequestFn$6, Config$21, MethodFn$6, BuildUrlFn$6, SseFn$6> & {
   interceptors: Middleware$4<HttpRequest<unknown>, HttpResponse<unknown>, unknown, ResolvedRequestOptions$4>;
   requestOptions: RequestOptionsFn;
 };
-interface TDataShape$6 {
+interface TDataShape$5 {
   body?: unknown;
   headers?: unknown;
   path?: unknown;
   query?: unknown;
   url: string;
 }
-type OmitKeys$6<T, K> = Pick<T, Exclude<keyof T, K>>;
-type Options$7<TData extends TDataShape$6 = TDataShape$6, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle$3 = 'fields'> = OmitKeys$6<RequestOptions$6<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
+type OmitKeys$5<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options$6<TData extends TDataShape$5 = TDataShape$5, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle$3 = 'fields'> = OmitKeys$5<RequestOptions$6<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
 //#endregion
 //#region src/plugins/@hey-api/client-axios/bundle/types.d.ts
 interface Config$20<T extends ClientOptions$5 = ClientOptions$5> extends Omit<CreateAxiosDefaults, 'auth' | 'baseURL' | 'headers' | 'method'>, Config$22 {
@@ -2768,26 +2881,16 @@ type RequestResult$5<TData = unknown, TError = unknown, ThrowOnError extends boo
   error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
 })>;
 type MethodFn$5 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions$5<TData, ThrowOnError>, 'method'>) => RequestResult$5<TData, TError, ThrowOnError>;
-type SseFn$5 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions$5<TData, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type SseFn$5 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions$5<never, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
 type RequestFn$5 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions$5<TData, ThrowOnError>, 'method'> & Pick<Required<RequestOptions$5<TData, ThrowOnError>>, 'method'>) => RequestResult$5<TData, TError, ThrowOnError>;
 type BuildUrlFn$5 = <TData extends {
-  body?: unknown;
   path?: Record<string, unknown>;
   query?: Record<string, unknown>;
   url: string;
-}>(options: TData & Options$6<TData>) => string;
+}>(options: TData & Pick<RequestOptions$5<unknown, boolean>, 'axios' | 'baseURL' | 'paramsSerializer' | 'querySerializer'>) => string;
 type Client$6 = Client$8<RequestFn$5, Config$20, MethodFn$5, BuildUrlFn$5, SseFn$5> & {
   instance: AxiosInstance;
 };
-interface TDataShape$5 {
-  body?: unknown;
-  headers?: unknown;
-  path?: unknown;
-  query?: unknown;
-  url: string;
-}
-type OmitKeys$5<T, K> = Pick<T, Exclude<keyof T, K>>;
-type Options$6<TData extends TDataShape$5 = TDataShape$5, ThrowOnError extends boolean = boolean, TResponse = unknown> = OmitKeys$5<RequestOptions$5<TResponse, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
 //#endregion
 //#region src/plugins/@hey-api/client-axios/types.d.ts
 type UserConfig$25 = Plugin$1.Name<'@hey-api/client-axios'> & Client.Config & {
@@ -2903,7 +3006,7 @@ interface ClientOptions$4 {
   throwOnError?: boolean;
 }
 type MethodFn$4 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$2 = 'fields'>(options: Omit<RequestOptions$4<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult$4<TData, TError, ThrowOnError, TResponseStyle>;
-type SseFn$4 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$2 = 'fields'>(options: Omit<RequestOptions$4<TData, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type SseFn$4 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$2 = 'fields'>(options: Omit<RequestOptions$4<never, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
 type RequestFn$4 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$2 = 'fields'>(options: Omit<RequestOptions$4<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions$4<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult$4<TData, TError, ThrowOnError, TResponseStyle>;
 type BuildUrlFn$4 = <TData extends {
   body?: unknown;
@@ -3020,7 +3123,7 @@ interface ClientOptions$3 {
   throwOnError?: boolean;
 }
 type MethodFn$3 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions$3<TData, ThrowOnError>, 'method'>) => RequestResult$3<TData, TError, ThrowOnError>;
-type SseFn$3 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions$3<TData, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type SseFn$3 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions$3<never, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
 type RequestFn$3 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions$3<TData, ThrowOnError>, 'method'> & Pick<Required<RequestOptions$3<TData, ThrowOnError>>, 'method'>) => RequestResult$3<TData, TError, ThrowOnError>;
 type BuildUrlFn$3 = <TData extends {
   body?: unknown;
@@ -3287,7 +3390,7 @@ interface ClientOptions$1 {
   throwOnError?: boolean;
 }
 type MethodFn$1 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$1 = 'fields'>(options: Omit<RequestOptions$1<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult$1<TData, TError, ThrowOnError, TResponseStyle>;
-type SseFn$1 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$1 = 'fields'>(options: Omit<RequestOptions$1<TData, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type SseFn$1 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$1 = 'fields'>(options: Omit<RequestOptions$1<never, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
 type RequestFn$1 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$1 = 'fields'>(options: Omit<RequestOptions$1<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions$1<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult$1<TData, TError, ThrowOnError, TResponseStyle>;
 type BuildUrlFn$1 = <TData extends {
   body?: unknown;
@@ -3519,7 +3622,7 @@ interface ClientOptions {
   throwOnError?: boolean;
 }
 type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<never, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
 type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
 type BuildUrlFn = <TData extends {
   body?: unknown;
@@ -3555,12 +3658,12 @@ type HeyApiClientKyPlugin = DefinePlugin$1<UserConfig$19, UserConfig$19>;
 type UserConfig$18 = Plugin$1.Name<'@hey-api/schemas'> & Plugin$1.Hooks & Plugin$1.UserExports & {
   /**
    * Customise the schema name. By default, `{{name}}Schema` is used. `name` is a
-   * valid JavaScript/TypeScript identifier, e.g. if your schema name is
+   * valid JavaScript/TypeScript identifier, e.g., if your schema name is
    * "Foo-Bar", `name` value would be "FooBar".
    *
    * @default '{{name}}Schema'
    */
-  nameBuilder?: string | ((name: string, schema: OpenApiV2_0_XTypes['SchemaObject'] | OpenApiV3_0_XTypes['ReferenceObject'] | OpenApiV3_0_XTypes['SchemaObject'] | OpenApiV3_1_XTypes['SchemaObject']) => string);
+  nameBuilder?: string | ((name: string, schema: OpenAPIV2.SchemaObject | OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject | OpenAPIV3_1.SchemaObject) => string);
   /**
    * Choose schema type to generate. Select 'form' if you don't want
    * descriptions to reduce bundle size and you plan to use schemas
@@ -3768,7 +3871,7 @@ type UserConfig$17 = Plugin$1.Name<'@hey-api/sdk'> & Plugin$1.Hooks & Plugin$1.U
   client?: PluginClientNames | boolean;
   /**
    * Generate code examples for SDK operations and attach them to the
-   * input source (e.g. via `x-codeSamples`).
+   * input source (e.g., via `x-codeSamples`).
    *
    * Set to `false` to disable example generation entirely, or provide an
    * object for fine-grained control over the output and post-processing.
@@ -7593,13 +7696,13 @@ type TanStackVueQueryPlugin = DefinePlugin$1<UserConfig$8, Config$5>;
 //#endregion
 //#region src/plugins/arktype/shared/types.d.ts
 type ValidatorArgs$2 = {
-  operation: IR$1.OperationObject;
+  operation: IR$1.OperationObject; /** The plugin instance. */
   plugin: ArktypePlugin['Instance'];
 };
 //#endregion
 //#region src/plugins/arktype/api.d.ts
 type IApi$2 = {
-  createRequestValidator: (args: ValidatorArgs$2) => ReturnType<typeof $.func> | undefined;
+  createRequestValidator: (args: RequestSchemaContext<ArktypePlugin['Instance']>) => ReturnType<typeof $.func> | undefined;
   createResponseValidator: (args: ValidatorArgs$2) => ReturnType<typeof $.func> | undefined;
 };
 //#endregion
@@ -8690,7 +8793,8 @@ interface ValibotFinal extends Pick<ValibotResult, 'pipes'> {
 //#endregion
 //#region src/plugins/valibot/api.d.ts
 type IApi$1 = {
-  createRequestValidator: (args: ValidatorArgs$1) => ReturnType<typeof $.func> | undefined;
+  createRequestSchema: (ctx: RequestSchemaContext<ValibotPlugin['Instance']>) => Symbol | Pipe | undefined;
+  createRequestValidator: (args: RequestSchemaContext<ValibotPlugin['Instance']>) => ReturnType<typeof $.func> | undefined;
   createResponseValidator: (args: ValidatorArgs$1) => ReturnType<typeof $.func> | undefined;
 };
 //#endregion
@@ -8819,23 +8923,21 @@ type ValibotResolvers = Plugin$1.Resolvers<{
    *
    * Allow customization of validator function bodies.
    *
-   * Example path: `~resolvers.validator.request` or `~resolvers.validator.response`
-   *
    * Returning `undefined` will execute the default resolver logic.
    */
-  validator?: ValidatorResolver$1 | {
+  validator?: ((ctx: ValidatorResolverContext$1) => PipeResult | null | undefined) | {
     /**
      * Controls how the request validator function body is generated.
      *
      * Returning `undefined` will execute the default resolver logic.
      */
-    request?: ValidatorResolver$1;
+    request?: (ctx: RequestValidatorResolverContext$1) => PipeResult | null | undefined;
     /**
      * Controls how the response validator function body is generated.
      *
      * Returning `undefined` will execute the default resolver logic.
      */
-    response?: ValidatorResolver$1;
+    response?: (ctx: ResponseValidatorResolverContext$1) => PipeResult | null | undefined;
   };
   /**
    * Resolver for void schemas.
@@ -8846,7 +8948,6 @@ type ValibotResolvers = Plugin$1.Resolvers<{
    */
   void?: (ctx: VoidResolverContext$1) => PipeResult;
 }>;
-type ValidatorResolver$1 = (ctx: ValidatorResolverContext$1) => PipeResult | null | undefined;
 interface BaseContext$1 extends DollarTsDsl {
   /**
    * Functions for working with pipes.
@@ -9056,15 +9157,61 @@ interface UnknownResolverContext$1 extends BaseContext$1 {
   };
   schema: SchemaWithType<'unknown'>;
 }
-interface ValidatorResolverContext$1 extends BaseContext$1 {
+interface RequestValidatorResolverContext$1 extends BaseContext$1, RequestSchemaContext<ValibotPlugin['Instance']> {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the composite schema combining all layers.
+     *
+     * Returns `undefined` if all layers are omitted.
+     */
+    composite: (ctx: RequestValidatorResolverContext$1) => Pipe | undefined;
+    /**
+     * Returns an empty/fallback schema for a layer based on its `whenEmpty` config.
+     *
+     * @throws if `whenEmpty` is `'omit'` (no schema should be generated)
+     */
+    empty: (ctx: RequestValidatorResolverContext$1 & {
+      /** Resolved configuration for the request layer. */layer: ResolvedRequestValidatorLayer;
+    }) => Pipe;
+    /**
+     * Returns an optional schema based on the layer's config.
+     */
+    optional: (ctx: RequestValidatorResolverContext$1 & {
+      /** Resolved configuration for the request layer. */layer: ResolvedRequestValidatorLayer; /** The schema to conditionally wrap. */
+      schema: Pipe;
+    }) => Pipe;
+  };
+  /**
+   * Provides access to commonly used symbols within the plugin.
+   */
+  symbols: BaseContext$1['symbols'] & {
+    /**
+     * The schema to use in the validator body.
+     *
+     * This is either:
+     * - an inline AST expression
+     * - a Symbol reference to a named export
+     */
+    schema: Symbol | Pipe;
+  };
+}
+interface ResponseValidatorResolverContext$1 extends BaseContext$1 {
+  /** The operation being processed. */
   operation: IR$1.OperationObject;
   /**
    * Provides access to commonly used symbols within the plugin.
    */
   symbols: BaseContext$1['symbols'] & {
+    /**
+     * The response schema symbol.
+     */
     schema: Symbol;
   };
 }
+type ValidatorResolverContext$1 = RequestValidatorResolverContext$1 | ResponseValidatorResolverContext$1;
 interface VoidResolverContext$1 extends BaseContext$1 {
   /**
    * Nodes used to build different parts of the result.
@@ -9150,6 +9297,36 @@ type UserConfig$2 = Plugin$1.Name<'valibot'> & Plugin$1.Hooks & Plugin$1.UserCom
    * @default true
    */
   requests?: boolean | NameTransformer | {
+    /**
+     * Configuration for request body Valibot schemas.
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
+     */
+    body?: boolean | NameTransformer | {
+      /**
+       * Casing convention for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case?: Casing;
+      /**
+       * Whether this feature is enabled.
+       *
+       * @default true
+       */
+      enabled?: boolean;
+      /**
+       * Naming pattern for generated names.
+       *
+       * @default 'v{{name}}Body'
+       */
+      name?: NameTransformer;
+    };
     /**
      * Casing convention for generated names.
      *
@@ -9162,12 +9339,128 @@ type UserConfig$2 = Plugin$1.Name<'valibot'> & Plugin$1.Hooks & Plugin$1.UserCom
      * @default true
      */
     enabled?: boolean;
+    /**
+     * Configuration for request headers Valibot schemas.
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
+     */
+    headers?: boolean | NameTransformer | {
+      /**
+       * Casing convention for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case?: Casing;
+      /**
+       * Whether this feature is enabled.
+       *
+       * @default true
+       */
+      enabled?: boolean;
+      /**
+       * Naming pattern for generated names.
+       *
+       * @default 'v{{name}}Headers'
+       */
+      name?: NameTransformer;
+    };
     /**
      * Naming pattern for generated names.
      *
      * @default 'v{{name}}Data'
      */
     name?: NameTransformer;
+    /**
+     * Configuration for request path parameters Valibot schemas.
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
+     */
+    path?: boolean | NameTransformer | {
+      /**
+       * Casing convention for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case?: Casing;
+      /**
+       * Whether this feature is enabled.
+       *
+       * @default true
+       */
+      enabled?: boolean;
+      /**
+       * Naming pattern for generated names.
+       *
+       * @default 'v{{name}}Path'
+       */
+      name?: NameTransformer;
+    };
+    /**
+     * Configuration for request query parameters Valibot schemas.
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
+     */
+    query?: boolean | NameTransformer | {
+      /**
+       * Casing convention for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case?: Casing;
+      /**
+       * Whether this feature is enabled.
+       *
+       * @default true
+       */
+      enabled?: boolean;
+      /**
+       * Naming pattern for generated names.
+       *
+       * @default 'v{{name}}Query'
+       */
+      name?: NameTransformer;
+    };
+    /**
+     * Whether to extract the request schema into a named export.
+     *
+     * When `true`, generates a reusable schema like `vProjectListData`.
+     * When `false`, the schema is built inline within the caller plugin.
+     *
+     * Can be a boolean or a function for per-operation control.
+     *
+     * @default false
+     * @example
+     * ```ts
+     * // Always extract
+     * shouldExtract: true
+     *
+     * // Extract only for operations with complex request bodies
+     * shouldExtract: ({ operation }) =>
+     *   operation.body !== undefined && operation.parameters !== undefined
+     *
+     * // Extract based on custom extension
+     * shouldExtract: ({ operation }) =>
+     *   operation['x-custom']?.extractRequestSchema === true
+     * ```
+     */
+    shouldExtract?: MaybeFunc<(ctx: {
+      /** The operation being processed */operation: IR$1.OperationObject;
+    }) => boolean>;
   };
   /**
    * Configuration for response-specific Valibot schemas.
@@ -9242,7 +9535,15 @@ type Config$1 = Plugin$1.Name<'valibot'> & Plugin$1.Hooks & Plugin$1.Comments &
     node: ReturnType<typeof $.object>;
     schema: IR$1.SchemaObject;
   }) => void); /** Configuration for request-specific Valibot schemas. */
-  requests: NamingOptions & FeatureToggle; /** Configuration for response-specific Valibot schemas. */
+  requests: NamingOptions & FeatureToggle & {
+    /** Configuration for request body Valibot schemas. */body: NamingOptions & FeatureToggle; /** Configuration for request headers Valibot schemas. */
+    headers: NamingOptions & FeatureToggle; /** Configuration for request path parameters Valibot schemas. */
+    path: NamingOptions & FeatureToggle; /** Configuration for request query parameters Valibot schemas. */
+    query: NamingOptions & FeatureToggle; /** Whether to extract the request schema into a named export. */
+    shouldExtract: (ctx: {
+      /** The operation being processed */operation: IR$1.OperationObject;
+    }) => boolean;
+  }; /** Configuration for response-specific Valibot schemas. */
   responses: NamingOptions & FeatureToggle; /** Configuration for webhook-specific Valibot schemas. */
   webhooks: NamingOptions & FeatureToggle;
 };
@@ -9298,8 +9599,9 @@ interface ZodFinal extends Pick<ZodResult, 'expression'> {
 //#endregion
 //#region src/plugins/zod/api.d.ts
 type IApi = {
-  createRequestValidator: (args: ValidatorArgs) => ReturnType<typeof $.func> | undefined;
-  createResponseValidator: (args: ValidatorArgs) => ReturnType<typeof $.func> | undefined;
+  createRequestSchema: (ctx: RequestSchemaContext<ZodPlugin['Instance']>) => Symbol | Chain | undefined;
+  createRequestValidator: (ctx: RequestSchemaContext<ZodPlugin['Instance']>) => ReturnType<typeof $.func> | undefined;
+  createResponseValidator: (ctx: ValidatorArgs) => ReturnType<typeof $.func> | undefined;
 };
 //#endregion
 //#region src/plugins/zod/resolvers.d.ts
@@ -9413,23 +9715,21 @@ type ZodResolvers = Plugin$1.Resolvers<{
    *
    * Allow customization of validator function bodies.
    *
-   * Example path: `~resolvers.validator.request` or `~resolvers.validator.response`
-   *
    * Returning `undefined` will execute the default resolver logic.
    */
-  validator?: ValidatorResolver | {
+  validator?: ((ctx: ValidatorResolverContext) => MaybeArray<TsDsl<ts.Statement>> | null | undefined) | {
     /**
      * Controls how the request validator function body is generated.
      *
      * Returning `undefined` will execute the default resolver logic.
      */
-    request?: ValidatorResolver;
+    request?: (ctx: RequestValidatorResolverContext) => MaybeArray<TsDsl<ts.Statement>> | null | undefined;
     /**
      * Controls how the response validator function body is generated.
      *
      * Returning `undefined` will execute the default resolver logic.
      */
-    response?: ValidatorResolver;
+    response?: (ctx: ResponseValidatorResolverContext) => MaybeArray<TsDsl<ts.Statement>> | null | undefined;
   };
   /**
    * Resolver for void schemas.
@@ -9440,7 +9740,6 @@ type ZodResolvers = Plugin$1.Resolvers<{
    */
   void?: (ctx: VoidResolverContext) => ChainResult;
 }>;
-type ValidatorResolver = (ctx: ValidatorResolverContext) => MaybeArray<TsDsl<ts.Statement>> | null | undefined;
 interface BaseContext extends DollarTsDsl {
   /**
    * Functions for working with chains.
@@ -9749,15 +10048,61 @@ interface UnknownResolverContext extends BaseContext {
   };
   schema: SchemaWithType<'unknown'>;
 }
-interface ValidatorResolverContext extends BaseContext {
+interface RequestValidatorResolverContext extends BaseContext, RequestSchemaContext<ZodPlugin['Instance']> {
+  /**
+   * Nodes used to build different parts of the result.
+   */
+  nodes: {
+    /**
+     * Returns the composite schema combining all layers.
+     *
+     * Returns `undefined` if all layers are omitted.
+     */
+    composite: (ctx: RequestValidatorResolverContext) => Chain | undefined;
+    /**
+     * Returns an empty/fallback schema for a layer based on its `whenEmpty` config.
+     *
+     * @throws if `whenEmpty` is `'omit'` (no schema should be generated)
+     */
+    empty: (ctx: RequestValidatorResolverContext & {
+      /** Resolved configuration for the request layer. */layer: ResolvedRequestValidatorLayer;
+    }) => Chain;
+    /**
+     * Returns an optional schema based on the layer's config.
+     */
+    optional: (ctx: RequestValidatorResolverContext & {
+      /** Resolved configuration for the request layer. */layer: ResolvedRequestValidatorLayer; /** The schema to conditionally wrap. */
+      schema: Chain;
+    }) => Chain;
+  };
+  /**
+   * Provides access to commonly used symbols within the plugin.
+   */
+  symbols: BaseContext['symbols'] & {
+    /**
+     * The schema to use in the validator body.
+     *
+     * This is either:
+     * - an inline AST expression
+     * - a Symbol reference to a named export
+     */
+    schema: Symbol | Chain;
+  };
+}
+interface ResponseValidatorResolverContext extends BaseContext {
+  /** The operation being processed. */
   operation: IR$1.OperationObject;
   /**
    * Provides access to commonly used symbols within the plugin.
    */
   symbols: BaseContext['symbols'] & {
+    /**
+     * The response schema symbol.
+     */
     schema: Symbol;
   };
 }
+type ValidatorResolverContext = RequestValidatorResolverContext | ResponseValidatorResolverContext;
 interface VoidResolverContext extends BaseContext {
   /**
    * Nodes used to build different parts of the result.
@@ -9910,7 +10255,7 @@ type UserConfig$1 = Plugin$1.Name<'zod'> & Plugin$1.Hooks & Plugin$1.UserComment
   /**
    * Configuration for request-specific Zod schemas.
    *
-   * Controls generation of Zod schemas for request bodies, query parameters, path
+   * Controls generation of Zod schemas for request bodies, path parameters, query
    * parameters, and headers.
    *
    * Can be:
@@ -9921,6 +10266,73 @@ type UserConfig$1 = Plugin$1.Name<'zod'> & Plugin$1.Hooks & Plugin$1.UserComment
    * @default true
    */
   requests?: boolean | NameTransformer | {
+    /**
+     * Configuration for request body Zod schemas.
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
+     */
+    body?: boolean | NameTransformer | {
+      /**
+       * Casing convention for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case?: Casing;
+      /**
+       * Whether this feature is enabled.
+       *
+       * @default true
+       */
+      enabled?: boolean;
+      /**
+       * Naming pattern for generated names.
+       *
+       * @default 'z{{name}}Body'
+       */
+      name?: NameTransformer;
+      /**
+       * Configuration for TypeScript type generation from Zod schemas.
+       *
+       * Controls generation of TypeScript types based on the generated Zod schemas.
+       */
+      types?: {
+        /**
+         * Configuration for `infer` types.
+         *
+         * Can be:
+         * - `boolean`: Shorthand for `{ enabled: boolean }`
+         * - `string` or `function`: Shorthand for `{ name: string | function }`
+         * - `object`: Full configuration object
+         *
+         * @default false
+         */
+        infer?: boolean | NameTransformer | {
+          /**
+           * Casing convention for generated names.
+           *
+           * @default 'PascalCase'
+           */
+          case?: Casing;
+          /**
+           * Whether this feature is enabled.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Naming pattern for generated names.
+           *
+           * @default '{{name}}BodyZodType'
+           */
+          name?: NameTransformer;
+        };
+      };
+    };
     /**
      * Casing convention for generated names.
      *
@@ -9933,12 +10345,239 @@ type UserConfig$1 = Plugin$1.Name<'zod'> & Plugin$1.Hooks & Plugin$1.UserComment
      * @default true
      */
     enabled?: boolean;
+    /**
+     * Configuration for request headers Zod schemas.
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
+     */
+    headers?: boolean | NameTransformer | {
+      /**
+       * Casing convention for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case?: Casing;
+      /**
+       * Whether this feature is enabled.
+       *
+       * @default true
+       */
+      enabled?: boolean;
+      /**
+       * Naming pattern for generated names.
+       *
+       * @default 'z{{name}}Headers'
+       */
+      name?: NameTransformer;
+      /**
+       * Configuration for TypeScript type generation from Zod schemas.
+       *
+       * Controls generation of TypeScript types based on the generated Zod schemas.
+       */
+      types?: {
+        /**
+         * Configuration for `infer` types.
+         *
+         * Can be:
+         * - `boolean`: Shorthand for `{ enabled: boolean }`
+         * - `string` or `function`: Shorthand for `{ name: string | function }`
+         * - `object`: Full configuration object
+         *
+         * @default false
+         */
+        infer?: boolean | NameTransformer | {
+          /**
+           * Casing convention for generated names.
+           *
+           * @default 'PascalCase'
+           */
+          case?: Casing;
+          /**
+           * Whether this feature is enabled.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Naming pattern for generated names.
+           *
+           * @default '{{name}}HeadersZodType'
+           */
+          name?: NameTransformer;
+        };
+      };
+    };
     /**
      * Naming pattern for generated names.
      *
      * @default 'z{{name}}Data'
      */
     name?: NameTransformer;
+    /**
+     * Configuration for request path parameters Zod schemas.
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
+     */
+    path?: boolean | NameTransformer | {
+      /**
+       * Casing convention for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case?: Casing;
+      /**
+       * Whether this feature is enabled.
+       *
+       * @default true
+       */
+      enabled?: boolean;
+      /**
+       * Naming pattern for generated names.
+       *
+       * @default 'z{{name}}Path'
+       */
+      name?: NameTransformer;
+      /**
+       * Configuration for TypeScript type generation from Zod schemas.
+       *
+       * Controls generation of TypeScript types based on the generated Zod schemas.
+       */
+      types?: {
+        /**
+         * Configuration for `infer` types.
+         *
+         * Can be:
+         * - `boolean`: Shorthand for `{ enabled: boolean }`
+         * - `string` or `function`: Shorthand for `{ name: string | function }`
+         * - `object`: Full configuration object
+         *
+         * @default false
+         */
+        infer?: boolean | NameTransformer | {
+          /**
+           * Casing convention for generated names.
+           *
+           * @default 'PascalCase'
+           */
+          case?: Casing;
+          /**
+           * Whether this feature is enabled.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Naming pattern for generated names.
+           *
+           * @default '{{name}}PathZodType'
+           */
+          name?: NameTransformer;
+        };
+      };
+    };
+    /**
+     * Configuration for request query parameters Zod schemas.
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
+     */
+    query?: boolean | NameTransformer | {
+      /**
+       * Casing convention for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case?: Casing;
+      /**
+       * Whether this feature is enabled.
+       *
+       * @default true
+       */
+      enabled?: boolean;
+      /**
+       * Naming pattern for generated names.
+       *
+       * @default 'z{{name}}Query'
+       */
+      name?: NameTransformer;
+      /**
+       * Configuration for TypeScript type generation from Zod schemas.
+       *
+       * Controls generation of TypeScript types based on the generated Zod schemas.
+       */
+      types?: {
+        /**
+         * Configuration for `infer` types.
+         *
+         * Can be:
+         * - `boolean`: Shorthand for `{ enabled: boolean }`
+         * - `string` or `function`: Shorthand for `{ name: string | function }`
+         * - `object`: Full configuration object
+         *
+         * @default false
+         */
+        infer?: boolean | NameTransformer | {
+          /**
+           * Casing convention for generated names.
+           *
+           * @default 'PascalCase'
+           */
+          case?: Casing;
+          /**
+           * Whether this feature is enabled.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Naming pattern for generated names.
+           *
+           * @default '{{name}}QueryZodType'
+           */
+          name?: NameTransformer;
+        };
+      };
+    };
+    /**
+     * Whether to extract the request schema into a named export.
+     *
+     * When `true`, generates a reusable schema like `zProjectListData`.
+     * When `false`, the schema is built inline within the caller plugin.
+     *
+     * Can be a boolean or a function for per-operation control.
+     *
+     * @default false
+     * @example
+     * ```ts
+     * // Always extract
+     * shouldExtract: true
+     *
+     * // Extract only for operations with complex request bodies
+     * shouldExtract: ({ operation }) =>
+     *   operation.body !== undefined && operation.parameters !== undefined
+     *
+     * // Extract based on custom extension
+     * shouldExtract: ({ operation }) =>
+     *   operation['x-custom']?.extractRequestSchema === true
+     * ```
+     */
+    shouldExtract?: MaybeFunc<(ctx: {
+      /** The operation being processed */operation: IR$1.OperationObject;
+    }) => boolean>;
     /**
      * Configuration for TypeScript type generation from Zod schemas.
      *
@@ -10160,7 +10799,15 @@ type Config = Plugin$1.Name<'zod'> & Plugin$1.Hooks & Plugin$1.Comments & Plugin
     node: ReturnType<typeof $.object>;
     schema: IR$1.SchemaObject;
   }) => void); /** Configuration for request-specific Zod schemas. */
-  requests: NamingOptions & FeatureToggle & TypeOptions; /** Configuration for response-specific Zod schemas. */
+  requests: NamingOptions & FeatureToggle & TypeOptions & {
+    /** Configuration for request body Zod schemas. */body: NamingOptions & FeatureToggle & TypeOptions; /** Configuration for request headers Zod schemas. */
+    headers: NamingOptions & FeatureToggle & TypeOptions; /** Configuration for request path parameters Zod schemas. */
+    path: NamingOptions & FeatureToggle & TypeOptions; /** Configuration for request query parameters Zod schemas. */
+    query: NamingOptions & FeatureToggle & TypeOptions; /** Whether to extract the request schema into a named export. */
+    shouldExtract: (ctx: {
+      /** The operation being processed */operation: IR$1.OperationObject;
+    }) => boolean;
+  }; /** Configuration for response-specific Zod schemas. */
   responses: NamingOptions & FeatureToggle & TypeOptions; /** Configuration for TypeScript type generation from Zod schemas. */
   types: {
     /** Configuration for `infer` types. */infer: FeatureToggle & {