@hey-api/openapi-ts 0.88.2 → 0.89.0

package/dist/{config-eqVtXEeO.d.mts → config-uoaRJc6A.d.mts}

@@ -1,4 +1,4 @@
-import { IProject, Project, Symbol, SymbolIdentifier, SymbolIn, SymbolMeta } from "@hey-api/codegen-core";
+import { AnalysisContext, File, FromRef, IProject, Language, NameConflictResolver, Node, Project, Ref, Refs, RenderContext, Renderer, Symbol, SymbolIdentifier, SymbolIn, SymbolMeta } from "@hey-api/codegen-core";
 import * as typescript0 from "typescript";
 import ts from "typescript";
 import { RangeOptions, SemVer } from "semver";
@@ -6,46 +6,9 @@ import { HttpClient, HttpErrorResponse, HttpHeaders, HttpRequest, HttpResponse }
 import { Injector } from "@angular/core";
 import { AxiosError, AxiosInstance, AxiosRequestHeaders, AxiosResponse, AxiosStatic, CreateAxiosDefaults } from "axios";
 import { AsyncDataOptions, UseFetchOptions, useAsyncData, useFetch, useLazyAsyncData, useLazyFetch } from "nuxt/app";
-import { Ref } from "vue";
+import { Ref as Ref$1 } from "vue";
 import { FetchOptions, ResponseType, ofetch } from "ofetch";
 
-//#region src/plugins/shared/types/refs.d.ts
-/**
- * Ref wrapper which ensures a stable reference for a value.
- *
- * @example
- * ```ts
- * type NumRef = Ref<number>; // { value: number }
- * const num: NumRef = { value: 42 };
- * console.log(num.value); // 42
- * ```
- */
-type Ref$1<T> = {
-  value: T;
-};
-
-/**
- * Utility type: wraps a value in a Ref.
- *
- * @example
- * ```ts
- * type R = ToRef<number>; // { value: number }
- * ```
- */
-
-/**
- * Maps every property of `T` to a `Ref` of that property.
- *
- * @example
- * ```ts
- * type Foo = { a: number; b: string };
- * type Refs = ToRefs<Foo>; // { a: Ref<number>; b: Ref<string> }
- * const refs: Refs = { a: { value: 1 }, b: { value: 'x' } };
- * console.log(refs.a.value, refs.b.value); // 1 'x'
- * ```
- */
-type ToRefs<T> = { [K in keyof T]: Ref$1<T[K]> };
-//#endregion
 //#region src/openApi/shared/types/openapi-spec-extensions.d.ts
 interface EnumExtensions {
   /**
@@ -2609,6 +2572,10 @@ interface IRSchemaObject extends Pick<JsonSchemaDraft2020_12, '$ref' | 'const' |
    * follow a specific convention.
    */
   propertyNames?: IRSchemaObject;
+  /**
+   * Reference to symbol instead of `$ref` string.
+   */
+  symbolRef?: Symbol;
   /**
    * Each schema eventually resolves into `type`.
    */
@@ -3583,7 +3550,7 @@ type HeyApiClientNextPlugin = DefinePlugin<UserConfig$20, UserConfig$20>;
 //#endregion
 //#region src/plugins/@hey-api/client-nuxt/bundle/types.d.ts
 type QuerySerializer = (query: Parameters<Client$3['buildUrl']>[0]['query']) => string;
-type WithRefs<TData> = { [K in keyof TData]: NonNullable<TData[K]> extends object ? WithRefs<NonNullable<TData[K]>> | Ref<NonNullable<TData[K]>> : NonNullable<TData[K]> | Ref<NonNullable<TData[K]>> };
+type WithRefs<TData> = { [K in keyof TData]: NonNullable<TData[K]> extends object ? WithRefs<NonNullable<TData[K]>> | Ref$1<NonNullable<TData[K]>> : NonNullable<TData[K]> | Ref$1<NonNullable<TData[K]>> };
 type KeysOf<T> = Array<T extends T ? (keyof T extends string ? keyof T : never) : never>;
 interface Config$16<T extends ClientOptions$1 = ClientOptions$1> extends Omit<FetchOptions$1<unknown>, 'baseURL' | 'body' | 'headers' | 'method' | 'query'>, WithRefs<Pick<FetchOptions$1<unknown>, 'query'>>, Omit<Config$14, 'querySerializer'> {
   /**
@@ -7249,597 +7216,722 @@ type HeyApiSdkPlugin = DefinePlugin<UserConfig$14, Config$13>;
 //#endregion
 //#region src/ts-dsl/base.d.ts
 type MaybeArray$1<T> = T | ReadonlyArray<T>;
-interface ITsDsl<T extends ts.Node = ts.Node> {
-  $render(): T;
-}
-declare abstract class TsDsl<T extends ts.Node = ts.Node> implements ITsDsl<T> {
-  abstract $render(): T;
+declare abstract class TsDsl<T extends ts.Node = ts.Node> implements Node<T> {
+  analyze(_: AnalysisContext): void;
+  exported?: boolean;
+  file?: File;
+  language: Language;
+  parent?: Node;
+  root?: Node;
+  symbol?: Symbol;
+  toAst(): T;
+  readonly '~brand': any;
+  /** Branding property to identify the DSL class at runtime. */
+  abstract readonly '~dsl': string;
   /** Conditionally applies a callback to this builder. */
-  $if<T extends TsDsl, V$1, R extends TsDsl = T>(this: T, value: V$1, ifTrue: (self: T, v: Exclude<V$1, false | null | undefined>) => R | void, ifFalse?: (self: T, v: Extract<V$1, false | null | undefined>) => R | void): R | T;
-  $if<T extends TsDsl, V$1, R extends TsDsl = T>(this: T, value: V$1, ifTrue: (v: Exclude<V$1, false | null | undefined>) => R | void, ifFalse?: (v: Extract<V$1, false | null | undefined>) => R | void): R | T;
-  $if<T extends TsDsl, V$1, R extends TsDsl = T>(this: T, value: V$1, ifTrue: () => R | void, ifFalse?: () => R | void): R | T;
+  $if<T extends TsDsl, V, R extends TsDsl = T>(this: T, value: V, ifTrue: (self: T, v: Exclude<V, false | null | undefined>) => R | void, ifFalse?: (self: T, v: Extract<V, false | null | undefined>) => R | void): R | T;
+  $if<T extends TsDsl, V, R extends TsDsl = T>(this: T, value: V, ifTrue: (v: Exclude<V, false | null | undefined>) => R | void, ifFalse?: (v: Extract<V, false | null | undefined>) => R | void): R | T;
+  $if<T extends TsDsl, V, R extends TsDsl = T>(this: T, value: V, ifTrue: () => R | void, ifFalse?: () => R | void): R | T;
   protected $maybeId<T extends string | ts.Expression>(expr: T): T extends string ? ts.Identifier : T;
   protected $node<I>(value: I): NodeOfMaybe<I>;
   protected $type<I>(value: I, args?: ReadonlyArray<ts.TypeNode>): TypeOfMaybe<I>;
-  protected unwrap<I>(value: I): I extends TsDsl<infer N> ? N : I;
+  /** Unwraps nested nodes into raw TypeScript AST. */
+  private unwrap;
 }
-type NodeOfMaybe<I> = undefined extends I ? NodeOf<NonNullable<I>> | undefined : NodeOf<I>;
+type NodeOfMaybe<I> = undefined extends I ? NodeOf<NonNullable<FromRef<I>>> | undefined : NodeOf<FromRef<I>>;
 type NodeOf<I> = I extends ReadonlyArray<infer U> ? ReadonlyArray<U extends TsDsl<infer N> ? N : U> : I extends string ? ts.Expression : I extends TsDsl<infer N> ? N : I extends ts.Node ? I : never;
 type MaybeTsDsl<T> = T extends TsDsl<infer U> ? U | TsDsl<U> : T extends ts.Node ? T | TsDsl<T> : never;
 declare abstract class TypeTsDsl<T extends ts.LiteralTypeNode | ts.QualifiedName | ts.TypeElement | ts.TypeNode | ts.TypeParameterDeclaration = ts.TypeNode> extends TsDsl<T> {}
-type TypeOfMaybe<I> = undefined extends I ? TypeOf<NonNullable<I>> | undefined : TypeOf<I>;
+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/newline.d.ts
-declare class NewlineTsDsl extends TsDsl<ts.Identifier> {
-  $render(): ts.Identifier;
+//#region src/ts-dsl/mixins/types.d.ts
+type BaseCtor<T> = abstract new (...args: any[]) => TsDsl<T>;
+type MixinCtor<T extends BaseCtor<any>, K$1> = abstract new (...args: any[]) => InstanceType<T> & K$1;
+//#endregion
+//#region src/ts-dsl/mixins/type-args.d.ts
+type Arg$1 = Symbol | string | 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>`). */
+  generic(arg: Arg$1): this;
+  /** Adds type arguments (e.g. `Map<string, number>`). */
+  generics(...args: ReadonlyArray<Arg$1>): this;
 }
 //#endregion
-//#region src/ts-dsl/mixins/args.d.ts
-/**
- * Adds `.arg()` and `.args()` for managing expression arguments in call-like nodes.
- */
-declare class ArgsMixin extends TsDsl {
-  protected _args?: Array<string | MaybeTsDsl<ts.Expression>>;
-  /** Adds a single expression argument. */
-  arg(arg: string | MaybeTsDsl<ts.Expression>): this;
-  /** Adds one or more expression arguments. */
-  args(...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>): this;
-  /** Renders the arguments into an array of `Expression`s. */
-  protected $args(): ReadonlyArray<ts.Expression>;
-  $render(): ts.Node;
+//#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/decl/decorator.d.ts
-declare class DecoratorTsDsl extends TsDsl<ts.Decorator> {
-  protected name: string | ts.Expression;
-  constructor(name: string | ts.Expression, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>);
-  $render(): ts.Decorator;
+//#region src/ts-dsl/expr/as.d.ts
+type AsExpr = Symbol | string | MaybeTsDsl<ts.Expression>;
+type AsType = Symbol | string | TypeTsDsl;
+declare const Mixed$52: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.AsExpression>, ExprMethods>, AsMethods>;
+declare class AsTsDsl extends Mixed$52 {
+  readonly '~dsl' = "AsTsDsl";
+  protected expr: Ref<AsExpr>;
+  protected type: Ref<AsType>;
+  constructor(expr: AsExpr, type: AsType);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.AsExpression;
 }
-interface DecoratorTsDsl extends ArgsMixin {}
 //#endregion
-//#region src/ts-dsl/mixins/decorator.d.ts
-declare class DecoratorMixin extends TsDsl {
-  protected decorators?: Array<DecoratorTsDsl>;
-  /** Adds a decorator (e.g. `@sealed({ in: 'root' })`). */
-  decorator(name: string | ts.Expression, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>): this;
-  /** Renders the decorators into an array of `ts.Decorator`s. */
-  protected $decorators(): ReadonlyArray<ts.Decorator>;
-  $render(): ts.Node;
+//#region src/ts-dsl/mixins/as.d.ts
+interface AsMethods extends Node {
+  /** Creates an `as` type assertion expression (e.g. `value as Type`). */
+  as(type: AsType): AsTsDsl;
 }
 //#endregion
-//#region src/ts-dsl/layout/doc.d.ts
-declare class DocTsDsl extends TsDsl<ts.Node> {
-  protected _lines: Array<string>;
-  constructor(lines?: MaybeArray$1<string>, fn?: (d: DocTsDsl) => void);
-  add(...lines: ReadonlyArray<string>): this;
-  apply<T extends ts.Node>(node: T): T;
-  $render(): ts.Node;
+//#region src/ts-dsl/expr/binary.d.ts
+type Expr$3 = Symbol | string | 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 {
+  readonly '~dsl' = "BinaryTsDsl";
+  protected _base: Ref<Expr$3>;
+  protected _expr?: Ref<Expr$3>;
+  protected _op?: Op$1;
+  constructor(base: Expr$3, op?: Op$1, expr?: Expr$3);
+  analyze(ctx: AnalysisContext): void;
+  /** Logical AND — `this && expr` */
+  and(expr: Expr$3): this;
+  /** Creates an assignment expression (e.g. `this = expr`). */
+  assign(expr: Expr$3): this;
+  /** Nullish coalescing — `this ?? expr` */
+  coalesce(expr: Expr$3): this;
+  /** Division — `this / expr` */
+  div(expr: Expr$3): this;
+  /** Strict equality — `this === expr` */
+  eq(expr: Expr$3): this;
+  /** Greater than — `this > expr` */
+  gt(expr: Expr$3): this;
+  /** Greater than or equal — `this >= expr` */
+  gte(expr: Expr$3): this;
+  /** Loose equality — `this == expr` */
+  looseEq(expr: Expr$3): this;
+  /** Loose inequality — `this != expr` */
+  looseNeq(expr: Expr$3): this;
+  /** Less than — `this < expr` */
+  lt(expr: Expr$3): this;
+  /** Less than or equal — `this <= expr` */
+  lte(expr: Expr$3): this;
+  /** Subtraction — `this - expr` */
+  minus(expr: Expr$3): this;
+  /** Strict inequality — `this !== expr` */
+  neq(expr: Expr$3): this;
+  /** Logical OR — `this || expr` */
+  or(expr: Expr$3): this;
+  /** Addition — `this + expr` */
+  plus(expr: Expr$3): this;
+  /** Multiplication — `this * expr` */
+  times(expr: Expr$3): this;
+  toAst(): ts.BinaryExpression;
+  /** Sets the binary operator and right-hand operand for this expression. */
+  private opAndExpr;
+  private opToToken;
 }
 //#endregion
-//#region src/ts-dsl/mixins/doc.d.ts
-declare function DocMixin<TBase extends new (...args: ReadonlyArray<any>) => ITsDsl>(Base: TBase): {
-  new (...args: ReadonlyArray<any>): {
-    _doc?: DocTsDsl;
-    doc(lines?: MaybeArray$1<string>, fn?: (d: DocTsDsl) => void): /*elided*/any;
-    $render(): any;
-  };
-} & TBase;
-type DocMixin = InstanceType<ReturnType<typeof DocMixin>>;
+//#region src/ts-dsl/mixins/operator.d.ts
+type Expr$2 = Symbol | string | 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;
+  /** Nullish coalescing — `this ?? expr` */
+  coalesce(expr: Expr$2): BinaryTsDsl;
+  /** Division — `this / expr` */
+  div(expr: Expr$2): BinaryTsDsl;
+  /** Strict equality — `this === expr` */
+  eq(expr: Expr$2): BinaryTsDsl;
+  /** Greater than — `this > expr` */
+  gt(expr: Expr$2): BinaryTsDsl;
+  /** Greater than or equal — `this >= expr` */
+  gte(expr: Expr$2): BinaryTsDsl;
+  /** Loose equality — `this == expr` */
+  looseEq(expr: Expr$2): BinaryTsDsl;
+  /** Loose inequality — `this != expr` */
+  looseNeq(expr: Expr$2): BinaryTsDsl;
+  /** Less than — `this < expr` */
+  lt(expr: Expr$2): BinaryTsDsl;
+  /** Less than or equal — `this <= expr` */
+  lte(expr: Expr$2): BinaryTsDsl;
+  /** Subtraction — `this - expr` */
+  minus(expr: Expr$2): BinaryTsDsl;
+  /** Strict inequality — `this !== expr` */
+  neq(expr: Expr$2): BinaryTsDsl;
+  /** Logical OR — `this || expr` */
+  or(expr: Expr$2): BinaryTsDsl;
+  /** Addition — `this + expr` */
+  plus(expr: Expr$2): BinaryTsDsl;
+  /** Multiplication — `this * expr` */
+  times(expr: Expr$2): BinaryTsDsl;
+}
+//#endregion
+//#region src/ts-dsl/expr/attr.d.ts
+type AttrLeft = Symbol | string | MaybeTsDsl<ts.Expression>;
+type AttrRight = Symbol | string | ts.MemberName | number;
+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 {
+  readonly '~dsl' = "AttrTsDsl";
+  protected left: Ref<AttrLeft>;
+  protected right: Ref<AttrRight>;
+  constructor(left: AttrLeft, right: AttrRight);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.PropertyAccessExpression | ts.ElementAccessExpression;
+}
+//#endregion
+//#region src/ts-dsl/expr/await.d.ts
+type AwaitExpr = Symbol | string | MaybeTsDsl<ts.Expression>;
+declare const Mixed$49: MixinCtor<abstract new () => TsDsl<ts.AwaitExpression>, ExprMethods>;
+declare class AwaitTsDsl extends Mixed$49 {
+  readonly '~dsl' = "AwaitTsDsl";
+  protected _awaitExpr: Ref<AwaitExpr>;
+  constructor(expr: AwaitExpr);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.AwaitExpression;
+}
+//#endregion
+//#region src/ts-dsl/stmt/return.d.ts
+type ReturnExpr = Symbol | string | MaybeTsDsl<ts.Expression>;
+declare const Mixed$48: abstract new () => TsDsl<ts.ReturnStatement>;
+declare class ReturnTsDsl extends Mixed$48 {
+  readonly '~dsl' = "ReturnTsDsl";
+  protected _returnExpr?: Ref<ReturnExpr>;
+  constructor(expr?: ReturnExpr);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.ReturnStatement;
+}
+//#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(name: AttrRight): AttrTsDsl;
+  /** Awaits the current expression (e.g. `await expr`). */
+  await(): AwaitTsDsl;
+  /** Calls the current expression (e.g. `fn(arg1, arg2)`). */
+  call(...args: CallArgs): CallTsDsl;
+  /** Produces a `return` statement returning the current expression. */
+  return(): ReturnTsDsl;
+}
+//#endregion
+//#region src/ts-dsl/mixins/args.d.ts
+type Arg = Symbol | string | MaybeTsDsl<ts.Expression>;
+interface ArgsMethods extends Node {
+  /** Renders the arguments into an array of `Expression`s. */
+  $args(): ReadonlyArray<ts.Expression>;
+  /** Adds a single expression argument. */
+  arg(arg: Arg | undefined): this;
+  /** Adds one or more expression arguments. */
+  args(...args: ReadonlyArray<Arg | undefined>): this;
+}
+//#endregion
+//#region src/ts-dsl/expr/call.d.ts
+type CallCallee = string | MaybeTsDsl<ts.Expression>;
+type CallArg = Symbol | string | MaybeTsDsl<ts.Expression>;
+type CallArgs = ReadonlyArray<CallArg | undefined>;
+declare const Mixed$47: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.CallExpression>, TypeArgsMethods>, ExprMethods>, AsMethods>, ArgsMethods>;
+declare class CallTsDsl extends Mixed$47 {
+  readonly '~dsl' = "CallTsDsl";
+  protected _callee: CallCallee;
+  constructor(callee: CallCallee, ...args: CallArgs);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.CallExpression;
+}
 //#endregion
 //#region src/ts-dsl/mixins/modifiers.d.ts
-type Target = object & {
-  _m?(kind: ts.ModifierSyntaxKind, condition?: boolean): unknown;
+type Modifiers = {
+  modifiers: Array<ts.Modifier>;
 };
-/**
- * Mixin that adds an `abstract` modifier to a node.
- */
-declare class AbstractMixin {
+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<T extends Target>(this: T, condition?: boolean): T;
+  abstract(condition?: boolean): this;
 }
-/**
- * Mixin that adds an `async` modifier to a node.
- */
-declare class AsyncMixin {
+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<T extends Target>(this: T, condition?: boolean): T;
+  async(condition?: boolean): this;
 }
-/**
- * Mixin that adds a `const` modifier to a node.
- */
-declare class ConstMixin {
+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<T extends Target>(this: T, condition?: boolean): T;
+  const(condition?: boolean): this;
 }
-/**
- * Mixin that adds a `default` modifier to a node.
- */
-declare class DefaultMixin {
+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<T extends Target>(this: T, condition?: boolean): T;
+  default(condition?: boolean): this;
 }
-/**
- * Mixin that adds an `export` modifier to a node.
- */
-declare class ExportMixin {
+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<T extends Target>(this: T, condition?: boolean): T;
+  export(condition?: boolean): this;
 }
-/**
- * Mixin that adds a `private` modifier to a node.
- */
-declare class PrivateMixin {
+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<T extends Target>(this: T, condition?: boolean): T;
+  private(condition?: boolean): this;
 }
-/**
- * Mixin that adds a `protected` modifier to a node.
- */
-declare class ProtectedMixin {
+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<T extends Target>(this: T, condition?: boolean): T;
+  protected(condition?: boolean): this;
 }
-/**
- * Mixin that adds a `public` modifier to a node.
- */
-declare class PublicMixin {
+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<T extends Target>(this: T, condition?: boolean): T;
+  public(condition?: boolean): this;
 }
-/**
- * Mixin that adds a `readonly` modifier to a node.
- */
-declare class ReadonlyMixin {
+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<T extends Target>(this: T, condition?: boolean): T;
+  readonly(condition?: boolean): this;
 }
-/**
- * Mixin that adds a `static` modifier to a node.
- */
-declare class StaticMixin {
+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<T extends Target>(this: T, condition?: boolean): T;
-}
-//#endregion
-//#region src/ts-dsl/type/param.d.ts
-declare class TypeParamTsDsl extends TypeTsDsl<ts.TypeParameterDeclaration> {
-  protected name?: string | ts.Identifier;
-  protected constraint?: string | MaybeTsDsl<TypeTsDsl> | boolean;
-  protected defaultValue?: string | MaybeTsDsl<TypeTsDsl> | boolean;
-  constructor(name?: string | ts.Identifier, fn?: (name: TypeParamTsDsl) => void);
-  default(value: string | MaybeTsDsl<TypeTsDsl> | boolean): this;
-  extends(constraint: string | MaybeTsDsl<TypeTsDsl> | boolean): this;
-  $render(): ts.TypeParameterDeclaration;
-}
-//#endregion
-//#region src/ts-dsl/mixins/type-params.d.ts
-declare class TypeParamsMixin extends TsDsl {
-  protected _generics?: Array<string | MaybeTsDsl<TypeParamTsDsl>>;
-  /** 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<string | MaybeTsDsl<TypeParamTsDsl>>): this;
-  /** Returns the type parameters as an array of ts.TypeParameterDeclaration nodes. */
-  protected $generics(): ReadonlyArray<ts.TypeParameterDeclaration> | undefined;
-  $render(): ts.Node;
+  static(condition?: boolean): this;
 }
 //#endregion
 //#region src/ts-dsl/mixins/value.d.ts
-declare class ValueMixin extends TsDsl {
-  protected value?: string | MaybeTsDsl<ts.Expression>;
+type ValueExpr = string | MaybeTsDsl<ts.Expression>;
+interface ValueMethods extends Node {
+  $value(): ts.Expression | undefined;
   /** Sets the initializer expression (e.g. `= expr`). */
-  assign<T extends this>(this: T, expr: string | MaybeTsDsl<ts.Expression>): T;
-  protected $value(): ts.Expression | undefined;
-  $render(): ts.Node;
-}
-//#endregion
-//#region src/ts-dsl/decl/field.d.ts
-declare class FieldTsDsl extends TsDsl<ts.PropertyDeclaration> {
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  protected name: string;
-  protected _type?: TypeTsDsl;
-  constructor(name: string, fn?: (f: FieldTsDsl) => void);
-  /** Sets the field type. */
-  type(type: string | TypeTsDsl): this;
-  /** Builds the `PropertyDeclaration` node. */
-  $render(): ts.PropertyDeclaration;
-}
-interface FieldTsDsl extends DecoratorMixin, DocMixin, PrivateMixin, ProtectedMixin, PublicMixin, ReadonlyMixin, StaticMixin, ValueMixin {}
-//#endregion
-//#region src/ts-dsl/mixins/do.d.ts
-/**
- * Adds `.do()` for appending statements or expressions to a body.
- */
-declare class DoMixin extends TsDsl {
-  protected _do?: Array<MaybeTsDsl<ts.Expression | ts.Statement>>;
-  /** Adds one or more expressions/statements to the body. */
-  do(...items: ReadonlyArray<MaybeTsDsl<ts.Expression | ts.Statement>>): this;
-  /** Renders the collected `.do()` calls into an array of `Statement` nodes. */
-  protected $do(): ReadonlyArray<ts.Statement>;
-  $render(): ts.Node;
-}
-//#endregion
-//#region src/ts-dsl/mixins/optional.d.ts
-declare class OptionalMixin {
-  protected _optional?: boolean;
-  /** Marks the node as optional when the condition is true. */
-  optional<T extends this>(this: T, condition?: boolean): T;
-  /** Marks the node as required when the condition is true. */
-  required<T extends this>(this: T, condition?: boolean): T;
-}
-//#endregion
-//#region src/ts-dsl/decl/pattern.d.ts
-/**
- * Builds binding patterns (e.g. `{ foo, bar }`, `[a, b, ...rest]`).
- */
-declare class PatternTsDsl extends TsDsl<ts.BindingName> {
-  protected pattern?: {
-    kind: 'array';
-    values: ReadonlyArray<string>;
-  } | {
-    kind: 'object';
-    values: Record<string, string>;
-  };
-  protected _spread?: string;
-  /** 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 }`). */
-  object(...props: ReadonlyArray<MaybeArray$1<string> | Record<string, string>>): this;
-  /** Adds a spread element (e.g. `...rest`, `...options`, `...args`). */
-  spread(name: string): this;
-  /** Builds and returns a BindingName (ObjectBindingPattern, ArrayBindingPattern, or Identifier). */
-  $render(): ts.BindingName;
-  private createSpread;
+  assign(expr: ValueExpr): this;
 }
 //#endregion
 //#region src/ts-dsl/mixins/pattern.d.ts
-/**
- * Mixin providing `.array()`, `.object()`, and `.spread()` methods for defining destructuring patterns.
- */
-declare class PatternMixin extends TsDsl {
-  protected pattern?: PatternTsDsl;
+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$1<string> | Record<string, string>>): this;
   /** Adds a spread element (e.g. `...args`, `...options`) to the pattern. */
   spread(name: string): this;
-  /** Renders the pattern into a `BindingName`. */
-  protected $pattern(): ts.BindingName | undefined;
-  $render(): ts.Node;
+}
+//#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: Symbol | string | MaybeTsDsl<ts.Expression>, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>): this;
 }
 //#endregion
 //#region src/ts-dsl/decl/param.d.ts
-declare class ParamTsDsl extends TsDsl<ts.ParameterDeclaration> {
-  protected name?: string;
+type ParamName = Symbol | string;
+type ParamCtor = (name: ParamName | ((p: ParamTsDsl) => void), fn?: (p: ParamTsDsl) => void) => ParamTsDsl;
+declare const Mixed$46: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ParameterDeclaration>, ValueMethods>, PatternMethods>, OptionalMethods>, DecoratorMethods>;
+declare class ParamTsDsl extends Mixed$46 {
+  readonly '~dsl' = "ParamTsDsl";
+  protected name?: Ref<ParamName>;
   protected _type?: TypeTsDsl;
-  constructor(name: string | ((p: ParamTsDsl) => void), fn?: (p: ParamTsDsl) => void);
+  constructor(name: ParamName | ((p: ParamTsDsl) => void), fn?: (p: ParamTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
   /** Sets the parameter type. */
   type(type: string | TypeTsDsl): this;
-  $render(): ts.ParameterDeclaration;
+  toAst(): ts.ParameterDeclaration;
 }
-interface ParamTsDsl extends DecoratorMixin, OptionalMixin, PatternMixin, ValueMixin {}
 //#endregion
 //#region src/ts-dsl/mixins/param.d.ts
-declare class ParamMixin extends TsDsl {
-  protected _params?: Array<MaybeTsDsl<ts.ParameterDeclaration>>;
+interface ParamMethods extends Node {
+  /** Renders the parameters into an array of `ParameterDeclaration`s. */
+  $params(): ReadonlyArray<ts.ParameterDeclaration>;
   /** Adds a parameter. */
-  param(name: string | ((p: ParamTsDsl) => void), fn?: (p: ParamTsDsl) => void): this;
+  param(...args: Parameters<ParamCtor>): this;
   /** Adds multiple parameters. */
   params(...params: ReadonlyArray<MaybeTsDsl<ts.ParameterDeclaration>>): this;
-  /** Renders the parameters into an array of `ParameterDeclaration`s. */
-  protected $params(): ReadonlyArray<ts.ParameterDeclaration>;
-  $render(): ts.Node;
 }
 //#endregion
-//#region src/ts-dsl/decl/init.d.ts
-declare class InitTsDsl extends TsDsl<ts.ConstructorDeclaration> {
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  constructor(fn?: (i: InitTsDsl) => void);
-  /** Builds the `ConstructorDeclaration` node. */
-  $render(): ts.ConstructorDeclaration;
+//#region src/ts-dsl/layout/doc.d.ts
+declare class DocTsDsl extends TsDsl<ts.Node> {
+  readonly '~dsl' = "DocTsDsl";
+  protected _lines: Array<string>;
+  constructor(lines?: MaybeArray$1<string>, fn?: (d: DocTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
+  add(...lines: ReadonlyArray<string>): this;
+  apply<T extends ts.Node>(node: T): T;
+  toAst(): ts.Node;
 }
-interface InitTsDsl extends DecoratorMixin, DoMixin, DocMixin, ParamMixin, PrivateMixin, ProtectedMixin, PublicMixin {}
 //#endregion
-//#region src/ts-dsl/decl/method.d.ts
-declare class MethodTsDsl extends TsDsl<ts.MethodDeclaration> {
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  protected name: string;
-  protected _returns?: TypeTsDsl;
-  constructor(name: string, fn?: (m: MethodTsDsl) => void);
-  /** Sets the return type. */
-  returns(type: string | TypeTsDsl): this;
-  /** Builds the `MethodDeclaration` node. */
-  $render(): ts.MethodDeclaration;
+//#region src/ts-dsl/mixins/doc.d.ts
+interface DocMethods extends Node {
+  $docs<T extends ts.Node>(node: T): T;
+  doc(lines?: MaybeArray$1<string>, fn?: (d: DocTsDsl) => void): this;
 }
-interface MethodTsDsl extends AbstractMixin, AsyncMixin, DecoratorMixin, DoMixin, DocMixin, OptionalMixin, ParamMixin, PrivateMixin, ProtectedMixin, PublicMixin, StaticMixin, TypeParamsMixin {}
 //#endregion
-//#region src/ts-dsl/decl/class.d.ts
-declare class ClassTsDsl extends TsDsl<ts.ClassDeclaration> {
-  protected heritageClauses: Array<ts.HeritageClause>;
-  protected body: Array<MaybeTsDsl<ts.ClassElement | NewlineTsDsl>>;
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  protected name: string;
-  constructor(name: string);
-  /** Adds one or more class members (fields, methods, etc.). */
-  do(...items: ReadonlyArray<MaybeTsDsl<ts.ClassElement | ts.Node>>): this;
-  /** Adds a base class to extend from. */
-  extends(base?: string | ts.Expression | false | null): this;
-  /** Adds a class field. */
-  field(name: string, fn?: (f: FieldTsDsl) => void): this;
-  /** Adds a class constructor. */
-  init(fn?: (i: InitTsDsl) => void): this;
-  /** Adds a class method. */
-  method(name: string, fn?: (m: MethodTsDsl) => void): this;
-  /** Inserts an empty line between members for formatting. */
-  newline(): this;
-  /** Builds the `ClassDeclaration` node. */
-  $render(): ts.ClassDeclaration;
+//#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;
 }
-interface ClassTsDsl extends AbstractMixin, DecoratorMixin, DefaultMixin, DocMixin, ExportMixin, TypeParamsMixin {}
 //#endregion
-//#region src/ts-dsl/decl/member.d.ts
-type Value$1 = string | number | MaybeTsDsl<ts.Expression>;
-type ValueFn$1 = Value$1 | ((m: EnumMemberTsDsl) => void);
-declare class EnumMemberTsDsl extends TsDsl<ts.EnumMember> {
-  private _name;
-  private _value?;
-  constructor(name: string, value?: ValueFn$1);
-  /** Sets the enum member value. */
-  value(value?: Value$1): this;
-  $render(): ts.EnumMember;
+//#region src/ts-dsl/decl/getter.d.ts
+type GetterName = string | ts.PropertyName;
+declare const Mixed$45: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.GetAccessorDeclaration>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AbstractMethods>;
+declare class GetterTsDsl extends Mixed$45 {
+  readonly '~dsl' = "GetterTsDsl";
+  protected name: GetterName;
+  constructor(name: GetterName, fn?: (g: GetterTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.GetAccessorDeclaration;
 }
-interface EnumMemberTsDsl extends DocMixin {}
 //#endregion
-//#region src/ts-dsl/decl/enum.d.ts
-type Value = string | number | MaybeTsDsl<ts.Expression>;
-type ValueFn = Value | ((m: EnumMemberTsDsl) => void);
-declare class EnumTsDsl extends TsDsl<ts.EnumDeclaration> {
-  private _members;
-  private _name;
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  constructor(name: string | ts.Identifier, fn?: (e: EnumTsDsl) => void);
-  /** Adds an enum member. */
-  member(name: string, value?: ValueFn): this;
-  /** Adds multiple enum members. */
-  members(...members: ReadonlyArray<EnumMemberTsDsl>): this;
-  /** Renders the enum declaration. */
-  $render(): ts.EnumDeclaration;
+//#region src/ts-dsl/stmt/if.d.ts
+type IfCondition = string | MaybeTsDsl<ts.Expression>;
+declare const Mixed$44: MixinCtor<abstract new () => TsDsl<ts.IfStatement>, DoMethods>;
+declare class IfTsDsl extends Mixed$44 {
+  readonly '~dsl' = "IfTsDsl";
+  protected _condition?: IfCondition;
+  protected _else?: Array<DoExpr>;
+  constructor(condition?: IfCondition);
+  analyze(ctx: AnalysisContext): void;
+  condition(condition: IfCondition): this;
+  otherwise(...items: Array<DoExpr>): this;
+  toAst(): ts.IfStatement;
 }
-interface EnumTsDsl extends ConstMixin, DocMixin, ExportMixin {}
 //#endregion
-//#region src/ts-dsl/expr/binary.d.ts
-type Expr$3 = string | MaybeTsDsl<ts.Expression>;
-type Op$1 = Operator | ts.BinaryOperator;
-type Operator = '!=' | '!==' | '&&' | '*' | '+' | '-' | '/' | '<' | '<=' | '=' | '==' | '===' | '>' | '>=' | '??' | '||';
-declare class BinaryTsDsl extends TsDsl<ts.BinaryExpression> {
-  protected _base: Expr$3;
-  protected _expr?: Expr$3;
-  protected _op?: Op$1;
-  constructor(base: Expr$3, op?: Op$1, expr?: Expr$3);
-  /** Logical AND — `this && expr` */
-  and(expr: Expr$3): this;
-  /** Creates an assignment expression (e.g. `this = expr`). */
-  assign(expr: Expr$3): this;
-  /** Nullish coalescing — `this ?? expr` */
-  coalesce(expr: Expr$3): this;
-  /** Division — `this / expr` */
-  div(expr: Expr$3): this;
-  /** Strict equality — `this === expr` */
-  eq(expr: Expr$3): this;
-  /** Greater than — `this > expr` */
-  gt(expr: Expr$3): this;
-  /** Greater than or equal — `this >= expr` */
-  gte(expr: Expr$3): this;
-  /** Loose equality — `this == expr` */
-  looseEq(expr: Expr$3): this;
-  /** Loose inequality — `this != expr` */
-  looseNeq(expr: Expr$3): this;
-  /** Less than — `this < expr` */
-  lt(expr: Expr$3): this;
-  /** Less than or equal — `this <= expr` */
-  lte(expr: Expr$3): this;
-  /** Subtraction — `this - expr` */
-  minus(expr: Expr$3): this;
-  /** Strict inequality — `this !== expr` */
-  neq(expr: Expr$3): this;
-  /** Logical OR — `this || expr` */
-  or(expr: Expr$3): this;
-  /** Addition — `this + expr` */
-  plus(expr: Expr$3): this;
-  /** Multiplication — `this * expr` */
-  times(expr: Expr$3): this;
-  $render(): ts.BinaryExpression;
-  /** Sets the binary operator and right-hand operand for this expression. */
-  private opAndExpr;
-  private opToToken;
+//#region src/ts-dsl/decl/setter.d.ts
+type SetterName = string | ts.PropertyName;
+declare const Mixed$43: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.SetAccessorDeclaration>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AbstractMethods>;
+declare class SetterTsDsl extends Mixed$43 {
+  readonly '~dsl' = "SetterTsDsl";
+  protected name: SetterName;
+  constructor(name: SetterName, fn?: (s: SetterTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.SetAccessorDeclaration;
 }
-interface BinaryTsDsl extends AsMixin, ExprMixin {}
 //#endregion
-//#region src/ts-dsl/mixins/operator.d.ts
-type This = string | MaybeTsDsl<ts.Expression>;
-type Expr$2 = string | MaybeTsDsl<ts.Expression>;
-declare class OperatorMixin {
-  /** Logical AND — `this && expr` */
-  and(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Creates an assignment expression (e.g. `this = expr`). */
-  assign(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Nullish coalescing — `this ?? expr` */
-  coalesce(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Division — `this / expr` */
-  div(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Strict equality — `this === expr` */
-  eq(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Greater than — `this > expr` */
-  gt(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Greater than or equal — `this >= expr` */
-  gte(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Loose equality — `this == expr` */
-  looseEq(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Loose inequality — `this != expr` */
-  looseNeq(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Less than — `this < expr` */
-  lt(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Less than or equal — `this <= expr` */
-  lte(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Subtraction — `this - expr` */
-  minus(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Strict inequality — `this !== expr` */
-  neq(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Logical OR — `this || expr` */
-  or(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Addition — `this + expr` */
-  plus(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Multiplication — `this * expr` */
-  times(this: This, expr: Expr$2): BinaryTsDsl;
+//#region src/ts-dsl/type/param.d.ts
+type TypeParamName = Symbol | string;
+type TypeParamExpr = Symbol | string | boolean | MaybeTsDsl<TypeTsDsl>;
+declare const Mixed$42: abstract new () => TypeTsDsl<ts.TypeParameterDeclaration>;
+declare class TypeParamTsDsl extends Mixed$42 {
+  readonly '~dsl' = "TypeParamTsDsl";
+  protected constraint?: Ref<TypeParamExpr>;
+  protected defaultValue?: Ref<TypeParamExpr>;
+  protected name?: Ref<TypeParamName>;
+  constructor(name?: TypeParamName, fn?: (name: TypeParamTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
+  default(value: TypeParamExpr): this;
+  extends(constraint: TypeParamExpr): this;
+  toAst(): ts.TypeParameterDeclaration;
 }
 //#endregion
-//#region src/ts-dsl/expr/attr.d.ts
-declare class AttrTsDsl extends TsDsl<ts.PropertyAccessExpression | ts.ElementAccessExpression> {
-  protected left: string | MaybeTsDsl<ts.Expression>;
-  protected right: string | ts.MemberName | number;
-  constructor(left: string | MaybeTsDsl<ts.Expression>, right: string | ts.MemberName | number);
-  $render(): ts.PropertyAccessExpression | ts.ElementAccessExpression;
+//#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<Symbol | string | MaybeTsDsl<TypeParamTsDsl>>): this;
 }
-interface AttrTsDsl extends AsMixin, ExprMixin, OperatorMixin, OptionalMixin {}
 //#endregion
-//#region src/ts-dsl/expr/await.d.ts
-declare class AwaitTsDsl extends TsDsl<ts.AwaitExpression> {
-  protected _awaitExpr: string | MaybeTsDsl<ts.Expression>;
+//#region src/ts-dsl/expr/typeof.d.ts
+declare const Mixed$41: MixinCtor<abstract new () => TsDsl<ts.TypeOfExpression>, OperatorMethods>;
+declare class TypeOfExprTsDsl extends Mixed$41 {
+  readonly '~dsl' = "TypeOfExprTsDsl";
+  protected _expr: string | MaybeTsDsl<ts.Expression>;
   constructor(expr: string | MaybeTsDsl<ts.Expression>);
-  $render(): ts.AwaitExpression;
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.TypeOfExpression;
 }
-interface AwaitTsDsl extends ExprMixin {}
 //#endregion
-//#region src/ts-dsl/mixins/type-args.d.ts
-declare class TypeArgsMixin extends TsDsl {
-  protected _generics?: Array<string | MaybeTsDsl<TypeTsDsl>>;
-  /** Adds a single type argument (e.g. `string` in `Foo<string>`). */
-  generic(arg: string | MaybeTsDsl<TypeTsDsl>): this;
-  /** Adds type arguments (e.g. `Map<string, number>`). */
-  generics(...args: ReadonlyArray<string | MaybeTsDsl<TypeTsDsl>>): this;
-  /** Returns the type arguments as an array of ts.TypeNode nodes. */
-  protected $generics(): ReadonlyArray<ts.TypeNode> | undefined;
-  $render(): ts.Node;
+//#region src/ts-dsl/type/idx.d.ts
+type Base$2 = string | MaybeTsDsl<ts.TypeNode>;
+type Index = string | number | MaybeTsDsl<ts.TypeNode>;
+declare const Mixed$40: MixinCtor<abstract new () => TypeTsDsl<ts.IndexedAccessTypeNode>, TypeExprMethods>;
+declare class TypeIdxTsDsl extends Mixed$40 {
+  readonly '~dsl' = "TypeIdxTsDsl";
+  protected _base: Base$2;
+  protected _index: Index;
+  constructor(base: Base$2, index: Index);
+  analyze(ctx: AnalysisContext): void;
+  base(base: Base$2): this;
+  index(index: Index): this;
+  toAst(): ts.IndexedAccessTypeNode;
 }
 //#endregion
-//#region src/ts-dsl/expr/call.d.ts
-declare class CallTsDsl extends TsDsl<ts.CallExpression> {
-  protected _callee: string | MaybeTsDsl<ts.Expression>;
-  constructor(callee: string | MaybeTsDsl<ts.Expression>, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression> | undefined>);
-  $render(): ts.CallExpression;
+//#region src/ts-dsl/type/operator.d.ts
+type Op = ts.SyntaxKind.KeyOfKeyword | ts.SyntaxKind.ReadonlyKeyword | ts.SyntaxKind.UniqueKeyword;
+type Type$2 = string | MaybeTsDsl<ts.TypeNode>;
+declare const Mixed$39: abstract new () => TypeTsDsl<ts.TypeOperatorNode>;
+/**
+ * Builds a TypeScript `TypeOperatorNode`, such as:
+ *
+ * - `keyof T`
+ * - `readonly U`
+ * - `unique V`
+ *
+ * This DSL provides both a generic `.operator()` API and convenient
+ * shorthand methods (`.keyof()`, `.readonly()`, `.unique()`).
+ *
+ * The node will throw during render if required fields are missing.
+ */
+declare class TypeOperatorTsDsl extends Mixed$39 {
+  readonly '~dsl' = "TypeOperatorTsDsl";
+  protected _op?: Op;
+  protected _type?: Type$2;
+  analyze(ctx: AnalysisContext): void;
+  /** Shorthand: builds `keyof T`. */
+  keyof(type: Type$2): this;
+  /** Sets the operator explicitly. */
+  operator(op: Op): this;
+  /** Shorthand: builds `readonly T`. */
+  readonly(type: Type$2): this;
+  /** Sets the target type of the operator. */
+  type(type: Type$2): this;
+  /** Shorthand: builds `unique T`. */
+  unique(type: Type$2): this;
+  toAst(): ts.TypeOperatorNode;
+  /** Throws if required fields are not set. */
+  $validate(): asserts this is this & {
+    _op: Op;
+    _type: Type$2;
+  };
+  private missingRequiredCalls;
 }
-interface CallTsDsl extends ArgsMixin, AsMixin, ExprMixin, TypeArgsMixin {}
 //#endregion
-//#region src/ts-dsl/stmt/return.d.ts
-declare class ReturnTsDsl extends TsDsl<ts.ReturnStatement> {
-  protected _returnExpr?: string | MaybeTsDsl<ts.Expression>;
-  constructor(expr?: string | MaybeTsDsl<ts.Expression>);
-  $render(): ts.ReturnStatement;
+//#region src/ts-dsl/type/query.d.ts
+declare const Mixed$38: MixinCtor<abstract new () => TypeTsDsl<ts.TypeQueryNode>, TypeExprMethods>;
+declare class TypeQueryTsDsl extends Mixed$38 {
+  readonly '~dsl' = "TypeQueryTsDsl";
+  protected _expr: string | MaybeTsDsl<TypeTsDsl | ts.Expression>;
+  constructor(expr: string | MaybeTsDsl<TypeTsDsl | ts.Expression>);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.TypeQueryNode;
+}
+//#endregion
+//#region src/ts-dsl/mixins/type-expr.d.ts
+interface TypeExprMethods extends Node {
+  /** Creates an indexed-access type (e.g. `Foo<T>[K]`). */
+  idx(this: MaybeTsDsl<TypeTsDsl>, index: string | number | MaybeTsDsl<ts.TypeNode>): TypeIdxTsDsl;
+  /** Shorthand: builds `keyof T`. */
+  keyof(this: MaybeTsDsl<TypeTsDsl>): TypeOperatorTsDsl;
+  /** Shorthand: builds `readonly T`. */
+  readonly(this: MaybeTsDsl<TypeTsDsl>): TypeOperatorTsDsl;
+  /** Create a TypeExpr node representing ReturnType<this>. */
+  returnType(this: MaybeTsDsl<ts.Expression>): TypeExprTsDsl;
+  /** Create a TypeOfExpr node representing typeof this. */
+  typeofExpr(this: MaybeTsDsl<ts.Expression>): TypeOfExprTsDsl;
+  /** Create a TypeQuery node representing typeof this. */
+  typeofType(this: MaybeTsDsl<TypeTsDsl | ts.Expression>): TypeQueryTsDsl;
+  /** Shorthand: builds `unique T`. */
+  unique(this: MaybeTsDsl<TypeTsDsl>): TypeOperatorTsDsl;
+}
+//#endregion
+//#region src/ts-dsl/type/attr.d.ts
+type Base$1 = Symbol | string | MaybeTsDsl<ts.EntityName>;
+type Right = Symbol | string | ts.Identifier;
+declare const Mixed$37: MixinCtor<abstract new () => TypeTsDsl<ts.QualifiedName>, TypeExprMethods>;
+declare class TypeAttrTsDsl extends Mixed$37 {
+  readonly '~dsl' = "TypeAttrTsDsl";
+  protected _base?: Ref<Base$1>;
+  protected _right: Ref<Right>;
+  constructor(base: Base$1 | Ref<Base$1>, right: string | ts.Identifier);
+  constructor(right: Right);
+  analyze(ctx: AnalysisContext): void;
+  base(base?: Base$1 | Ref<Base$1>): this;
+  right(right: Right): this;
+  toAst(): ts.QualifiedName;
+}
+//#endregion
+//#region src/ts-dsl/type/expr.d.ts
+type TypeExprName = Symbol | string;
+type TypeExprExpr = TypeExprName | TypeAttrTsDsl;
+declare const Mixed$36: MixinCtor<MixinCtor<abstract new () => TypeTsDsl<ts.TypeReferenceNode>, TypeExprMethods>, TypeArgsMethods>;
+declare class TypeExprTsDsl extends Mixed$36 {
+  readonly '~dsl' = "TypeExprTsDsl";
+  protected _exprInput?: Ref<TypeExprExpr>;
+  constructor();
+  constructor(fn: (t: TypeExprTsDsl) => void);
+  constructor(name: TypeExprName);
+  constructor(name: TypeExprName, fn?: (t: TypeExprTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
+  /** Accesses a nested type (e.g. `Foo.Bar`). */
+  attr(right: string | ts.Identifier | TypeAttrTsDsl): this;
+  toAst(): ts.TypeReferenceNode;
+}
+//#endregion
+//#region src/ts-dsl/decl/field.d.ts
+type FieldType = TypeExprName | TypeTsDsl;
+declare const Mixed$35: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.PropertyDeclaration>, ValueMethods>, StaticMethods>, ReadonlyMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, DocMethods>, DecoratorMethods>;
+declare class FieldTsDsl extends Mixed$35 {
+  readonly '~dsl' = "FieldTsDsl";
+  protected name: string;
+  protected _type?: TypeTsDsl;
+  constructor(name: string, fn?: (f: FieldTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
+  /** Sets the field type. */
+  type(type: FieldType): this;
+  toAst(): ts.PropertyDeclaration;
+}
+//#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 {
+  readonly '~dsl' = "InitTsDsl";
+  constructor(fn?: (i: InitTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.ConstructorDeclaration;
+}
+//#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<abstract new () => TsDsl<ts.MethodDeclaration>, TypeParamsMethods>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, OptionalMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AbstractMethods>;
+declare class MethodTsDsl extends Mixed$33 {
+  readonly '~dsl' = "MethodTsDsl";
+  protected name: string;
+  protected _returns?: TypeTsDsl;
+  constructor(name: string, fn?: (m: MethodTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
+  /** Sets the return type. */
+  returns(type: string | TypeTsDsl): this;
+  toAst(): ts.MethodDeclaration;
+}
+//#endregion
+//#region src/ts-dsl/decl/class.d.ts
+type Base = Symbol | string;
+type Name$1 = Symbol | string;
+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>;
+declare class ClassTsDsl extends Mixed$32 {
+  readonly '~dsl' = "ClassTsDsl";
+  protected baseClass?: Ref<Base>;
+  protected body: Body;
+  protected name: Ref<Name$1>;
+  constructor(name: Name$1);
+  analyze(ctx: AnalysisContext): void;
+  /** Adds one or more class members (fields, methods, etc.). */
+  do(...items: Body): this;
+  /** Records a base class to extend from. */
+  extends(base?: Base): this;
+  /** Adds a class field. */
+  field(name: string, fn?: (f: FieldTsDsl) => void): this;
+  /** Adds a class constructor. */
+  init(fn?: (i: InitTsDsl) => void): this;
+  /** Adds a class method. */
+  method(name: string, fn?: (m: MethodTsDsl) => void): this;
+  /** Inserts an empty line between members for formatting. */
+  newline(): this;
+  toAst(): ts.ClassDeclaration;
+  /** Builds heritage clauses (extends). */
+  private _heritage;
 }
-interface ReturnTsDsl extends ExprMixin {}
 //#endregion
-//#region src/ts-dsl/mixins/expr.d.ts
-declare class ExprMixin {
-  /** Accesses a property on the current expression (e.g. `this.foo`). */
-  attr(this: string | MaybeTsDsl<ts.Expression>, name: string | ts.MemberName | number): AttrTsDsl;
-  /** Awaits the current expression (e.g. `await expr`). */
-  await(this: string | MaybeTsDsl<ts.Expression>): AwaitTsDsl;
-  /** Calls the current expression (e.g. `fn(arg1, arg2)`). */
-  call(this: string | MaybeTsDsl<ts.Expression>, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression> | undefined>): CallTsDsl;
-  /** Produces a `return` statement returning the current expression. */
-  return(this: string | MaybeTsDsl<ts.Expression>): ReturnTsDsl;
+//#region src/ts-dsl/decl/decorator.d.ts
+type DecoratorName = Symbol | string | MaybeTsDsl<ts.Expression>;
+declare const Mixed$31: MixinCtor<abstract new () => TsDsl<ts.Decorator>, ArgsMethods>;
+declare class DecoratorTsDsl extends Mixed$31 {
+  readonly '~dsl' = "DecoratorTsDsl";
+  protected name: Ref<DecoratorName>;
+  constructor(name: DecoratorName, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.Decorator;
 }
 //#endregion
-//#region src/ts-dsl/expr/as.d.ts
-declare class AsTsDsl extends TsDsl<ts.AsExpression> {
-  protected expr: string | MaybeTsDsl<ts.Expression>;
-  protected type: string | TypeTsDsl;
-  constructor(expr: string | MaybeTsDsl<ts.Expression>, type: string | TypeTsDsl);
-  $render(): ts.AsExpression;
+//#region src/ts-dsl/decl/member.d.ts
+type Value$2 = string | number | MaybeTsDsl<ts.Expression>;
+type ValueFn$1 = Value$2 | ((m: EnumMemberTsDsl) => void);
+declare const Mixed$30: MixinCtor<abstract new () => TsDsl<ts.EnumMember>, DocMethods>;
+declare class EnumMemberTsDsl extends Mixed$30 {
+  readonly '~dsl' = "EnumMemberTsDsl";
+  private _name;
+  private _value?;
+  constructor(name: string, value?: ValueFn$1);
+  analyze(ctx: AnalysisContext): void;
+  /** Sets the enum member value. */
+  value(value?: Value$2): this;
+  toAst(): ts.EnumMember;
 }
-interface AsTsDsl extends AsMixin, ExprMixin {}
 //#endregion
-//#region src/ts-dsl/mixins/as.d.ts
-declare class AsMixin {
-  /** Creates an `as` type assertion expression (e.g. `value as Type`). */
-  as(this: string | MaybeTsDsl<ts.Expression>, type: string | TypeTsDsl): AsTsDsl;
+//#region src/ts-dsl/decl/enum.d.ts
+type EnumName = Symbol | string;
+type Value$1 = string | number | MaybeTsDsl<ts.Expression>;
+type ValueFn = Value$1 | ((m: EnumMemberTsDsl) => void);
+declare const Mixed$29: MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.EnumDeclaration>, ExportMethods>, DocMethods>, ConstMethods>;
+declare class EnumTsDsl extends Mixed$29 {
+  readonly '~dsl' = "EnumTsDsl";
+  private _members;
+  private _name;
+  constructor(name: EnumName, fn?: (e: EnumTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
+  /** Adds an enum member. */
+  member(name: string, value?: ValueFn): this;
+  /** Adds multiple enum members. */
+  members(...members: ReadonlyArray<EnumMemberTsDsl>): this;
+  toAst(): ts.EnumDeclaration;
 }
 //#endregion
 //#region src/ts-dsl/decl/func.d.ts
 type FuncMode = 'arrow' | 'decl' | 'expr';
-declare class ImplFuncTsDsl<M extends FuncMode = 'arrow'> extends TsDsl<M extends 'decl' ? ts.FunctionDeclaration : M extends 'expr' ? ts.FunctionExpression : ts.ArrowFunction> {
-  protected mode: FuncMode;
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  protected name?: string;
+type FuncName = Symbol | string;
+declare const Mixed$28: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ArrowFunction>, TypeParamsMethods>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AsMethods>, AbstractMethods>;
+declare class ImplFuncTsDsl<M extends FuncMode = 'arrow'> extends Mixed$28 {
+  readonly '~dsl' = "FuncTsDsl";
+  protected mode?: FuncMode;
+  protected name?: Ref<FuncName>;
   protected _returns?: TypeTsDsl;
   constructor();
   constructor(fn: (f: ImplFuncTsDsl<'arrow'>) => void);
-  constructor(name: string);
-  constructor(name: string, fn: (f: ImplFuncTsDsl<'decl'>) => void);
+  constructor(name: FuncName);
+  constructor(name: FuncName, fn: (f: ImplFuncTsDsl<'decl'>) => void);
+  analyze(ctx: AnalysisContext): void;
   /** Switches the function to an arrow function form. */
   arrow(): FuncTsDsl<'arrow'>;
   /** Switches the function to a function declaration form. */
@@ -7848,9 +7940,8 @@ declare class ImplFuncTsDsl<M extends FuncMode = 'arrow'> extends TsDsl<M extend
   expr(): FuncTsDsl<'expr'>;
   /** Sets the return type. */
   returns(type: string | TypeTsDsl): this;
-  $render(): M extends 'decl' ? ts.FunctionDeclaration : M extends 'expr' ? ts.FunctionExpression : ts.ArrowFunction;
+  toAst(): M extends 'decl' ? ts.FunctionDeclaration : M extends 'expr' ? ts.FunctionExpression : ts.ArrowFunction;
 }
-interface ImplFuncTsDsl extends AbstractMixin, AsMixin, AsyncMixin, DecoratorMixin, DoMixin, DocMixin, ParamMixin, PrivateMixin, ProtectedMixin, PublicMixin, StaticMixin, TypeParamsMixin {}
 declare const FuncTsDsl: {
   new (): FuncTsDsl<"arrow">;
   new (fn: (f: FuncTsDsl<"arrow">) => void): FuncTsDsl<"arrow">;
@@ -7859,44 +7950,48 @@ declare const FuncTsDsl: {
 } & typeof ImplFuncTsDsl;
 type FuncTsDsl<M extends FuncMode = 'arrow'> = ImplFuncTsDsl<M>;
 //#endregion
-//#region src/ts-dsl/decl/getter.d.ts
-declare class GetterTsDsl extends TsDsl<ts.GetAccessorDeclaration> {
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  protected name: string | ts.PropertyName;
-  constructor(name: string | ts.PropertyName, fn?: (g: GetterTsDsl) => void);
-  $render(): ts.GetAccessorDeclaration;
-}
-interface GetterTsDsl extends AbstractMixin, AsyncMixin, DecoratorMixin, DoMixin, DocMixin, ParamMixin, PrivateMixin, ProtectedMixin, PublicMixin, StaticMixin {}
-//#endregion
-//#region src/ts-dsl/decl/setter.d.ts
-declare class SetterTsDsl extends TsDsl<ts.SetAccessorDeclaration> {
-  protected modifiers: {
-    list: () => ts.Modifier[];
+//#region src/ts-dsl/decl/pattern.d.ts
+declare const Mixed$27: abstract new () => TsDsl<ts.BindingName>;
+/**
+ * Builds binding patterns (e.g. `{ foo, bar }`, `[a, b, ...rest]`).
+ */
+declare class PatternTsDsl extends Mixed$27 {
+  readonly '~dsl' = "PatternTsDsl";
+  protected pattern?: {
+    kind: 'array';
+    values: ReadonlyArray<string>;
+  } | {
+    kind: 'object';
+    values: Record<string, string>;
   };
-  protected name: string | ts.PropertyName;
-  constructor(name: string | ts.PropertyName, fn?: (s: SetterTsDsl) => void);
-  $render(): ts.SetAccessorDeclaration;
+  protected _spread?: string;
+  analyze(ctx: AnalysisContext): void;
+  /** 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 }`). */
+  object(...props: ReadonlyArray<MaybeArray$1<string> | Record<string, string>>): this;
+  /** Adds a spread element (e.g. `...rest`, `...options`, `...args`). */
+  spread(name: string): this;
+  toAst(): ts.ObjectBindingPattern | ts.ArrayBindingPattern;
+  private createSpread;
 }
-interface SetterTsDsl extends AbstractMixin, AsyncMixin, DecoratorMixin, DoMixin, DocMixin, ParamMixin, PrivateMixin, ProtectedMixin, PublicMixin, StaticMixin {}
 //#endregion
 //#region src/ts-dsl/mixins/layout.d.ts
-declare class LayoutMixin {
-  protected static readonly DEFAULT_THRESHOLD = 3;
-  protected layout: boolean | number | undefined;
+interface LayoutMethods extends Node {
+  /** Computes whether output should be multiline based on layout setting and element count. */
+  $multiline(count: number): boolean;
   /** Sets automatic line output with optional threshold (default: 3). */
   auto(threshold?: number): this;
   /** Sets single line output. */
   inline(): this;
   /** Sets multi line output. */
   pretty(): this;
-  /** Computes whether output should be multiline based on layout setting and element count. */
-  protected $multiline(count: number): boolean;
 }
 //#endregion
 //#region src/ts-dsl/expr/array.d.ts
-declare class ArrayTsDsl extends TsDsl<ts.ArrayLiteralExpression> {
+declare const Mixed$26: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ArrayLiteralExpression>, LayoutMethods>, AsMethods>;
+declare class ArrayTsDsl extends Mixed$26 {
+  readonly '~dsl' = "ArrayTsDsl";
   protected _elements: Array<{
     expr: MaybeTsDsl<ts.Expression>;
     kind: 'element';
@@ -7905,185 +8000,78 @@ declare class ArrayTsDsl extends TsDsl<ts.ArrayLiteralExpression> {
     kind: 'spread';
   }>;
   constructor(...exprs: Array<string | number | boolean | MaybeTsDsl<ts.Expression>>);
+  analyze(ctx: AnalysisContext): void;
   /** Adds a single array element. */
   element(expr: string | number | boolean | MaybeTsDsl<ts.Expression>): 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;
-  $render(): ts.ArrayLiteralExpression;
-}
-interface ArrayTsDsl extends AsMixin, LayoutMixin {}
-//#endregion
-//#region src/ts-dsl/expr/typeof.d.ts
-declare class TypeOfExprTsDsl extends TsDsl<ts.TypeOfExpression> {
-  protected _expr: string | MaybeTsDsl<ts.Expression>;
-  constructor(expr: string | MaybeTsDsl<ts.Expression>);
-  $render(): ts.TypeOfExpression;
-}
-interface TypeOfExprTsDsl extends OperatorMixin {}
-//#endregion
-//#region src/ts-dsl/type/attr.d.ts
-declare class TypeAttrTsDsl extends TypeTsDsl<ts.QualifiedName> {
-  protected _base?: string | MaybeTsDsl<ts.EntityName>;
-  protected right: string | ts.Identifier;
-  constructor(base: string | MaybeTsDsl<ts.EntityName>, right: string | ts.Identifier);
-  constructor(right: string | ts.Identifier);
-  base(base?: string | MaybeTsDsl<ts.EntityName>): this;
-  $render(): ts.QualifiedName;
-}
-interface TypeAttrTsDsl extends TypeExprMixin {}
-//#endregion
-//#region src/ts-dsl/type/expr.d.ts
-declare class TypeExprTsDsl extends TypeTsDsl<ts.TypeReferenceNode> {
-  protected _exprInput?: string | ts.Identifier | TypeAttrTsDsl;
-  constructor();
-  constructor(fn: (t: TypeExprTsDsl) => void);
-  constructor(name: string);
-  constructor(name: string, fn?: (t: TypeExprTsDsl) => void);
-  /** Accesses a nested type (e.g. `Foo.Bar`). */
-  attr(right: string | ts.Identifier | TypeAttrTsDsl): this;
-  $render(): ts.TypeReferenceNode;
-}
-interface TypeExprTsDsl extends TypeArgsMixin, TypeExprMixin {}
-//#endregion
-//#region src/ts-dsl/type/idx.d.ts
-declare class TypeIdxTsDsl extends TypeTsDsl<ts.IndexedAccessTypeNode> {
-  protected _base: string | MaybeTsDsl<ts.TypeNode>;
-  protected _index: string | MaybeTsDsl<ts.TypeNode> | number;
-  constructor(base: string | MaybeTsDsl<ts.TypeNode>, index: string | MaybeTsDsl<ts.TypeNode> | number);
-  base(base: string | MaybeTsDsl<ts.TypeNode>): this;
-  index(index: string | MaybeTsDsl<ts.TypeNode> | number): this;
-  $render(): ts.IndexedAccessTypeNode;
-}
-interface TypeIdxTsDsl extends TypeExprMixin {}
-//#endregion
-//#region src/ts-dsl/type/operator.d.ts
-type Op = ts.SyntaxKind.KeyOfKeyword | ts.SyntaxKind.ReadonlyKeyword | ts.SyntaxKind.UniqueKeyword;
-type Type$1 = string | MaybeTsDsl<ts.TypeNode>;
-/**
- * Builds a TypeScript `TypeOperatorNode`, such as:
- *
- * - `keyof T`
- * - `readonly U`
- * - `unique V`
- *
- * This DSL provides both a generic `.operator()` API and convenient
- * shorthand methods (`.keyof()`, `.readonly()`, `.unique()`).
- *
- * The node will throw during render if required fields are missing.
- */
-declare class TypeOperatorTsDsl extends TypeTsDsl<ts.TypeOperatorNode> {
-  protected _op?: Op;
-  protected _type?: Type$1;
-  /** Shorthand: builds `keyof T`. */
-  keyof(type: Type$1): this;
-  /** Sets the operator explicitly. */
-  operator(op: Op): this;
-  /** Shorthand: builds `readonly T`. */
-  readonly(type: Type$1): this;
-  /** Sets the target type of the operator. */
-  type(type: Type$1): this;
-  /** Shorthand: builds `unique T`. */
-  unique(type: Type$1): this;
-  $render(): ts.TypeOperatorNode;
-  /** Throws if required fields are not set. */
-  $validate(): asserts this is this & {
-    _op: Op;
-    _type: Type$1;
-  };
-  private missingRequiredCalls;
-}
-//#endregion
-//#region src/ts-dsl/type/query.d.ts
-declare class TypeQueryTsDsl extends TypeTsDsl<ts.TypeQueryNode> {
-  protected _expr: string | MaybeTsDsl<TypeTsDsl | ts.Expression>;
-  constructor(expr: string | MaybeTsDsl<TypeTsDsl | ts.Expression>);
-  $render(): ts.TypeQueryNode;
-}
-interface TypeQueryTsDsl extends TypeExprMixin {}
-//#endregion
-//#region src/ts-dsl/mixins/type-expr.d.ts
-declare class TypeExprMixin {
-  /** Creates an indexed-access type (e.g. `Foo<T>[K]`). */
-  idx(this: MaybeTsDsl<TypeTsDsl>, index: string | number | MaybeTsDsl<ts.TypeNode>): TypeIdxTsDsl;
-  /** Shorthand: builds `keyof T`. */
-  keyof(this: MaybeTsDsl<TypeTsDsl>): TypeOperatorTsDsl;
-  /** Shorthand: builds `readonly T`. */
-  readonly(this: MaybeTsDsl<TypeTsDsl>): TypeOperatorTsDsl;
-  /** Create a TypeExpr DSL node representing ReturnType<this>. */
-  returnType(this: MaybeTsDsl<ts.Expression>): TypeExprTsDsl;
-  /** Create a TypeOfExpr DSL node representing typeof this. */
-  typeofExpr(this: MaybeTsDsl<ts.Expression>): TypeOfExprTsDsl;
-  /** Create a TypeQuery DSL node representing typeof this. */
-  typeofType(this: MaybeTsDsl<TypeTsDsl | ts.Expression>): TypeQueryTsDsl;
-  /**
-   * Create a `typeof` operator that narrows its return type based on the receiver.
-   *
-   * - If `this` is a `TsDsl<ts.Expression>` → returns TypeOfExprTsDsl
-   * - If `this` is a `TsDsl<TypeTsDsl>`     → returns TypeQueryTsDsl
-   * - If `this` is a raw ts.Expression      → returns TypeOfExprTsDsl
-   * - Otherwise                             → returns TypeQueryTsDsl
-   */
-  typeof<T extends MaybeTsDsl<TypeTsDsl | ts.Expression>>(this: T): T extends MaybeTsDsl<ts.Expression> ? TypeOfExprTsDsl : T extends MaybeTsDsl<TypeTsDsl> ? TypeQueryTsDsl : TypeQueryTsDsl | TypeOfExprTsDsl;
-  /** Shorthand: builds `unique T`. */
-  unique(this: MaybeTsDsl<TypeTsDsl>): TypeOperatorTsDsl;
+  toAst(): ts.ArrayLiteralExpression;
 }
 //#endregion
 //#region src/ts-dsl/expr/expr.d.ts
-declare class ExprTsDsl extends TsDsl<ts.Expression> {
-  protected _exprInput: string | MaybeTsDsl<ts.Expression>;
-  constructor(id: string | MaybeTsDsl<ts.Expression>);
-  $render(): ts.Expression;
+type Id = Symbol | string | MaybeTsDsl<ts.Expression>;
+declare const Mixed$25: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.Expression>, TypeExprMethods>, OperatorMethods>, ExprMethods>, AsMethods>;
+declare class ExprTsDsl extends Mixed$25 {
+  readonly '~dsl' = "ExprTsDsl";
+  protected _exprInput: Ref<Id>;
+  constructor(id: Id);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): any;
 }
-interface ExprTsDsl extends AsMixin, ExprMixin, OperatorMixin, TypeExprMixin {}
 //#endregion
 //#region src/ts-dsl/expr/id.d.ts
-declare class IdTsDsl extends TsDsl<ts.Identifier> {
+declare const Mixed$24: abstract new () => TsDsl<ts.Identifier>;
+declare class IdTsDsl extends Mixed$24 {
+  readonly '~dsl' = "IdTsDsl";
   protected name: string;
   constructor(name: string);
-  $render(): ts.Identifier;
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.Identifier;
 }
 //#endregion
 //#region src/ts-dsl/expr/literal.d.ts
-declare class LiteralTsDsl extends TsDsl<ts.LiteralTypeNode['literal']> {
+declare const Mixed$23: MixinCtor<abstract new () => TsDsl<ts.LiteralExpression | ts.NullLiteral | ts.BooleanLiteral | ts.PrefixUnaryExpression>, AsMethods>;
+declare class LiteralTsDsl extends Mixed$23 {
+  readonly '~dsl' = "LiteralTsDsl";
   protected value: string | number | boolean | null;
   constructor(value: string | number | boolean | null);
-  $render(): ts.LiteralTypeNode['literal'];
+  analyze(ctx: AnalysisContext): void;
+  toAst(): any;
 }
-interface LiteralTsDsl extends AsMixin {}
 //#endregion
 //#region src/ts-dsl/expr/new.d.ts
-declare class NewTsDsl extends TsDsl<ts.NewExpression> {
-  protected classExpr: string | MaybeTsDsl<ts.Expression>;
-  constructor(classExpr: string | MaybeTsDsl<ts.Expression>, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>);
-  /** Builds the `NewExpression` node. */
-  $render(): ts.NewExpression;
+type NewExpr = Symbol | string | MaybeTsDsl<ts.Expression>;
+declare const Mixed$22: MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.NewExpression>, TypeArgsMethods>, ExprMethods>, ArgsMethods>;
+declare class NewTsDsl extends Mixed$22 {
+  readonly '~dsl' = "NewTsDsl";
+  protected classExpr: Ref<NewExpr>;
+  constructor(classExpr: NewExpr, ...args: ReadonlyArray<NewExpr>);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.NewExpression;
 }
-interface NewTsDsl extends ArgsMixin, ExprMixin, TypeArgsMixin {}
 //#endregion
 //#region src/ts-dsl/layout/hint.d.ts
 declare class HintTsDsl extends TsDsl<ts.Node> {
+  readonly '~dsl' = "HintTsDsl";
   protected _lines: Array<string>;
   constructor(lines?: MaybeArray$1<string>, fn?: (d: HintTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
   add(...lines: ReadonlyArray<string>): this;
   apply<T extends ts.Node>(node: T): T;
-  $render(): ts.Node;
+  toAst(): ts.Node;
 }
 //#endregion
 //#region src/ts-dsl/mixins/hint.d.ts
-declare function HintMixin<TBase extends new (...args: ReadonlyArray<any>) => ITsDsl>(Base: TBase): {
-  new (...args: ReadonlyArray<any>): {
-    _hint?: HintTsDsl;
-    hint(lines?: MaybeArray$1<string>, fn?: (h: HintTsDsl) => void): /*elided*/any;
-    $render(): any;
-  };
-} & TBase;
-type HintMixin = InstanceType<ReturnType<typeof HintMixin>>;
+interface HintMethods extends Node {
+  $hint<T extends ts.Node>(node: T): T;
+  hint(lines?: MaybeArray$1<string>, fn?: (h: HintTsDsl) => void): this;
+}
 //#endregion
 //#region src/ts-dsl/expr/prop.d.ts
-type Expr$1 = string | MaybeTsDsl<ts.Expression>;
-type Stmt$1 = string | MaybeTsDsl<ts.Statement>;
+type Expr$1 = Symbol | string | MaybeTsDsl<ts.Expression>;
+type Stmt$1 = Symbol | string | MaybeTsDsl<ts.Statement>;
 type Kind = 'computed' | 'getter' | 'prop' | 'setter' | 'spread';
 type Meta = {
   kind: 'computed';
@@ -8101,30 +8089,35 @@ type Meta = {
   kind: 'spread';
   name?: undefined;
 };
-declare class ObjectPropTsDsl extends TsDsl<ts.ObjectLiteralElementLike> {
-  protected _value?: Expr$1 | Stmt$1;
+declare const Mixed$21: MixinCtor<abstract new () => TsDsl<ts.ObjectLiteralElementLike>, DocMethods>;
+declare class ObjectPropTsDsl extends Mixed$21 {
+  readonly '~dsl' = "ObjectPropTsDsl";
+  protected _value?: Ref<Expr$1 | Stmt$1>;
   protected meta: Meta;
   constructor(meta: Meta);
+  analyze(ctx: AnalysisContext): void;
   /** Returns true when all required builder calls are present. */
   get isValid(): boolean;
   value(value: Expr$1 | Stmt$1 | ((p: ObjectPropTsDsl) => void)): this;
-  $render(): ts.ObjectLiteralElementLike;
+  toAst(): any;
   $validate(): asserts this is this & {
     _value: Expr$1 | Stmt$1;
     kind: Kind;
   };
   private missingRequiredCalls;
 }
-interface ObjectPropTsDsl extends DocMixin {}
 //#endregion
 //#region src/ts-dsl/expr/object.d.ts
-type Expr = string | MaybeTsDsl<ts.Expression>;
-type Stmt = string | MaybeTsDsl<ts.Statement>;
+type Expr = Symbol | string | MaybeTsDsl<ts.Expression>;
+type Stmt = Symbol | string | MaybeTsDsl<ts.Statement>;
 type ExprFn = Expr | ((p: ObjectPropTsDsl) => void);
 type StmtFn = Stmt | ((p: ObjectPropTsDsl) => void);
-declare class ObjectTsDsl extends TsDsl<ts.ObjectLiteralExpression> {
+declare const Mixed$20: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ObjectLiteralExpression>, LayoutMethods>, HintMethods>, ExprMethods>, AsMethods>;
+declare class ObjectTsDsl extends Mixed$20 {
+  readonly '~dsl' = "ObjectTsDsl";
   protected _props: Array<ObjectPropTsDsl>;
   constructor(...props: Array<ObjectPropTsDsl>);
+  analyze(ctx: AnalysisContext): void;
   /** Adds a computed property (e.g. `{ [expr]: value }`). */
   computed(name: string, expr: ExprFn): this;
   /** Adds a getter property (e.g. `{ get foo() { ... } }`). */
@@ -8141,16 +8134,17 @@ declare class ObjectTsDsl extends TsDsl<ts.ObjectLiteralExpression> {
   setter(name: string, stmt: StmtFn): this;
   /** Adds a spread property (e.g. `{ ...options }`). */
   spread(expr: ExprFn): this;
-  /** Builds and returns the object literal expression. */
-  $render(): ts.ObjectLiteralExpression;
+  toAst(): ts.ObjectLiteralExpression;
 }
-interface ObjectTsDsl extends AsMixin, ExprMixin, HintMixin, LayoutMixin {}
 //#endregion
 //#region src/ts-dsl/expr/prefix.d.ts
-declare class PrefixTsDsl extends TsDsl<ts.PrefixUnaryExpression> {
+declare const Mixed$19: abstract new () => TsDsl<ts.PrefixUnaryExpression>;
+declare class PrefixTsDsl extends Mixed$19 {
+  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;
   /** Sets the operand (the expression being prefixed). */
   expr(expr: string | MaybeTsDsl<ts.Expression>): this;
   /** Sets the operator to MinusToken for negation (`-`). */
@@ -8159,98 +8153,138 @@ declare class PrefixTsDsl extends TsDsl<ts.PrefixUnaryExpression> {
   not(): this;
   /** Sets the operator (e.g. `ts.SyntaxKind.ExclamationToken` for `!`). */
   op(op: ts.PrefixUnaryOperator): this;
-  /** Renders the prefix unary expression node. */
-  $render(): ts.PrefixUnaryExpression;
+  toAst(): ts.PrefixUnaryExpression;
 }
 //#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 class RegExpTsDsl extends TsDsl<ts.RegularExpressionLiteral> {
+declare const Mixed$18: abstract new () => TsDsl<ts.RegularExpressionLiteral>;
+declare class RegExpTsDsl extends Mixed$18 {
+  readonly '~dsl' = "RegExpTsDsl";
   protected pattern: string;
   protected flags?: RegexFlags;
   constructor(pattern: string, flags?: RegexFlags);
-  /** Emits a RegularExpressionLiteral node. */
-  $render(): ts.RegularExpressionLiteral;
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.RegularExpressionLiteral;
 }
 //#endregion
 //#region src/ts-dsl/expr/template.d.ts
-declare class TemplateTsDsl extends TsDsl<ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral> {
-  protected parts: Array<string | MaybeTsDsl<ts.Expression>>;
-  constructor(value?: string | MaybeTsDsl<ts.Expression>);
-  add(value: string | MaybeTsDsl<ts.Expression>): this;
-  $render(): ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral;
+type TemplatePart = Symbol | string | MaybeTsDsl<ts.Expression>;
+declare const Mixed$17: abstract new () => TsDsl<ts.NoSubstitutionTemplateLiteral | ts.TemplateExpression>;
+declare class TemplateTsDsl extends Mixed$17 {
+  readonly '~dsl' = "TemplateTsDsl";
+  protected parts: Array<Ref<TemplatePart>>;
+  constructor(value?: TemplatePart);
+  analyze(ctx: AnalysisContext): void;
+  add(value: TemplatePart): this;
+  toAst(): ts.NoSubstitutionTemplateLiteral | ts.TemplateExpression;
 }
 //#endregion
 //#region src/ts-dsl/expr/ternary.d.ts
-declare class TernaryTsDsl extends TsDsl<ts.ConditionalExpression> {
+declare const Mixed$16: abstract new () => TsDsl<ts.ConditionalExpression>;
+declare class TernaryTsDsl extends Mixed$16 {
+  readonly '~dsl' = "TernaryTsDsl";
   protected _condition?: string | MaybeTsDsl<ts.Expression>;
   protected _then?: string | MaybeTsDsl<ts.Expression>;
   protected _else?: string | MaybeTsDsl<ts.Expression>;
   constructor(condition?: string | MaybeTsDsl<ts.Expression>);
+  analyze(ctx: AnalysisContext): void;
   condition(condition: string | MaybeTsDsl<ts.Expression>): this;
   do(expr: string | MaybeTsDsl<ts.Expression>): this;
   otherwise(expr: string | MaybeTsDsl<ts.Expression>): this;
-  $render(): ts.ConditionalExpression;
+  toAst(): ts.ConditionalExpression;
+}
+//#endregion
+//#region src/ts-dsl/layout/newline.d.ts
+declare class NewlineTsDsl extends TsDsl<ts.Identifier> {
+  readonly '~dsl' = "NewlineTsDsl";
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.Identifier;
 }
 //#endregion
 //#region src/ts-dsl/layout/note.d.ts
 declare class NoteTsDsl extends TsDsl<ts.Node> {
+  readonly '~dsl' = "NoteTsDsl";
   protected _lines: Array<string>;
   constructor(lines?: MaybeArray$1<string>, fn?: (d: NoteTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
   add(...lines: ReadonlyArray<string>): this;
   apply<T extends ts.Node>(node: T): T;
-  $render(): ts.Node;
+  toAst(): ts.Node;
 }
 //#endregion
-//#region src/ts-dsl/stmt/if.d.ts
-declare class IfTsDsl extends TsDsl<ts.IfStatement> {
-  protected _condition?: string | MaybeTsDsl<ts.Expression>;
-  protected _else?: ReadonlyArray<MaybeTsDsl<ts.Statement>>;
-  constructor(condition?: string | MaybeTsDsl<ts.Expression>);
-  condition(condition: string | MaybeTsDsl<ts.Expression>): this;
-  otherwise(...statements: ReadonlyArray<MaybeTsDsl<ts.Statement>>): this;
-  $render(): ts.IfStatement;
+//#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 {
+  readonly '~dsl' = "BlockTsDsl";
+  constructor(...items: Array<DoExpr>);
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.Block;
 }
-interface IfTsDsl extends DoMixin {}
 //#endregion
 //#region src/ts-dsl/stmt/stmt.d.ts
-declare class StmtTsDsl extends TsDsl<ts.Statement> {
+declare const Mixed$14: abstract new () => TsDsl<ts.Statement>;
+declare class StmtTsDsl extends Mixed$14 {
+  readonly '~dsl' = "StmtTsDsl";
   protected _inner: ts.Expression | ts.Statement | TsDsl<any>;
   constructor(inner: ts.Expression | ts.Statement | TsDsl<any>);
-  $render(): ts.Statement;
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.Statement;
 }
 //#endregion
 //#region src/ts-dsl/stmt/throw.d.ts
-declare class ThrowTsDsl extends TsDsl<ts.ThrowStatement> {
+declare const Mixed$13: abstract new () => TsDsl<ts.ThrowStatement>;
+declare class ThrowTsDsl extends Mixed$13 {
+  readonly '~dsl' = "ThrowTsDsl";
   protected error: string | MaybeTsDsl<ts.Expression>;
   protected msg?: string | MaybeTsDsl<ts.Expression>;
   protected useNew: boolean;
   constructor(error: string | MaybeTsDsl<ts.Expression>, useNew?: boolean);
+  analyze(ctx: AnalysisContext): void;
   message(value: string | MaybeTsDsl<ts.Expression>): this;
-  $render(): ts.ThrowStatement;
+  toAst(): ts.ThrowStatement;
+}
+//#endregion
+//#region src/ts-dsl/stmt/try.d.ts
+declare const Mixed$12: abstract new () => TsDsl<ts.TryStatement>;
+type CatchParam = Symbol | string;
+declare class TryTsDsl extends Mixed$12 {
+  readonly '~dsl' = "TryTsDsl";
+  protected _catch?: Array<DoExpr>;
+  protected _catchArg?: CatchParam;
+  protected _finally?: Array<DoExpr>;
+  protected _try?: Array<DoExpr>;
+  constructor(...tryBlock: Array<DoExpr>);
+  analyze(ctx: AnalysisContext): void;
+  catch(...items: Array<DoExpr>): this;
+  catchArg(arg: CatchParam): this;
+  finally(...items: Array<DoExpr>): this;
+  try(...items: Array<DoExpr>): this;
+  toAst(): ts.TryStatement;
 }
 //#endregion
 //#region src/ts-dsl/stmt/var.d.ts
-declare class VarTsDsl extends TsDsl<ts.VariableStatement> {
+type VarName = Symbol | string;
+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";
   protected kind: ts.NodeFlags;
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  protected name?: string;
+  protected name?: Ref<VarName>;
   protected _type?: TypeTsDsl;
-  constructor(name?: string);
+  constructor(name?: VarName);
+  analyze(ctx: AnalysisContext): void;
   const(): this;
   let(): this;
   /** Sets the variable type. */
   type(type: string | TypeTsDsl): this;
   var(): this;
-  $render(): ts.VariableStatement;
+  toAst(): ts.VariableStatement;
 }
-interface VarTsDsl extends DefaultMixin, DocMixin, ExportMixin, HintMixin, PatternMixin, ValueMixin {}
 //#endregion
 //#region src/ts-dsl/token.d.ts
 declare class TokenTsDsl<K$1 extends ts.SyntaxKind = never> extends TsDsl<ts.Token<K$1>> {
+  readonly '~dsl' = "TokenTsDsl";
   protected _kind?: K$1;
   /** Sets the token kind */
   kind(kind: K$1): this;
@@ -8266,57 +8300,68 @@ declare class TokenTsDsl<K$1 extends ts.SyntaxKind = never> extends TsDsl<ts.Tok
   readonly(): TokenTsDsl<ts.SyntaxKind.ReadonlyKeyword>;
   /** Creates `...` (spread / rest) */
   spread(): TokenTsDsl<ts.SyntaxKind.DotDotDotToken>;
-  /** Renders the final token */
-  $render(): ts.Token<K$1>;
+  toAst(): ts.Token<K$1>;
 }
 //#endregion
 //#region src/ts-dsl/type/alias.d.ts
-declare class TypeAliasTsDsl extends TsDsl<ts.TypeAliasDeclaration> {
-  protected value?: MaybeTsDsl<ts.TypeNode>;
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  protected name: string;
-  constructor(name: string, fn?: (t: TypeAliasTsDsl) => void);
+type Name = Symbol | string;
+type Value = MaybeTsDsl<ts.TypeNode>;
+declare const Mixed$10: MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.TypeAliasDeclaration>, TypeParamsMethods>, ExportMethods>, DocMethods>;
+declare class TypeAliasTsDsl extends Mixed$10 {
+  readonly '~dsl' = "TypeAliasTsDsl";
+  protected name: Ref<Name>;
+  protected value?: Value;
+  constructor(name: Name, fn?: (t: TypeAliasTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
   /** Sets the type expression on the right-hand side of `= ...`. */
-  type(node: MaybeTsDsl<ts.TypeNode>): this;
-  /** Renders a `TypeAliasDeclaration` node. */
-  $render(): ts.TypeAliasDeclaration;
+  type(node: Value): this;
+  toAst(): ts.TypeAliasDeclaration;
 }
-interface TypeAliasTsDsl extends DocMixin, ExportMixin, TypeParamsMixin {}
 //#endregion
 //#region src/ts-dsl/type/and.d.ts
-declare class TypeAndTsDsl extends TypeTsDsl<ts.IntersectionTypeNode> {
-  protected _types: Array<string | ts.TypeNode | TypeTsDsl>;
-  constructor(...nodes: Array<string | ts.TypeNode | TypeTsDsl>);
-  types(...nodes: Array<string | ts.TypeNode | TypeTsDsl>): this;
-  $render(): ts.IntersectionTypeNode;
+type Type$1 = Symbol | string | ts.TypeNode | TypeTsDsl;
+declare const Mixed$9: abstract new () => TypeTsDsl<ts.IntersectionTypeNode>;
+declare class TypeAndTsDsl extends Mixed$9 {
+  readonly '~dsl' = "TypeAndTsDsl";
+  protected _types: Array<Ref<Type$1>>;
+  constructor(...nodes: Array<Type$1>);
+  analyze(ctx: AnalysisContext): void;
+  types(...nodes: Array<Type$1>): this;
+  toAst(): ts.IntersectionTypeNode;
 }
 //#endregion
 //#region src/ts-dsl/type/func.d.ts
-declare class TypeFuncTsDsl extends TypeTsDsl<ts.FunctionTypeNode> {
+declare const Mixed$8: MixinCtor<MixinCtor<MixinCtor<abstract new () => TypeTsDsl<ts.FunctionTypeNode>, TypeParamsMethods>, ParamMethods>, DocMethods>;
+declare class TypeFuncTsDsl extends Mixed$8 {
+  readonly '~dsl' = "TypeFuncTsDsl";
   protected _returns?: TypeTsDsl;
+  analyze(ctx: AnalysisContext): void;
   /** Sets the return type. */
   returns(type: string | TypeTsDsl): this;
-  $render(): ts.FunctionTypeNode;
+  toAst(): ts.FunctionTypeNode;
 }
-interface TypeFuncTsDsl extends DocMixin, ParamMixin, TypeParamsMixin {}
 //#endregion
 //#region src/ts-dsl/type/literal.d.ts
-declare class TypeLiteralTsDsl extends TypeTsDsl<ts.LiteralTypeNode> {
+declare const Mixed$7: abstract new () => TypeTsDsl<ts.LiteralTypeNode>;
+declare class TypeLiteralTsDsl extends Mixed$7 {
+  readonly '~dsl' = "TypeLiteralTsDsl";
   protected value: string | number | boolean | null;
   constructor(value: string | number | boolean | null);
-  $render(): ts.LiteralTypeNode;
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.LiteralTypeNode;
 }
 //#endregion
 //#region src/ts-dsl/type/mapped.d.ts
-declare class TypeMappedTsDsl extends TypeTsDsl<ts.MappedTypeNode> {
+declare const Mixed$6: abstract new () => TypeTsDsl<ts.MappedTypeNode>;
+declare class TypeMappedTsDsl extends Mixed$6 {
+  readonly '~dsl' = "TypeMappedTsDsl";
   protected questionToken?: TokenTsDsl<ts.SyntaxKind.QuestionToken | ts.SyntaxKind.PlusToken | ts.SyntaxKind.MinusToken>;
   protected readonlyToken?: TokenTsDsl<ts.SyntaxKind.ReadonlyKeyword | ts.SyntaxKind.MinusToken | ts.SyntaxKind.PlusToken>;
   protected _key?: string | MaybeTsDsl<ts.TypeNode>;
   protected _name?: string;
   protected _type?: string | MaybeTsDsl<ts.TypeNode>;
   constructor(name?: string);
+  analyze(ctx: AnalysisContext): void;
   /** Returns true when all required builder calls are present. */
   get isValid(): boolean;
   /** Sets the key constraint: `[K in Constraint]` */
@@ -8333,7 +8378,7 @@ declare class TypeMappedTsDsl extends TypeTsDsl<ts.MappedTypeNode> {
   required(): this;
   /** Sets the mapped value type: `[K in X]: ValueType` */
   type(type: string | MaybeTsDsl<ts.TypeNode>): this;
-  $render(): ts.MappedTypeNode;
+  toAst(): ts.MappedTypeNode;
   $validate(): asserts this is this & {
     _key: string | MaybeTsDsl<ts.TypeNode>;
     _name: string;
@@ -8343,49 +8388,52 @@ declare class TypeMappedTsDsl extends TypeTsDsl<ts.MappedTypeNode> {
 }
 //#endregion
 //#region src/ts-dsl/type/idx-sig.d.ts
-type Type = string | MaybeTsDsl<ts.TypeNode>;
-declare class TypeIdxSigTsDsl extends TypeTsDsl<ts.IndexSignatureDeclaration> {
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  protected _key?: Type;
-  protected _name: string;
-  protected _type?: Type;
-  constructor(name: string, fn?: (i: TypeIdxSigTsDsl) => void);
+type TypeIdxSigName = string;
+type TypeIdxSigType = string | MaybeTsDsl<ts.TypeNode>;
+declare const Mixed$5: MixinCtor<MixinCtor<abstract new () => TypeTsDsl<ts.IndexSignatureDeclaration>, ReadonlyMethods>, DocMethods>;
+declare class TypeIdxSigTsDsl extends Mixed$5 {
+  readonly '~dsl' = "TypeIdxSigTsDsl";
+  protected _key?: TypeIdxSigType;
+  protected _name: TypeIdxSigName;
+  protected _type?: TypeIdxSigType;
+  constructor(name: TypeIdxSigName, fn?: (i: TypeIdxSigTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
   /** Returns true when all required builder calls are present. */
   get isValid(): boolean;
   /** Sets the key type: `[name: T]` */
-  key(type: Type): this;
+  key(type: TypeIdxSigType): this;
   /** Sets the property type. */
-  type(type: Type): this;
-  $render(): ts.IndexSignatureDeclaration;
+  type(type: TypeIdxSigType): this;
+  toAst(): ts.IndexSignatureDeclaration;
   $validate(): asserts this is this & {
-    _key: Type;
-    _name: string;
-    _type: Type;
+    _key: TypeIdxSigType;
+    _name: TypeIdxSigName;
+    _type: TypeIdxSigType;
   };
   private missingRequiredCalls;
 }
-interface TypeIdxSigTsDsl extends DocMixin, ReadonlyMixin {}
 //#endregion
 //#region src/ts-dsl/type/prop.d.ts
-declare class TypePropTsDsl extends TypeTsDsl<ts.TypeElement> {
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  protected name: string;
-  protected _type?: string | MaybeTsDsl<ts.TypeNode>;
-  constructor(name: string, fn: (p: TypePropTsDsl) => void);
+type TypePropName = string;
+type TypePropType = Symbol | string | MaybeTsDsl<ts.TypeNode>;
+declare const Mixed$4: MixinCtor<MixinCtor<MixinCtor<abstract new () => TypeTsDsl<ts.TypeElement>, ReadonlyMethods>, OptionalMethods>, DocMethods>;
+declare class TypePropTsDsl extends Mixed$4 {
+  readonly '~dsl' = "TypePropTsDsl";
+  protected name: TypePropName;
+  protected _type?: Ref<TypePropType>;
+  constructor(name: TypePropName, fn: (p: TypePropTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
   /** Sets the property type. */
-  type(type: string | MaybeTsDsl<ts.TypeNode>): this;
-  /** Builds and returns the property signature. */
-  $render(): ts.TypeElement;
+  type(type: TypePropType): this;
+  toAst(): ts.PropertySignature;
 }
-interface TypePropTsDsl extends DocMixin, OptionalMixin, ReadonlyMixin {}
 //#endregion
 //#region src/ts-dsl/type/object.d.ts
-declare class TypeObjectTsDsl extends TypeTsDsl<ts.TypeNode> {
+declare const Mixed$3: abstract new () => TypeTsDsl<ts.TypeNode>;
+declare class TypeObjectTsDsl extends Mixed$3 {
+  readonly '~dsl' = "TypeObjectTsDsl";
   protected props: Array<TypePropTsDsl | TypeIdxSigTsDsl>;
+  analyze(ctx: AnalysisContext): void;
   /** Returns true if object has at least one property or spread. */
   hasProps(): boolean;
   /** Adds an index signature to the object type. */
@@ -8394,61 +8442,165 @@ declare class TypeObjectTsDsl extends TypeTsDsl<ts.TypeNode> {
   get isEmpty(): boolean;
   /** Adds a property signature (returns property builder). */
   prop(name: string, fn: (p: TypePropTsDsl) => void): this;
-  $render(): ts.TypeNode;
+  toAst(): ts.TypeLiteralNode;
 }
 //#endregion
 //#region src/ts-dsl/type/or.d.ts
-declare class TypeOrTsDsl extends TypeTsDsl<ts.UnionTypeNode> {
-  protected _types: Array<string | ts.TypeNode | TypeTsDsl>;
-  constructor(...nodes: Array<string | ts.TypeNode | TypeTsDsl>);
-  types(...nodes: Array<string | ts.TypeNode | TypeTsDsl>): this;
-  $render(): ts.UnionTypeNode;
+type Type = Symbol | string | ts.TypeNode | TypeTsDsl;
+declare const Mixed$2: abstract new () => TypeTsDsl<ts.UnionTypeNode>;
+declare class TypeOrTsDsl extends Mixed$2 {
+  readonly '~dsl' = "TypeOrTsDsl";
+  protected _types: Array<Ref<Type>>;
+  constructor(...nodes: Array<Type>);
+  analyze(ctx: AnalysisContext): void;
+  types(...nodes: Array<Type>): this;
+  toAst(): ts.UnionTypeNode;
 }
 //#endregion
 //#region src/ts-dsl/type/template.d.ts
-declare class TypeTemplateTsDsl extends TypeTsDsl<ts.TemplateLiteralTypeNode> {
+declare const Mixed$1: abstract new () => TypeTsDsl<ts.TemplateLiteralTypeNode>;
+declare class TypeTemplateTsDsl extends Mixed$1 {
+  readonly '~dsl' = "TypeTemplateTsDsl";
   protected parts: Array<string | MaybeTsDsl<ts.TypeNode>>;
   constructor(value?: string | MaybeTsDsl<ts.TypeNode>);
+  analyze(ctx: AnalysisContext): void;
   /** Adds a raw string segment or embedded type expression. */
   add(part: string | MaybeTsDsl<ts.TypeNode>): this;
-  /** Renders a TemplateLiteralTypeNode. */
-  $render(): ts.TemplateLiteralTypeNode;
+  toAst(): ts.TemplateLiteralTypeNode;
 }
 //#endregion
 //#region src/ts-dsl/type/tuple.d.ts
-declare class TypeTupleTsDsl extends TypeTsDsl<ts.TupleTypeNode> {
+declare const Mixed: abstract new () => TypeTsDsl<ts.TupleTypeNode>;
+declare class TypeTupleTsDsl extends Mixed {
+  readonly '~dsl' = "TypeTupleTsDsl";
   protected _elements: Array<string | ts.TypeNode | TypeTsDsl>;
   constructor(...nodes: Array<string | ts.TypeNode | TypeTsDsl>);
+  analyze(ctx: AnalysisContext): void;
   elements(...types: Array<string | ts.TypeNode | TypeTsDsl>): this;
-  $render(): ts.TupleTypeNode;
+  toAst(): ts.TupleTypeNode;
+}
+//#endregion
+//#region src/ts-dsl/render/typescript.d.ts
+declare class TypeScriptRenderer implements Renderer {
+  /**
+   * Whether `export * from 'module'` should be used when possible instead of named exports.
+   *
+   * @private
+   */
+  private preferExportAll;
+  /**
+   * Controls whether imports/exports include a file extension (e.g., '.ts' or '.js').
+   *
+   * @private
+   */
+  private preferFileExtension;
+  /**
+   * Optional function to transform module specifiers.
+   *
+   * @private
+   */
+  private resolveModuleName?;
+  constructor(args?: {
+    preferExportAll?: boolean;
+    preferFileExtension?: string;
+    resolveModuleName?: (moduleName: string) => string | undefined;
+  });
+  render(ctx: RenderContext): string;
+  supports(ctx: RenderContext): boolean;
+  private getExports;
+  private getImports;
+  private renderExport;
+  private renderImport;
+}
+//#endregion
+//#region src/ts-dsl/utils/keywords.d.ts
+declare const keywords: {
+  browserGlobals: string[];
+  javaScriptGlobals: string[];
+  javaScriptKeywords: string[];
+  nodeGlobals: string[];
+  typeScriptKeywords: string[];
+};
+//#endregion
+//#region src/ts-dsl/utils/regexp.d.ts
+declare const regexp: {
+  /**
+   * Matches characters from the start as long as they're not allowed.
+   */
+  illegalStartCharacters: RegExp;
+  /**
+   * Matches string if it contains only digits and optionally decimal point or
+   * leading minus sign.
+   */
+  number: RegExp;
+  /**
+   * Javascript identifier regexp pattern retrieved from
+   * {@link} https://developer.mozilla.org/docs/Web/JavaScript/Reference/Lexical_grammar#identifiers
+   */
+  typeScriptIdentifier: RegExp;
+};
+//#endregion
+//#region src/ts-dsl/utils/reserved.d.ts
+type List = ReadonlyArray<string>;
+declare class ReservedList {
+  private _array;
+  private _set;
+  constructor(values: List);
+  get '~values'(): Set<string>;
+  /**
+   * Updates the reserved list with new values.
+   *
+   * @param values New reserved values or a function that receives the previous
+   * reserved values and returns the new ones.
+   */
+  set(values: List | ((prev: List) => List)): void;
 }
+/**
+ * Reserved names for identifiers. These names will not be used
+ * for variables, functions, classes, or other identifiers in generated code.
+ */
+declare const reserved: {
+  /**
+   * Reserved names for runtime identifiers. These names will not be used
+   * for variables, functions, classes, or other runtime identifiers in
+   * generated code.
+   */
+  runtime: ReservedList;
+  /**
+   * Reserved names for type identifiers. These names will not be used
+   * for type or interface identifiers in generated code.
+   */
+  type: ReservedList;
+};
 //#endregion
 //#region src/ts-dsl/index.d.ts
-declare const $: ((id: string | typescript0.Expression | TsDsl<typescript0.Expression>) => ExprTsDsl) & {
+declare const $: ((id: any) => 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: string | typescript0.Expression | TsDsl<typescript0.Expression>, type: string | TypeTsDsl<typescript0.TypeNode>) => AsTsDsl;
+  as: (expr: any, type: any) => AsTsDsl;
   /** Creates a property access expression (e.g. `obj.foo`). */
-  attr: (left: string | typescript0.Expression | TsDsl<typescript0.Expression>, right: string | number | typescript0.MemberName) => AttrTsDsl;
+  attr: (left: any, right: any) => AttrTsDsl;
   /** Creates an await expression (e.g. `await promise`). */
-  await: (expr: string | typescript0.Expression | TsDsl<typescript0.Expression>) => AwaitTsDsl;
+  await: (expr: any) => AwaitTsDsl;
   /** Creates a binary expression (e.g. `a + b`). */
-  binary: (base: string | typescript0.Expression | TsDsl<typescript0.Expression>, op?: (("!=" | "!==" | "&&" | "*" | "+" | "-" | "/" | "<" | "<=" | "=" | "==" | "===" | ">" | ">=" | "??" | "||") | typescript0.BinaryOperator) | undefined, expr?: (string | typescript0.Expression | TsDsl<typescript0.Expression>) | undefined) => BinaryTsDsl;
+  binary: (base: any, op?: (("!=" | "!==" | "&&" | "*" | "+" | "-" | "/" | "<" | "<=" | "=" | "==" | "===" | ">" | ">=" | "??" | "||") | typescript0.BinaryOperator) | undefined, expr?: any) => BinaryTsDsl;
+  /** Creates a statement block (`{ ... }`). */
+  block: (...args: ConstructorParameters<typeof BlockTsDsl>) => BlockTsDsl;
   /** Creates a function or method call expression (e.g. `fn(arg)`). */
-  call: (callee: string | typescript0.Expression | TsDsl<typescript0.Expression>, ...args: (string | typescript0.Expression | TsDsl<typescript0.Expression> | undefined)[]) => CallTsDsl;
+  call: (callee: CallCallee, ...args: any[]) => CallTsDsl;
   /** Creates a class declaration or expression. */
-  class: (name: string) => ClassTsDsl;
+  class: (name: any) => ClassTsDsl;
   /** Creates a constant variable declaration (`const`). */
-  const: (name?: string | undefined) => VarTsDsl;
+  const: (name?: any) => VarTsDsl;
   /** Creates a decorator expression (e.g. `@decorator`). */
-  decorator: (name: string | typescript0.Expression, ...args: (string | typescript0.Expression | TsDsl<typescript0.Expression>)[]) => DecoratorTsDsl;
+  decorator: (name: any, ...args: (string | typescript0.Expression | TsDsl<typescript0.Expression>)[]) => DecoratorTsDsl;
   /** Creates a JSDoc documentation block. */
   doc: (lines?: MaybeArray$1<string> | undefined, fn?: ((d: DocTsDsl) => void) | undefined) => DocTsDsl;
   /** Creates an enum declaration. */
-  enum: (name: string | typescript0.Identifier, fn?: ((e: EnumTsDsl) => void) | undefined) => EnumTsDsl;
+  enum: (name: any, fn?: ((e: EnumTsDsl) => void) | undefined) => EnumTsDsl;
   /** Creates a general expression node. */
-  expr: (id: string | typescript0.Expression | TsDsl<typescript0.Expression>) => ExprTsDsl;
+  expr: (id: any) => ExprTsDsl;
   /** Creates a field declaration in a class or object. */
   field: (name: string, fn?: ((f: FieldTsDsl) => void) | undefined) => FieldTsDsl;
   /** Converts a runtime value into a corresponding expression node. */
@@ -8464,17 +8616,17 @@ declare const $: ((id: string | typescript0.Expression | TsDsl<typescript0.Expre
     (name?: string, fn?: (f: FuncTsDsl<"decl">) => void): FuncTsDsl<"arrow"> | FuncTsDsl<"decl">;
   };
   /** Creates a getter method declaration. */
-  getter: (name: string | typescript0.PropertyName, fn?: ((g: GetterTsDsl) => void) | undefined) => GetterTsDsl;
+  getter: (name: GetterName, fn?: ((g: GetterTsDsl) => void) | undefined) => GetterTsDsl;
   /** Creates a single-line comment (//). */
   hint: (lines?: MaybeArray$1<string> | undefined, fn?: ((d: HintTsDsl) => void) | undefined) => HintTsDsl;
   /** Creates an identifier (e.g. `foo`). */
   id: (name: string) => IdTsDsl;
   /** Creates an if statement. */
-  if: (condition?: string | typescript0.Expression | TsDsl<typescript0.Expression> | undefined) => IfTsDsl;
+  if: (condition?: IfCondition | undefined) => IfTsDsl;
   /** Creates an initialization block or statement. */
   init: (fn?: ((i: InitTsDsl) => void) | undefined) => InitTsDsl;
   /** Creates a let variable declaration (`let`). */
-  let: (name?: string | undefined) => VarTsDsl;
+  let: (name?: any) => VarTsDsl;
   /** Creates a literal value (e.g. string, number, boolean). */
   literal: (value: string | number | boolean | null) => LiteralTsDsl;
   /** Creates an enum member declaration. */
@@ -8484,7 +8636,7 @@ declare const $: ((id: string | typescript0.Expression | TsDsl<typescript0.Expre
   /** Creates a negation expression (`-x`). */
   neg: (expr?: string | typescript0.Expression | TsDsl<typescript0.Expression> | undefined, op?: typescript0.PrefixUnaryOperator | undefined) => PrefixTsDsl;
   /** Creates a new expression (e.g. `new ClassName()`). */
-  new: (classExpr: string | typescript0.Expression | TsDsl<typescript0.Expression>, ...args: (string | typescript0.Expression | TsDsl<typescript0.Expression>)[]) => NewTsDsl;
+  new: (classExpr: any, ...args: any[]) => NewTsDsl;
   /** Creates a newline (for formatting purposes). */
   newline: () => NewlineTsDsl;
   /** Creates a logical NOT expression (`!x`). */
@@ -8494,7 +8646,7 @@ declare const $: ((id: string | typescript0.Expression | TsDsl<typescript0.Expre
   /** Creates an object literal expression. */
   object: (...args: ConstructorParameters<typeof ObjectTsDsl>) => ObjectTsDsl;
   /** Creates a parameter declaration for functions or methods. */
-  param: (name: string | ((p: ParamTsDsl) => void), fn?: ((p: ParamTsDsl) => void) | undefined) => ParamTsDsl;
+  param: (name: any, fn?: ((p: ParamTsDsl) => void) | undefined) => ParamTsDsl;
   /** Creates a pattern for destructuring or matching. */
   pattern: () => PatternTsDsl;
   /** Creates a prefix unary expression (e.g. `-x`, `!x`, `~x`). */
@@ -8519,33 +8671,35 @@ declare const $: ((id: string | typescript0.Expression | TsDsl<typescript0.Expre
   /** 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?: string | typescript0.Expression | TsDsl<typescript0.Expression> | undefined) => ReturnTsDsl;
+  return: (expr?: any) => ReturnTsDsl;
   /** Creates a setter method declaration. */
-  setter: (name: string | typescript0.PropertyName, fn?: ((s: SetterTsDsl) => void) | undefined) => SetterTsDsl;
+  setter: (name: SetterName, fn?: ((s: SetterTsDsl) => void) | undefined) => SetterTsDsl;
   /** Wraps an expression or statement-like value into a `StmtTsDsl`. */
   stmt: (inner: typescript0.Expression | typescript0.Statement | TsDsl<any>) => StmtTsDsl;
   /** Creates a template literal expression. */
-  template: (value?: string | typescript0.Expression | TsDsl<typescript0.Expression> | undefined) => TemplateTsDsl;
+  template: (value?: any) => TemplateTsDsl;
   /** Creates a ternary conditional expression (if ? then : else). */
   ternary: (condition?: string | typescript0.Expression | TsDsl<typescript0.Expression> | undefined) => TernaryTsDsl;
   /** Creates a throw statement. */
   throw: (error: string | typescript0.Expression | TsDsl<typescript0.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: string, fn?: ((t: TypeExprTsDsl) => void) | undefined) => TypeExprTsDsl) & {
+  type: ((name: any, fn?: ((t: TypeExprTsDsl) => void) | undefined) => TypeExprTsDsl) & {
     /** Creates a type alias declaration (e.g. `type Foo = Bar`). */
-    alias: (name: string, fn?: ((t: TypeAliasTsDsl) => void) | undefined) => TypeAliasTsDsl;
+    alias: (name: any, 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: string | typescript0.Identifier) => TypeAttrTsDsl;
+    attr: (right: any) => TypeAttrTsDsl;
     /** Creates a basic type reference or type expression (e.g. Foo or Foo<T>). */
-    expr: (name: string, fn?: ((t: TypeExprTsDsl) => void) | undefined) => TypeExprTsDsl;
+    expr: (name: any, fn?: ((t: TypeExprTsDsl) => void) | undefined) => TypeExprTsDsl;
     /** Converts a runtime value into a corresponding type expression node. */
     fromValue: (input: unknown) => TsDsl<typescript0.TypeNode>;
     /** Creates a function type node (e.g. `(a: string) => number`). */
-    func: () => TypeFuncTsDsl;
+    func: (...args: ConstructorParameters<typeof TypeFuncTsDsl>) => TypeFuncTsDsl;
     /** Creates an indexed-access type (e.g. `Foo<T>[K]`). */
     idx: (base: string | typescript0.TypeNode | TsDsl<typescript0.TypeNode>, index: string | number | typescript0.TypeNode | TsDsl<typescript0.TypeNode>) => TypeIdxTsDsl;
     /** Creates a literal type node (e.g. 'foo', 42, or true). */
@@ -8559,7 +8713,7 @@ declare const $: ((id: string | typescript0.Expression | TsDsl<typescript0.Expre
     /** Represents a union type (e.g. `A | B | C`). */
     or: (...args: ConstructorParameters<typeof TypeOrTsDsl>) => TypeOrTsDsl;
     /** Creates a type parameter (e.g. `<T>`). */
-    param: (name?: string | typescript0.Identifier | undefined, fn?: ((name: TypeParamTsDsl) => void) | undefined) => TypeParamTsDsl;
+    param: (name?: any, fn?: ((name: TypeParamTsDsl) => void) | undefined) => TypeParamTsDsl;
     /** Creates a type query node (e.g. `typeof Foo`). */
     query: (expr: string | MaybeTsDsl<typescript0.Expression | TypeTsDsl<typescript0.TypeNode>>) => TypeQueryTsDsl;
     /** Builds a TypeScript template literal *type* (e.g. `${Foo}-${Bar}` as a type). */
@@ -8570,7 +8724,7 @@ declare const $: ((id: string | typescript0.Expression | TsDsl<typescript0.Expre
   /** Creates a runtime `typeof` expression (e.g. typeof x). */
   typeofExpr: (expr: string | typescript0.Expression | TsDsl<typescript0.Expression>) => TypeOfExprTsDsl;
   /** Creates a variable declaration (var). */
-  var: (name?: string | undefined) => VarTsDsl;
+  var: (name?: any) => VarTsDsl;
 };
 type DollarTsDsl = {
   /**
@@ -8676,7 +8830,7 @@ type HeyApiTransformersPlugin = DefinePlugin<UserConfig$13, Config$12>;
 //#region src/plugins/@hey-api/typescript/shared/types.d.ts
 type IrSchemaToAstOptions = {
   plugin: HeyApiTypeScriptPlugin['Instance'];
-  state: ToRefs<PluginState>;
+  state: Refs<PluginState>;
 };
 type PluginState = Pick<Required<SymbolMeta>, 'path'> & Pick<Partial<SymbolMeta>, 'tags'>;
 //#endregion
@@ -14853,6 +15007,8 @@ declare class PluginInstance<T extends Plugin.Types = Plugin.Types> {
     gen: IProject;
     name: string;
   });
+  addNode(node: Node | null): number;
+  updateNode(index: number, node: Node | null): void;
   /**
    * Iterates over various input elements as specified by the event types, in
    * a specific order: servers, schemas, parameters, request bodies, then
@@ -14905,12 +15061,15 @@ declare class PluginInstance<T extends Plugin.Types = Plugin.Types> {
   isSymbolRegistered(identifier: SymbolIdentifier): boolean;
   querySymbol(filter: SymbolMeta): Symbol | undefined;
   referenceSymbol(meta: SymbolMeta): Symbol;
+  /**
+   * @deprecated use `plugin.symbol()` instead
+   */
   registerSymbol(symbol: SymbolIn): Symbol;
   /**
    * Executes plugin's handler function.
    */
   run(): Promise<void>;
-  setSymbolValue(symbol: Symbol, value: unknown): void;
+  symbol(name: SymbolIn['name'], symbol?: Omit<SymbolIn, 'name'>): Symbol;
   private buildEventHooks;
   private forEachError;
   private getSymbolFilePath;
@@ -14923,6 +15082,34 @@ type Hooks = {
    * Event hooks.
    */
   events?: {
+    /**
+     * Triggered after adding or updating a node.
+     *
+     * You can use this to perform actions after a node is added or updated.
+     *
+     * @param args Arguments object.
+     * @returns void
+     */
+    'node:set:after'?: (args: {
+      /** The node added or updated. */
+      node: Node | null;
+      /** Plugin that added or updated the node. */
+      plugin: PluginInstance;
+    }) => void;
+    /**
+     * Triggered before adding or updating a node.
+     *
+     * You can use this to modify the node before it's added or updated.
+     *
+     * @param args Arguments object.
+     * @returns void
+     */
+    'node:set:before'?: (args: {
+      /** The node to be added or updated. */
+      node: Node | null;
+      /** Plugin adding or updating the node. */
+      plugin: PluginInstance;
+    }) => void;
     /**
      * Triggered after executing a plugin handler.
      *
@@ -14971,38 +15158,6 @@ type Hooks = {
       /** Symbol to register. */
       symbol: SymbolIn;
     }) => void;
-    /**
-     * Triggered after setting a symbol value.
-     *
-     * You can use this to perform actions after a symbol's value is set.
-     *
-     * @param args Arguments object.
-     * @returns void
-     */
-    'symbol:setValue:after'?: (args: {
-      /** Plugin that set the symbol value. */
-      plugin: PluginInstance;
-      /** The symbol. */
-      symbol: Symbol;
-      /** The value that was set. */
-      value: unknown;
-    }) => void;
-    /**
-     * Triggered before setting a symbol value.
-     *
-     *  You can use this to modify the value before it's set.
-     *
-     * @param args Arguments object.
-     * @returns void
-     */
-    'symbol:setValue:before'?: (args: {
-      /** Plugin setting the symbol value. */
-      plugin: PluginInstance;
-      /** The symbol. */
-      symbol: Symbol;
-      /** The value to set. */
-      value: unknown;
-    }) => void;
   };
   /**
    * Hooks specifically for overriding operations behavior.
@@ -15164,8 +15319,8 @@ declare namespace Plugin {
    * Generic wrapper for plugin hooks.
    */
   export type Hooks = Pick<BaseConfig, '~hooks'>;
-  export interface Name<Name extends PluginNames> {
-    name: Name;
+  export interface Name<Name$2 extends PluginNames> {
+    name: Name$2;
   }
 
   /**
@@ -15502,10 +15657,28 @@ type UserOutput = {
    * @default null
    */
   lint?: Linters | null;
+  /**
+   * Optional name conflict resolver to customize how naming conflicts
+   * are handled.
+   */
+  nameConflictResolver?: NameConflictResolver;
   /**
    * The absolute path to the output folder.
    */
   path: string;
+  /**
+   * Whether `export * from 'module'` should be used when possible
+   * instead of named exports.
+   *
+   * @default false
+   */
+  preferExportAll?: boolean;
+  /**
+   * Optional function to transform module specifiers.
+   *
+   * @default undefined
+   */
+  resolveModuleName?: (moduleName: string) => string | undefined;
   /**
    * Relative or absolute path to the tsconfig file we should use to
    * generate the output. If a path to tsconfig file is not provided, we
@@ -15520,17 +15693,13 @@ type Output = {
   /**
    * Defines casing of the output fields. By default, we preserve `input`
    * values as data transforms incur a performance penalty at runtime.
-   *
-   * @default undefined
    */
-  case?: StringCase;
+  case: StringCase | undefined;
   /**
    * Clean the `output` folder on every run? If disabled, this folder may
    * be used to store additional files. The default option is `true` to
    * reduce the risk of keeping outdated files around when configuration,
    * input, or package version changes.
-   *
-   * @default true
    */
   clean: boolean;
   /**
@@ -15542,21 +15711,16 @@ type Output = {
   fileName: {
     /**
      * The casing convention to use for generated file names.
-     *
-     * @default 'preserve'
      */
     case: StringCase;
     /**
      * Custom naming pattern for generated file names.
-     *
-     * @default '{{name}}'
      */
     name: StringName;
     /**
      * Suffix to append to file names (before the extension). For example,
      * with a suffix of `.gen`, `example.ts` becomes `example.gen.ts`.
      *
-     * @default '.gen'
      * @example
      * // Given a suffix of `.gen`
      * 'index.ts' -> 'index.ts' (index files are not renamed)
@@ -15567,8 +15731,6 @@ type Output = {
   };
   /**
    * Which formatter to use to process output folder?
-   *
-   * @default null
    */
   format: Formatters | null;
   /**
@@ -15576,28 +15738,36 @@ type Output = {
    * other modules. By default, we don't add a file extension and let the
    * runtime resolve it. If you're using moduleResolution `nodenext`, we
    * default to `.js`.
-   *
-   * @default undefined
    */
   importFileExtension: ImportFileExtensions | (string & {}) | null | undefined;
   /**
    * Should the exports from plugin files be re-exported in the index
    * barrel file? By default, this is enabled and only default plugins
    * are re-exported.
-   *
-   * @default true
    */
   indexFile: boolean;
   /**
    * Which linter to use to process output folder?
-   *
-   * @default null
    */
   lint: Linters | null;
+  /**
+   * Optional name conflict resolver to customize how naming conflicts
+   * are handled.
+   */
+  nameConflictResolver: NameConflictResolver | undefined;
   /**
    * The absolute path to the output folder.
    */
   path: string;
+  /**
+   * Whether `export * from 'module'` should be used when possible
+   * instead of named exports.
+   */
+  preferExportAll: boolean;
+  /**
+   * Optional function to transform module specifiers.
+   */
+  resolveModuleName: ((moduleName: string) => string | undefined) | undefined;
   /**
    * The parsed TypeScript configuration used to generate the output.
    * If no `tsconfig` file path was provided or found, this will be `null`.
@@ -15608,8 +15778,6 @@ type Output = {
    * generate the output. If a path to tsconfig file is not provided, we
    * attempt to find one starting from the location of the
    * `@hey-api/openapi-ts` configuration file and traversing up.
-   *
-   * @default undefined
    */
   tsConfigPath: (string & {}) | null | undefined;
 };
@@ -16255,5 +16423,5 @@ type Config = Omit<Required<UserConfig>, 'input' | 'logs' | 'output' | 'parser'
   plugins: { [K in PluginNames]?: Plugin.Config<PluginConfigMap[K]> };
 };
 //#endregion
-export { StringCase as A, PluginHandler as C, Client$5 as D, Client$4 as E, LazyOrAsync as M, MaybeArray as N, Client$6 as O, Client as S, Client$3 as T, $ as _, Plugin as a, TsDsl as b, OpenApiOperationObject as c, OpenApiResponseObject as d, OpenApiSchemaObject as f, ExpressionTransformer as g, TypeTransformer as h, DefinePlugin as i, IR$1 as j, Client$7 as k, OpenApiParameterObject as l, Logger as m, UserConfig as n, OpenApi as o, Context as p, Input as r, OpenApiMetaObject as s, Config as t, OpenApiRequestBodyObject as u, DollarTsDsl as v, Client$2 as w, TypeTsDsl as x, MaybeTsDsl as y };
-//# sourceMappingURL=config-eqVtXEeO.d.mts.map
+export { Client$4 as A, MaybeTsDsl as C, PluginHandler as D, Client as E, IR$1 as F, LazyOrAsync as I, MaybeArray as L, Client$6 as M, Client$7 as N, Client$2 as O, StringCase as P, TypeScriptRenderer as S, TypeTsDsl as T, $ as _, Plugin as a, regexp as b, OpenApiOperationObject as c, OpenApiResponseObject as d, OpenApiSchemaObject as f, ExpressionTransformer as g, TypeTransformer as h, DefinePlugin as i, Client$5 as j, Client$3 as k, OpenApiParameterObject as l, Logger as m, UserConfig as n, OpenApi as o, Context as p, Input as r, OpenApiMetaObject as s, Config as t, OpenApiRequestBodyObject as u, DollarTsDsl as v, TsDsl as w, keywords as x, reserved as y };
+//# sourceMappingURL=config-uoaRJc6A.d.mts.map