@hey-api/openapi-ts 0.98.1 → 0.98.2

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { n as UserConfig } from "./types-DH7EVLYi.mjs";
-import { AnalysisContext, BindingKind, ExportModule, File, FromRef, ImportModule, Language, Logger, Node, NodeName, NodeNameSanitizer, NodeRelationship, NodeScope, Ref, RenderContext, Renderer, Symbol } from "@hey-api/codegen-core";
+import { AnalysisContext, BindingKind, ExportModule, File, FromRef, ImportModule, Language, Logger, Node, NodeName, NodeNameSanitizer, NodeRelationship, NodeScope, ProjectMeta, Ref, RenderContext, Renderer, Symbol } from "@hey-api/codegen-core";
 import { AnyPluginName, BaseOutput, Casing, Coercer, CoercerMap, ConfigTable, Context, DefinePlugin, DefinePlugin as DefinePlugin$1, FeatureToggle, IR, IR as IR$1, NameTransformer, NamingConfig, NamingOptions, NamingRule, OpenApi, OpenApiMetaObject, OpenApiOperationObject, OpenApiParameterObject, OpenApiRequestBodyObject, OpenApiResponseObject, OpenApiSchemaObject, OperationPath, OperationPathStrategy, OperationStrategy, OperationsStrategy, Plugin, Plugin as Plugin$1, PluginContext, PluginInstance, PluginInstance as PluginInstance$1, RequestSchemaContext, ResolvedRequestValidatorLayer, SchemaVisitorContext, SchemaWithType, TableDirectives, Walker, applyNaming, coerce, defaultPaginationKeywords, defineConfig as defineConfigTable, definePluginConfig, toCase, utils } from "@hey-api/shared";
 import ts from "typescript";
 import { AnyString, LazyOrAsync, MaybeArray, MaybeFunc } from "@hey-api/types";
@@ -425,8 +425,8 @@ interface TypeReturnsMethods extends Node {
 //#endregion
 //#region src/ts-dsl/type/param.d.ts
 type TypeParamExpr = NodeName | boolean | MaybeTsDsl<TypeTsDsl>;
-declare const Mixed$56: abstract new () => TsDsl<ts.TypeParameterDeclaration>;
-declare class TypeParamTsDsl extends Mixed$56 {
+declare const Mixed$57: abstract new () => TsDsl<ts.TypeParameterDeclaration, "typescript">;
+declare class TypeParamTsDsl extends Mixed$57 {
   readonly '~dsl' = "TypeParamTsDsl";
   scope: NodeScope;
   protected constraint?: Ref<TypeParamExpr>;
@@ -593,8 +593,8 @@ interface DecoratorMethods extends Node {
 type ParamName = NodeName | ParamFn;
 type ParamFn = (p: ParamTsDsl) => void;
 type ParamCtor = (name: ParamName, fn?: ParamFn) => ParamTsDsl;
-declare const Mixed$55: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ParameterDeclaration>, ValueMethods>, PatternMethods>, OptionalMethods>, DecoratorMethods>;
-declare class ParamTsDsl extends Mixed$55 {
+declare const Mixed$56: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ParameterDeclaration, "typescript">, ValueMethods>, PatternMethods>, OptionalMethods>, DecoratorMethods>;
+declare class ParamTsDsl extends Mixed$56 {
   readonly '~dsl' = "ParamTsDsl";
   protected _type?: TypeTsDsl;
   constructor(name: ParamName, fn?: ParamFn);
@@ -650,8 +650,8 @@ interface DoMethods extends Node {
 //#endregion
 //#region src/ts-dsl/decl/method.d.ts
 type MethodCtor = (name: NodeName, fn?: (m: MethodTsDsl) => void) => MethodTsDsl;
-declare const Mixed$54: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.MethodDeclaration>, TypeReturnsMethods>, TypeParamsMethods>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, OptionalMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AbstractMethods>;
-declare class MethodTsDsl extends Mixed$54 {
+declare const Mixed$55: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.MethodDeclaration, "typescript">, TypeReturnsMethods>, TypeParamsMethods>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, OptionalMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AbstractMethods>;
+declare class MethodTsDsl extends Mixed$55 {
   readonly '~dsl' = "MethodTsDsl";
   readonly nameSanitizer: (name: string) => string;
   constructor(name: NodeName, fn?: (m: MethodTsDsl) => void);
@@ -681,8 +681,8 @@ interface AsMethods extends Node {
 type AsExpr = NodeName | MaybeTsDsl<ts.Expression>;
 type AsType = NodeName | TypeTsDsl;
 type AsCtor = (expr: AsExpr, type: AsType) => AsTsDsl;
-declare const Mixed$53: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.AsExpression>, ExprMethods>, AsMethods>;
-declare class AsTsDsl extends Mixed$53 {
+declare const Mixed$54: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.AsExpression, "typescript">, ExprMethods>, AsMethods>;
+declare class AsTsDsl extends Mixed$54 {
   readonly '~dsl' = "AsTsDsl";
   protected expr: Ref<AsExpr>;
   protected type: Ref<AsType>;
@@ -695,8 +695,8 @@ declare class AsTsDsl extends Mixed$53 {
 type Expr$2 = NodeName | MaybeTsDsl<ts.Expression>;
 type Op$1 = Operator | ts.BinaryOperator;
 type Operator = '!=' | '!==' | '&&' | '*' | '+' | '-' | '/' | '<' | '<=' | '=' | '==' | '===' | '>' | '>=' | '??' | '??=' | '||';
-declare const Mixed$52: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.BinaryExpression>, ExprMethods>, AsMethods>;
-declare class BinaryTsDsl extends Mixed$52 {
+declare const Mixed$53: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.BinaryExpression, "typescript">, ExprMethods>, AsMethods>;
+declare class BinaryTsDsl extends Mixed$53 {
   readonly '~dsl' = "BinaryTsDsl";
   protected _base: Ref<Expr$2>;
   protected _expr?: Ref<Expr$2>;
@@ -792,8 +792,8 @@ interface OperatorMethods extends Node {
 //#region src/ts-dsl/expr/attr.d.ts
 type AttrLeft = NodeName | MaybeTsDsl<ts.Expression>;
 type AttrCtor = (left: AttrLeft, right: NodeName) => AttrTsDsl;
-declare const Mixed$51: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.PropertyAccessExpression | ts.ElementAccessExpression>, SpreadMethods>, OptionalMethods>, OperatorMethods>, ExprMethods>, AsMethods>;
-declare class AttrTsDsl extends Mixed$51 {
+declare const Mixed$52: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.PropertyAccessExpression | ts.ElementAccessExpression, "typescript">, SpreadMethods>, OptionalMethods>, OperatorMethods>, ExprMethods>, AsMethods>;
+declare class AttrTsDsl extends Mixed$52 {
   readonly '~dsl' = "AttrTsDsl";
   protected _computed: boolean;
   protected _left: Ref<AttrLeft>;
@@ -807,8 +807,8 @@ declare class AttrTsDsl extends Mixed$51 {
 //#region src/ts-dsl/expr/await.d.ts
 type AwaitExpr = NodeName | MaybeTsDsl<ts.Expression>;
 type AwaitCtor = (expr: AwaitExpr) => AwaitTsDsl;
-declare const Mixed$50: MixinCtor<abstract new () => TsDsl<ts.AwaitExpression>, ExprMethods>;
-declare class AwaitTsDsl extends Mixed$50 {
+declare const Mixed$51: MixinCtor<abstract new () => TsDsl<ts.AwaitExpression, "typescript">, ExprMethods>;
+declare class AwaitTsDsl extends Mixed$51 {
   readonly '~dsl' = "AwaitTsDsl";
   protected _awaitExpr: Ref<AwaitExpr>;
   constructor(expr: AwaitExpr);
@@ -831,8 +831,8 @@ interface ArgsMethods extends Node {
 type NewArgs = ReadonlyArray<NewExpr | undefined>;
 type NewExpr = NodeName | MaybeTsDsl<ts.Expression>;
 type NewCtor = (expr: NewExpr, ...args: NewArgs) => NewTsDsl;
-declare const Mixed$49: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.NewExpression>, TypeArgsMethods>, SpreadMethods>, ExprMethods>, AsMethods>, ArgsMethods>;
-declare class NewTsDsl extends Mixed$49 {
+declare const Mixed$50: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.NewExpression, "typescript">, TypeArgsMethods>, SpreadMethods>, ExprMethods>, AsMethods>, ArgsMethods>;
+declare class NewTsDsl extends Mixed$50 {
   readonly '~dsl' = "NewTsDsl";
   protected _newExpr: Ref<NewExpr>;
   constructor(expr: NewExpr, ...args: NewArgs);
@@ -843,8 +843,8 @@ declare class NewTsDsl extends Mixed$49 {
 //#region src/ts-dsl/expr/spread.d.ts
 type SpreadExpr = NodeName | MaybeTsDsl<ts.Expression>;
 type SpreadCtor = (expr: SpreadExpr) => SpreadTsDsl;
-declare const Mixed$48: abstract new () => TsDsl<ts.SpreadElement>;
-declare class SpreadTsDsl extends Mixed$48 {
+declare const Mixed$49: abstract new () => TsDsl<ts.SpreadElement, "typescript">;
+declare class SpreadTsDsl extends Mixed$49 {
   readonly '~dsl' = "SpreadTsDsl";
   protected _expr: Ref<SpreadExpr>;
   constructor(expr: SpreadExpr);
@@ -855,8 +855,8 @@ declare class SpreadTsDsl extends Mixed$48 {
 //#region src/ts-dsl/expr/typeof.d.ts
 type TypeOfExpr = NodeName | MaybeTsDsl<ts.Expression>;
 type TypeOfExprCtor = (expr: TypeOfExpr) => TypeOfExprTsDsl;
-declare const Mixed$47: MixinCtor<abstract new () => TsDsl<ts.TypeOfExpression>, OperatorMethods>;
-declare class TypeOfExprTsDsl extends Mixed$47 {
+declare const Mixed$48: MixinCtor<abstract new () => TsDsl<ts.TypeOfExpression, "typescript">, OperatorMethods>;
+declare class TypeOfExprTsDsl extends Mixed$48 {
   readonly '~dsl' = "TypeOfExprTsDsl";
   protected _expr: TypeOfExpr;
   constructor(expr: TypeOfExpr);
@@ -867,8 +867,8 @@ declare class TypeOfExprTsDsl extends Mixed$47 {
 //#region src/ts-dsl/stmt/return.d.ts
 type ReturnExpr = NodeName | MaybeTsDsl<ts.Expression>;
 type ReturnCtor = (expr?: ReturnExpr) => ReturnTsDsl;
-declare const Mixed$46: abstract new () => TsDsl<ts.ReturnStatement>;
-declare class ReturnTsDsl extends Mixed$46 {
+declare const Mixed$47: abstract new () => TsDsl<ts.ReturnStatement, "typescript">;
+declare class ReturnTsDsl extends Mixed$47 {
   readonly '~dsl' = "ReturnTsDsl";
   protected _returnExpr?: Ref<ReturnExpr>;
   constructor(expr?: ReturnExpr);
@@ -897,8 +897,8 @@ interface TypeExprMethods extends Node {
 //#region src/ts-dsl/type/attr.d.ts
 type Base$1 = NodeName | MaybeTsDsl<ts.EntityName>;
 type Right = NodeName | ts.Identifier;
-declare const Mixed$45: MixinCtor<abstract new () => TsDsl<ts.QualifiedName>, TypeExprMethods>;
-declare class TypeAttrTsDsl extends Mixed$45 {
+declare const Mixed$46: MixinCtor<abstract new () => TsDsl<ts.QualifiedName, "typescript">, TypeExprMethods>;
+declare class TypeAttrTsDsl extends Mixed$46 {
   readonly '~dsl' = "TypeAttrTsDsl";
   scope: NodeScope;
   protected _base?: Ref<Base$1>;
@@ -922,8 +922,8 @@ declare class TypeAttrTsDsl extends Mixed$45 {
 type TypeExprExpr = NodeName | TypeAttrTsDsl;
 type TypeExprFn = (t: TypeExprTsDsl) => void;
 type TypeExprCtor = (nameOrFn?: NodeName | TypeExprFn, fn?: TypeExprFn) => TypeExprTsDsl;
-declare const Mixed$44: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.TypeReferenceNode>, TypeExprMethods>, TypeArgsMethods>;
-declare class TypeExprTsDsl extends Mixed$44 {
+declare const Mixed$45: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.TypeReferenceNode, "typescript">, TypeExprMethods>, TypeArgsMethods>;
+declare class TypeExprTsDsl extends Mixed$45 {
   readonly '~dsl' = "TypeExprTsDsl";
   scope: NodeScope;
   protected _exprInput?: Ref<TypeExprExpr>;
@@ -947,8 +947,8 @@ declare class TypeExprTsDsl extends Mixed$44 {
 type Base = string | MaybeTsDsl<ts.TypeNode>;
 type Index = string | number | MaybeTsDsl<ts.TypeNode>;
 type TypeIdxCtor = (base: Base, index: Index) => TypeIdxTsDsl;
-declare const Mixed$43: MixinCtor<abstract new () => TsDsl<ts.IndexedAccessTypeNode>, TypeExprMethods>;
-declare class TypeIdxTsDsl extends Mixed$43 {
+declare const Mixed$44: MixinCtor<abstract new () => TsDsl<ts.IndexedAccessTypeNode, "typescript">, TypeExprMethods>;
+declare class TypeIdxTsDsl extends Mixed$44 {
   readonly '~dsl' = "TypeIdxTsDsl";
   scope: NodeScope;
   protected _base: Base;
@@ -969,9 +969,9 @@ declare class TypeIdxTsDsl extends Mixed$43 {
 //#endregion
 //#region src/ts-dsl/type/operator.d.ts
 type Op = ts.SyntaxKind.KeyOfKeyword | ts.SyntaxKind.ReadonlyKeyword | ts.SyntaxKind.UniqueKeyword;
-type Type$3 = string | MaybeTsDsl<ts.TypeNode>;
+type Type$4 = string | MaybeTsDsl<ts.TypeNode>;
 type TypeOperatorCtor = () => TypeOperatorTsDsl;
-declare const Mixed$42: abstract new () => TsDsl<ts.TypeOperatorNode>;
+declare const Mixed$43: abstract new () => TsDsl<ts.TypeOperatorNode, "typescript">;
 /**
  * Builds a TypeScript `TypeOperatorNode`, such as:
  *
@@ -984,27 +984,27 @@ declare const Mixed$42: abstract new () => TsDsl<ts.TypeOperatorNode>;
  *
  * The node will throw during render if required fields are missing.
  */
-declare class TypeOperatorTsDsl extends Mixed$42 {
+declare class TypeOperatorTsDsl extends Mixed$43 {
   readonly '~dsl' = "TypeOperatorTsDsl";
   scope: NodeScope;
   protected _op?: Op;
-  protected _type?: Type$3;
+  protected _type?: Type$4;
   analyze(ctx: AnalysisContext): void;
   /** Shorthand: builds `keyof T`. */
-  keyof(type: Type$3): this;
+  keyof(type: Type$4): this;
   /** Sets the operator explicitly. */
   operator(op: Op): this;
   /** Shorthand: builds `readonly T`. */
-  readonly(type: Type$3): this;
+  readonly(type: Type$4): this;
   /** Sets the target type of the operator. */
-  type(type: Type$3): this;
+  type(type: Type$4): this;
   /** Shorthand: builds `unique T`. */
-  unique(type: Type$3): this;
+  unique(type: Type$4): this;
   toAst(): ts.TypeOperatorNode;
   /** Throws if required fields are not set. */
   $validate(): asserts this is this & {
     _op: Op;
-    _type: Type$3;
+    _type: Type$4;
   };
   private missingRequiredCalls;
 }
@@ -1012,8 +1012,8 @@ declare class TypeOperatorTsDsl extends Mixed$42 {
 //#region src/ts-dsl/type/query.d.ts
 type TypeQueryExpr = NodeName | MaybeTsDsl<TypeTsDsl | ts.Expression>;
 type TypeQueryCtor = (expr: TypeQueryExpr) => TypeQueryTsDsl;
-declare const Mixed$41: MixinCtor<abstract new () => TsDsl<ts.TypeQueryNode>, TypeExprMethods>;
-declare class TypeQueryTsDsl extends Mixed$41 {
+declare const Mixed$42: MixinCtor<abstract new () => TsDsl<ts.TypeQueryNode, "typescript">, TypeExprMethods>;
+declare class TypeQueryTsDsl extends Mixed$42 {
   readonly '~dsl' = "TypeQueryTsDsl";
   scope: NodeScope;
   protected _expr: Ref<TypeQueryExpr>;
@@ -1024,8 +1024,8 @@ declare class TypeQueryTsDsl extends Mixed$41 {
 //#endregion
 //#region src/ts-dsl/type/tuple-member.d.ts
 type TypeTupleMemberCtor = (name: NodeName) => TypeTupleMemberTsDsl;
-declare const Mixed$40: MixinCtor<abstract new () => TsDsl<ts.NamedTupleMember>, OptionalMethods>;
-declare class TypeTupleMemberTsDsl extends Mixed$40 {
+declare const Mixed$41: MixinCtor<abstract new () => TsDsl<ts.NamedTupleMember, "typescript">, OptionalMethods>;
+declare class TypeTupleMemberTsDsl extends Mixed$41 {
   readonly '~dsl' = "TypeTupleMemberTsDsl";
   scope: NodeScope;
   protected _type?: Ref<NodeName | TypeTsDsl>;
@@ -1074,8 +1074,8 @@ interface SpreadMethods extends Node {
 type CallArgs = ReadonlyArray<CallCallee | undefined>;
 type CallCallee = NodeName | MaybeTsDsl<ts.Expression>;
 type CallCtor = (callee: CallCallee, ...args: CallArgs) => CallTsDsl;
-declare const Mixed$39: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.CallExpression>, TypeArgsMethods>, SpreadMethods>, ExprMethods>, AsMethods>, ArgsMethods>;
-declare class CallTsDsl extends Mixed$39 {
+declare const Mixed$40: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.CallExpression, "typescript">, TypeArgsMethods>, SpreadMethods>, ExprMethods>, AsMethods>, ArgsMethods>;
+declare class CallTsDsl extends Mixed$40 {
   readonly '~dsl' = "CallTsDsl";
   protected _callee: Ref<CallCallee>;
   constructor(callee: CallCallee, ...args: CallArgs);
@@ -1141,14 +1141,15 @@ declare class TsDslContext {
 declare const ctx: TsDslContext;
 //#endregion
 //#region src/ts-dsl/base.d.ts
-declare abstract class TsDsl<T extends ts.Node = ts.Node> implements Node<T> {
+declare abstract class TsDsl<T extends ts.Node = ts.Node, L extends Language = 'typescript'> implements Node<T> {
   analyze(_: AnalysisContext): void;
   clone(): this;
   exported?: boolean;
   file?: File;
   get name(): Node['name'];
   readonly nameSanitizer?: NodeNameSanitizer;
-  language: Language;
+  language: L;
+  meta: Required<ProjectMeta>[L];
   parent?: Node;
   root: boolean;
   scope?: NodeScope;
@@ -1189,8 +1190,8 @@ type TypeOf<I> = I extends ReadonlyArray<infer U> ? ReadonlyArray<TypeOf<U>> : I
 //#region src/ts-dsl/expr/postfix.d.ts
 type PostfixExpr = string | MaybeTsDsl<ts.Expression>;
 type PostfixOp = ts.PostfixUnaryOperator;
-declare const Mixed$38: abstract new () => TsDsl<ts.PostfixUnaryExpression>;
-declare class PostfixTsDsl extends Mixed$38 {
+declare const Mixed$39: abstract new () => TsDsl<ts.PostfixUnaryExpression, "typescript">;
+declare class PostfixTsDsl extends Mixed$39 {
   readonly '~dsl' = "PostfixTsDsl";
   protected _expr?: PostfixExpr;
   protected _op?: PostfixOp;
@@ -1311,8 +1312,8 @@ declare function createLiteral(value: TsLiteralValue, leadingComments?: Readonly
 //#region src/ts-dsl/expr/prefix.d.ts
 type PrefixExpr = string | MaybeTsDsl<ts.Expression>;
 type PrefixOp = ts.PrefixUnaryOperator;
-declare const Mixed$37: abstract new () => TsDsl<ts.PrefixUnaryExpression>;
-declare class PrefixTsDsl extends Mixed$37 {
+declare const Mixed$38: abstract new () => TsDsl<ts.PrefixUnaryExpression, "typescript">;
+declare class PrefixTsDsl extends Mixed$38 {
   readonly '~dsl' = "PrefixTsDsl";
   protected _expr?: PrefixExpr;
   protected _op?: PrefixOp;
@@ -1352,8 +1353,8 @@ declare class NoteTsDsl extends TsDsl<ts.Node> {
 //#endregion
 //#region src/ts-dsl/decl/field.d.ts
 type FieldType = NodeName | TypeTsDsl;
-declare const Mixed$36: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.PropertyDeclaration>, ValueMethods>, StaticMethods>, ReadonlyMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, OptionalMethods>, DocMethods>, DecoratorMethods>;
-declare class FieldTsDsl extends Mixed$36 {
+declare const Mixed$37: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.PropertyDeclaration, "typescript">, ValueMethods>, StaticMethods>, ReadonlyMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, OptionalMethods>, DocMethods>, DecoratorMethods>;
+declare class FieldTsDsl extends Mixed$37 {
   readonly '~dsl' = "FieldTsDsl";
   readonly nameSanitizer: (name: string) => string;
   protected _type?: TypeTsDsl;
@@ -1365,8 +1366,8 @@ declare class FieldTsDsl extends Mixed$36 {
 }
 //#endregion
 //#region src/ts-dsl/decl/init.d.ts
-declare const Mixed$35: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ConstructorDeclaration>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>;
-declare class InitTsDsl extends Mixed$35 {
+declare const Mixed$36: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ConstructorDeclaration, "typescript">, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>;
+declare class InitTsDsl extends Mixed$36 {
   readonly '~dsl' = "InitTsDsl";
   constructor(fn?: (i: InitTsDsl) => void);
   analyze(ctx: AnalysisContext): void;
@@ -1375,8 +1376,8 @@ declare class InitTsDsl extends Mixed$35 {
 //#endregion
 //#region src/ts-dsl/decl/class.d.ts
 type Body = Array<MaybeTsDsl<ts.ClassElement | ts.Node>>;
-declare const Mixed$34: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ClassDeclaration>, TypeParamsMethods>, ExportMethods>, DocMethods>, DefaultMethods>, DecoratorMethods>, AbstractMethods>;
-declare class ClassTsDsl extends Mixed$34 {
+declare const Mixed$35: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ClassDeclaration, "typescript">, TypeParamsMethods>, ExportMethods>, DocMethods>, DefaultMethods>, DecoratorMethods>, AbstractMethods>;
+declare class ClassTsDsl extends Mixed$35 {
   readonly '~dsl' = "ClassTsDsl";
   readonly nameSanitizer: (name: string) => string;
   protected baseClass?: Ref<NodeName>;
@@ -1403,8 +1404,8 @@ declare class ClassTsDsl extends Mixed$34 {
 }
 //#endregion
 //#region src/ts-dsl/decl/decorator.d.ts
-declare const Mixed$33: MixinCtor<abstract new () => TsDsl<ts.Decorator>, ArgsMethods>;
-declare class DecoratorTsDsl extends Mixed$33 {
+declare const Mixed$34: MixinCtor<abstract new () => TsDsl<ts.Decorator, "typescript">, ArgsMethods>;
+declare class DecoratorTsDsl extends Mixed$34 {
   readonly '~dsl' = "DecoratorTsDsl";
   readonly nameSanitizer: (name: string) => string;
   constructor(name: NodeName, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>);
@@ -1415,8 +1416,8 @@ declare class DecoratorTsDsl extends Mixed$33 {
 //#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$32: MixinCtor<abstract new () => TsDsl<ts.EnumMember>, DocMethods>;
-declare class EnumMemberTsDsl extends Mixed$32 {
+declare const Mixed$33: MixinCtor<abstract new () => TsDsl<ts.EnumMember, "typescript">, DocMethods>;
+declare class EnumMemberTsDsl extends Mixed$33 {
   readonly '~dsl' = "EnumMemberTsDsl";
   private _value?;
   constructor(name: NodeName, value?: ValueFn$1);
@@ -1429,8 +1430,8 @@ declare class EnumMemberTsDsl extends Mixed$32 {
 //#region src/ts-dsl/decl/enum.d.ts
 type Value$1 = string | number | MaybeTsDsl<ts.Expression>;
 type ValueFn = Value$1 | ((m: EnumMemberTsDsl) => void);
-declare const Mixed$31: MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.EnumDeclaration>, ExportMethods>, DocMethods>, ConstMethods>;
-declare class EnumTsDsl extends Mixed$31 {
+declare const Mixed$32: MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.EnumDeclaration, "typescript">, ExportMethods>, DocMethods>, ConstMethods>;
+declare class EnumTsDsl extends Mixed$32 {
   readonly '~dsl' = "EnumTsDsl";
   readonly nameSanitizer: (name: string) => string;
   private _members;
@@ -1445,8 +1446,8 @@ declare class EnumTsDsl extends Mixed$31 {
 //#endregion
 //#region src/ts-dsl/decl/func.d.ts
 type FuncMode = 'arrow' | 'decl' | 'expr';
-declare const Mixed$30: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ArrowFunction>, TypeReturnsMethods>, TypeParamsMethods>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, ExportMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AsMethods>, AbstractMethods>;
-declare class ImplFuncTsDsl<M extends FuncMode = 'arrow'> extends Mixed$30 {
+declare const Mixed$31: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ArrowFunction, "typescript">, TypeReturnsMethods>, TypeParamsMethods>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, ExportMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AsMethods>, AbstractMethods>;
+declare class ImplFuncTsDsl<M extends FuncMode = 'arrow'> extends Mixed$31 {
   readonly '~dsl' = "FuncTsDsl";
   readonly '~mode': M;
   readonly nameSanitizer: (name: string) => string;
@@ -1477,8 +1478,8 @@ declare const FuncTsDsl: {
 type FuncTsDsl<M extends FuncMode = 'arrow'> = ImplFuncTsDsl<M>;
 //#endregion
 //#region src/ts-dsl/decl/getter.d.ts
-declare const Mixed$29: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.GetAccessorDeclaration>, TypeReturnsMethods>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AbstractMethods>;
-declare class GetterTsDsl extends Mixed$29 {
+declare const Mixed$30: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.GetAccessorDeclaration, "typescript">, TypeReturnsMethods>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AbstractMethods>;
+declare class GetterTsDsl extends Mixed$30 {
   readonly '~dsl' = "GetterTsDsl";
   readonly nameSanitizer: (name: string) => string;
   constructor(name: NodeName, fn?: (g: GetterTsDsl) => void);
@@ -1487,11 +1488,11 @@ declare class GetterTsDsl extends Mixed$29 {
 }
 //#endregion
 //#region src/ts-dsl/decl/pattern.d.ts
-declare const Mixed$28: abstract new () => TsDsl<ts.BindingName>;
+declare const Mixed$29: abstract new () => TsDsl<ts.BindingName, "typescript">;
 /**
  * Builds binding patterns (e.g., `{ foo, bar }`, `[a, b, ...rest]`).
  */
-declare class PatternTsDsl extends Mixed$28 {
+declare class PatternTsDsl extends Mixed$29 {
   readonly '~dsl' = "PatternTsDsl";
   protected pattern?: {
     kind: 'array';
@@ -1525,8 +1526,8 @@ declare class PatternTsDsl extends Mixed$28 {
 }
 //#endregion
 //#region src/ts-dsl/decl/setter.d.ts
-declare const Mixed$27: 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$27 {
+declare const Mixed$28: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.SetAccessorDeclaration, "typescript">, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AbstractMethods>;
+declare class SetterTsDsl extends Mixed$28 {
   readonly '~dsl' = "SetterTsDsl";
   readonly nameSanitizer: (name: string) => string;
   constructor(name: NodeName, fn?: (s: SetterTsDsl) => void);
@@ -1548,8 +1549,8 @@ interface LayoutMethods extends Node {
 //#endregion
 //#region src/ts-dsl/expr/array.d.ts
 type ArrayExpr = string | number | boolean | MaybeTsDsl<ts.Expression>;
-declare const Mixed$26: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ArrayLiteralExpression>, SpreadMethods>, LayoutMethods>, ExprMethods>, AsMethods>;
-declare class ArrayTsDsl extends Mixed$26 {
+declare const Mixed$27: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ArrayLiteralExpression, "typescript">, SpreadMethods>, LayoutMethods>, ExprMethods>, AsMethods>;
+declare class ArrayTsDsl extends Mixed$27 {
   readonly '~dsl' = "ArrayTsDsl";
   protected _elements: Array<MaybeTsDsl<ts.Expression>>;
   constructor(...exprs: Array<ArrayExpr>);
@@ -1563,8 +1564,8 @@ declare class ArrayTsDsl extends Mixed$26 {
 //#endregion
 //#region src/ts-dsl/expr/expr.d.ts
 type Id = NodeName | MaybeTsDsl<ts.Expression>;
-declare const Mixed$25: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.Expression>, TypeExprMethods>, SpreadMethods>, OperatorMethods>, ExprMethods>, AsMethods>;
-declare class ExprTsDsl extends Mixed$25 {
+declare const Mixed$26: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.Expression, "typescript">, TypeExprMethods>, SpreadMethods>, OperatorMethods>, ExprMethods>, AsMethods>;
+declare class ExprTsDsl extends Mixed$26 {
   readonly '~dsl' = "ExprTsDsl";
   protected _exprInput: Ref<Id>;
   constructor(id: Id);
@@ -1573,8 +1574,8 @@ declare class ExprTsDsl extends Mixed$25 {
 }
 //#endregion
 //#region src/ts-dsl/expr/id.d.ts
-declare const Mixed$24: abstract new () => TsDsl<ts.Identifier>;
-declare class IdTsDsl extends Mixed$24 {
+declare const Mixed$25: abstract new () => TsDsl<ts.Identifier, "typescript">;
+declare class IdTsDsl extends Mixed$25 {
   readonly '~dsl' = "IdTsDsl";
   constructor(name: string);
   analyze(ctx: AnalysisContext): void;
@@ -1631,8 +1632,8 @@ declare const ts$1: {
 };
 //#endregion
 //#region src/ts-dsl/expr/literal.d.ts
-declare const Mixed$23: MixinCtor<abstract new () => TsDsl<ts.BigIntLiteral | ts.BooleanLiteral | ts.NullLiteral | ts.NumericLiteral | ts.PrefixUnaryExpression | ts.StringLiteral>, AsMethods>;
-declare class LiteralTsDsl extends Mixed$23 {
+declare const Mixed$24: MixinCtor<abstract new () => TsDsl<ts.BigIntLiteral | ts.BooleanLiteral | ts.NullLiteral | ts.NumericLiteral | ts.PrefixUnaryExpression | ts.StringLiteral, "typescript">, AsMethods>;
+declare class LiteralTsDsl extends Mixed$24 {
   readonly '~dsl' = "LiteralTsDsl";
   protected value: ts$1.LiteralValue;
   constructor(value: ts$1.LiteralValue);
@@ -1668,8 +1669,8 @@ type Meta = {
   kind: 'spread';
   name?: undefined;
 };
-declare const Mixed$22: MixinCtor<abstract new () => TsDsl<ts.ObjectLiteralElementLike>, DocMethods>;
-declare class ObjectPropTsDsl extends Mixed$22 {
+declare const Mixed$23: MixinCtor<abstract new () => TsDsl<ts.ObjectLiteralElementLike, "typescript">, DocMethods>;
+declare class ObjectPropTsDsl extends Mixed$23 {
   readonly '~dsl' = "ObjectPropTsDsl";
   protected _value?: Ref<ObjectPropValue>;
   protected _meta: Meta;
@@ -1690,8 +1691,8 @@ declare class ObjectPropTsDsl extends Mixed$22 {
 //#region src/ts-dsl/expr/object.d.ts
 type Expr = NodeName | MaybeTsDsl<ts.Expression>;
 type Stmt = NodeName | MaybeTsDsl<ts.Statement>;
-declare const Mixed$21: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ObjectLiteralExpression>, LayoutMethods>, HintMethods>, ExprMethods>, AsMethods>;
-declare class ObjectTsDsl extends Mixed$21 {
+declare const Mixed$22: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ObjectLiteralExpression, "typescript">, LayoutMethods>, HintMethods>, ExprMethods>, AsMethods>;
+declare class ObjectTsDsl extends Mixed$22 {
   readonly '~dsl' = "ObjectTsDsl";
   protected _props: Map<string, ObjectPropTsDsl>;
   protected _spreadCounter: number;
@@ -1723,8 +1724,8 @@ declare class ObjectTsDsl extends Mixed$21 {
 //#region src/ts-dsl/expr/regexp.d.ts
 type RegexFlag = 'g' | 'i' | 'm' | 's' | 'u' | 'y';
 type RegexFlags<Avail extends string = RegexFlag> = '' | { [K in Avail]: `${K}${RegexFlags<Exclude<Avail, K>>}` }[Avail];
-declare const Mixed$20: abstract new () => TsDsl<ts.RegularExpressionLiteral>;
-declare class RegExpTsDsl extends Mixed$20 {
+declare const Mixed$21: abstract new () => TsDsl<ts.RegularExpressionLiteral, "typescript">;
+declare class RegExpTsDsl extends Mixed$21 {
   readonly '~dsl' = "RegExpTsDsl";
   protected pattern: string;
   protected flags?: RegexFlags;
@@ -1735,8 +1736,8 @@ declare class RegExpTsDsl extends Mixed$20 {
 //#endregion
 //#region src/ts-dsl/expr/template.d.ts
 type TemplatePart = NodeName | MaybeTsDsl<ts.Expression>;
-declare const Mixed$19: abstract new () => TsDsl<ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral>;
-declare class TemplateTsDsl extends Mixed$19 {
+declare const Mixed$20: abstract new () => TsDsl<ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral, "typescript">;
+declare class TemplateTsDsl extends Mixed$20 {
   readonly '~dsl' = "TemplateTsDsl";
   protected parts: Array<Ref<TemplatePart>>;
   constructor(value?: TemplatePart);
@@ -1746,8 +1747,8 @@ declare class TemplateTsDsl extends Mixed$19 {
 }
 //#endregion
 //#region src/ts-dsl/expr/ternary.d.ts
-declare const Mixed$18: abstract new () => TsDsl<ts.ConditionalExpression>;
-declare class TernaryTsDsl extends Mixed$18 {
+declare const Mixed$19: abstract new () => TsDsl<ts.ConditionalExpression, "typescript">;
+declare class TernaryTsDsl extends Mixed$19 {
   readonly '~dsl' = "TernaryTsDsl";
   protected _condition?: string | MaybeTsDsl<ts.Expression>;
   protected _then?: string | MaybeTsDsl<ts.Expression>;
@@ -1776,8 +1777,8 @@ declare class NewlineTsDsl extends TsDsl<ts.Identifier> {
 }
 //#endregion
 //#region src/ts-dsl/stmt/block.d.ts
-declare const Mixed$17: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.Block>, LayoutMethods>, DoMethods>;
-declare class BlockTsDsl extends Mixed$17 {
+declare const Mixed$18: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.Block, "typescript">, LayoutMethods>, DoMethods>;
+declare class BlockTsDsl extends Mixed$18 {
   readonly '~dsl' = "BlockTsDsl";
   constructor(...items: Array<DoExpr>);
   analyze(ctx: AnalysisContext): void;
@@ -1785,8 +1786,8 @@ declare class BlockTsDsl extends Mixed$17 {
 }
 //#endregion
 //#region src/ts-dsl/stmt/var.d.ts
-declare const Mixed$16: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.VariableStatement>, ValueMethods>, PatternMethods>, HintMethods>, ExportMethods>, DocMethods>, DefaultMethods>;
-declare class VarTsDsl extends Mixed$16 {
+declare const Mixed$17: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.VariableStatement, "typescript">, ValueMethods>, PatternMethods>, HintMethods>, ExportMethods>, DocMethods>, DefaultMethods>;
+declare class VarTsDsl extends Mixed$17 {
   readonly '~dsl' = "VarTsDsl";
   readonly nameSanitizer: (name: string) => string;
   protected kind: ts.NodeFlags;
@@ -1809,8 +1810,8 @@ declare class VarTsDsl extends Mixed$16 {
 type ForMode = 'for' | 'in' | 'of';
 type ForCondition = MaybeTsDsl<ts.Expression>;
 type ForIterable = MaybeTsDsl<ts.Expression>;
-declare const Mixed$15: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ForStatement>, LayoutMethods>, DoMethods>;
-declare class ImplForTsDsl<M extends ForMode = 'for'> extends Mixed$15 {
+declare const Mixed$16: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ForStatement, "typescript">, LayoutMethods>, DoMethods>;
+declare class ImplForTsDsl<M extends ForMode = 'for'> extends Mixed$16 {
   readonly '~dsl' = "ForTsDsl";
   protected _await?: boolean;
   protected _condition?: ForCondition;
@@ -1853,8 +1854,8 @@ type ForTsDsl<M extends ForMode = 'for'> = ImplForTsDsl<M>;
 //#endregion
 //#region src/ts-dsl/stmt/if.d.ts
 type IfCondition = NodeName | MaybeTsDsl<ts.Expression>;
-declare const Mixed$14: MixinCtor<abstract new () => TsDsl<ts.IfStatement>, DoMethods>;
-declare class IfTsDsl extends Mixed$14 {
+declare const Mixed$15: MixinCtor<abstract new () => TsDsl<ts.IfStatement, "typescript">, DoMethods>;
+declare class IfTsDsl extends Mixed$15 {
   readonly '~dsl' = "IfTsDsl";
   protected _condition?: IfCondition;
   protected _else?: Array<DoExpr>;
@@ -1872,8 +1873,8 @@ declare class IfTsDsl extends Mixed$14 {
 }
 //#endregion
 //#region src/ts-dsl/stmt/stmt.d.ts
-declare const Mixed$13: abstract new () => TsDsl<ts.Statement>;
-declare class StmtTsDsl extends Mixed$13 {
+declare const Mixed$14: abstract new () => TsDsl<ts.Statement, "typescript">;
+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>);
@@ -1882,8 +1883,8 @@ declare class StmtTsDsl extends Mixed$13 {
 }
 //#endregion
 //#region src/ts-dsl/stmt/throw.d.ts
-declare const Mixed$12: abstract new () => TsDsl<ts.ThrowStatement>;
-declare class ThrowTsDsl extends Mixed$12 {
+declare const Mixed$13: abstract new () => TsDsl<ts.ThrowStatement, "typescript">;
+declare class ThrowTsDsl extends Mixed$13 {
   readonly '~dsl' = "ThrowTsDsl";
   protected error: string | MaybeTsDsl<ts.Expression>;
   protected msg?: string | MaybeTsDsl<ts.Expression>;
@@ -1895,8 +1896,8 @@ declare class ThrowTsDsl extends Mixed$12 {
 }
 //#endregion
 //#region src/ts-dsl/stmt/try.d.ts
-declare const Mixed$11: abstract new () => TsDsl<ts.TryStatement>;
-declare class TryTsDsl extends Mixed$11 {
+declare const Mixed$12: abstract new () => TsDsl<ts.TryStatement, "typescript">;
+declare class TryTsDsl extends Mixed$12 {
   readonly '~dsl' = "TryTsDsl";
   protected _catch?: Array<DoExpr>;
   protected _catchArg?: NodeName;
@@ -1946,8 +1947,8 @@ declare class TokenTsDsl<K extends ts.SyntaxKind = never> extends TsDsl<ts.Token
 //#endregion
 //#region src/ts-dsl/type/alias.d.ts
 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 {
+declare const Mixed$11: MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.TypeAliasDeclaration, "typescript">, TypeParamsMethods>, ExportMethods>, DocMethods>;
+declare class TypeAliasTsDsl extends Mixed$11 {
   readonly '~dsl' = "TypeAliasTsDsl";
   readonly nameSanitizer: (name: string) => string;
   scope: NodeScope;
@@ -1966,21 +1967,21 @@ declare class TypeAliasTsDsl extends Mixed$10 {
 }
 //#endregion
 //#region src/ts-dsl/type/and.d.ts
-type Type$2 = NodeName | ts.TypeNode | TypeTsDsl;
-declare const Mixed$9: abstract new () => TsDsl<ts.IntersectionTypeNode>;
-declare class TypeAndTsDsl extends Mixed$9 {
+type Type$3 = NodeName | ts.TypeNode | TypeTsDsl;
+declare const Mixed$10: abstract new () => TsDsl<ts.IntersectionTypeNode, "typescript">;
+declare class TypeAndTsDsl extends Mixed$10 {
   readonly '~dsl' = "TypeAndTsDsl";
   scope: NodeScope;
-  protected _types: Array<Ref<Type$2>>;
-  constructor(...nodes: Array<Type$2>);
+  protected _types: Array<Ref<Type$3>>;
+  constructor(...nodes: Array<Type$3>);
   analyze(ctx: AnalysisContext): void;
-  types(...nodes: Array<Type$2>): this;
+  types(...nodes: Array<Type$3>): this;
   toAst(): ts.IntersectionTypeNode;
 }
 //#endregion
 //#region src/ts-dsl/type/func.d.ts
-declare const Mixed$8: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.FunctionTypeNode>, TypeReturnsMethods>, TypeParamsMethods>, ParamMethods>, DocMethods>;
-declare class TypeFuncTsDsl extends Mixed$8 {
+declare const Mixed$9: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.FunctionTypeNode, "typescript">, TypeReturnsMethods>, TypeParamsMethods>, ParamMethods>, DocMethods>;
+declare class TypeFuncTsDsl extends Mixed$9 {
   readonly '~dsl' = "TypeFuncTsDsl";
   scope: NodeScope;
   analyze(ctx: AnalysisContext): void;
@@ -1992,8 +1993,8 @@ declare class TypeFuncTsDsl extends Mixed$8 {
 }
 //#endregion
 //#region src/ts-dsl/type/literal.d.ts
-declare const Mixed$7: abstract new () => TsDsl<ts.LiteralTypeNode>;
-declare class TypeLiteralTsDsl extends Mixed$7 {
+declare const Mixed$8: abstract new () => TsDsl<ts.LiteralTypeNode, "typescript">;
+declare class TypeLiteralTsDsl extends Mixed$8 {
   readonly '~dsl' = "TypeLiteralTsDsl";
   scope: NodeScope;
   protected value: ts$1.LiteralValue;
@@ -2003,8 +2004,8 @@ declare class TypeLiteralTsDsl extends Mixed$7 {
 }
 //#endregion
 //#region src/ts-dsl/type/mapped.d.ts
-declare const Mixed$6: abstract new () => TsDsl<ts.MappedTypeNode>;
-declare class TypeMappedTsDsl extends Mixed$6 {
+declare const Mixed$7: abstract new () => TsDsl<ts.MappedTypeNode, "typescript">;
+declare class TypeMappedTsDsl extends Mixed$7 {
   readonly '~dsl' = "TypeMappedTsDsl";
   scope: NodeScope;
   protected questionToken?: TokenTsDsl<ts.SyntaxKind.QuestionToken | ts.SyntaxKind.PlusToken | ts.SyntaxKind.MinusToken>;
@@ -2038,8 +2039,8 @@ declare class TypeMappedTsDsl extends Mixed$6 {
 //#region src/ts-dsl/type/idx-sig.d.ts
 type TypeIdxSigType = string | MaybeTsDsl<ts.TypeNode>;
 type TypeIdxSigKind = 'idxSig';
-declare const Mixed$5: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.IndexSignatureDeclaration>, ReadonlyMethods>, DocMethods>;
-declare class TypeIdxSigTsDsl extends Mixed$5 {
+declare const Mixed$6: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.IndexSignatureDeclaration, "typescript">, ReadonlyMethods>, DocMethods>;
+declare class TypeIdxSigTsDsl extends Mixed$6 {
   readonly '~dsl' = "TypeIdxSigTsDsl";
   scope: NodeScope;
   protected _key?: TypeIdxSigType;
@@ -2067,8 +2068,8 @@ declare class TypeIdxSigTsDsl extends Mixed$5 {
 //#region src/ts-dsl/type/prop.d.ts
 type TypePropType = NodeName | MaybeTsDsl<ts.TypeNode>;
 type TypePropKind = 'prop';
-declare const Mixed$4: MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.TypeElement>, ReadonlyMethods>, OptionalMethods>, DocMethods>;
-declare class TypePropTsDsl extends Mixed$4 {
+declare const Mixed$5: MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.TypeElement, "typescript">, ReadonlyMethods>, OptionalMethods>, DocMethods>;
+declare class TypePropTsDsl extends Mixed$5 {
   readonly '~dsl' = "TypePropTsDsl";
   scope: NodeScope;
   protected _type?: Ref<TypePropType>;
@@ -2090,8 +2091,8 @@ declare class TypePropTsDsl extends Mixed$4 {
 }
 //#endregion
 //#region src/ts-dsl/type/object.d.ts
-declare const Mixed$3: abstract new () => TsDsl<ts.TypeNode>;
-declare class TypeObjectTsDsl extends Mixed$3 {
+declare const Mixed$4: abstract new () => TsDsl<ts.TypeNode, "typescript">;
+declare class TypeObjectTsDsl extends Mixed$4 {
   readonly '~dsl' = "TypeObjectTsDsl";
   scope: NodeScope;
   protected _props: Map<string, TypePropTsDsl | TypeIdxSigTsDsl>;
@@ -2110,21 +2111,21 @@ declare class TypeObjectTsDsl extends Mixed$3 {
 }
 //#endregion
 //#region src/ts-dsl/type/or.d.ts
-type Type$1 = NodeName | ts.TypeNode | TypeTsDsl;
-declare const Mixed$2: abstract new () => TsDsl<ts.UnionTypeNode>;
-declare class TypeOrTsDsl extends Mixed$2 {
+type Type$2 = NodeName | ts.TypeNode | TypeTsDsl;
+declare const Mixed$3: abstract new () => TsDsl<ts.UnionTypeNode, "typescript">;
+declare class TypeOrTsDsl extends Mixed$3 {
   readonly '~dsl' = "TypeOrTsDsl";
   scope: NodeScope;
-  protected _types: Array<Ref<Type$1>>;
-  constructor(...nodes: Array<Type$1>);
+  protected _types: Array<Ref<Type$2>>;
+  constructor(...nodes: Array<Type$2>);
   analyze(ctx: AnalysisContext): void;
-  types(...nodes: Array<Type$1>): this;
+  types(...nodes: Array<Type$2>): this;
   toAst(): ts.UnionTypeNode;
 }
 //#endregion
 //#region src/ts-dsl/type/template.d.ts
-declare const Mixed$1: abstract new () => TsDsl<ts.TemplateLiteralTypeNode>;
-declare class TypeTemplateTsDsl extends Mixed$1 {
+declare const Mixed$2: abstract new () => TsDsl<ts.TemplateLiteralTypeNode, "typescript">;
+declare class TypeTemplateTsDsl extends Mixed$2 {
   readonly '~dsl' = "TypeTemplateTsDsl";
   scope: NodeScope;
   protected parts: Array<string | MaybeTsDsl<ts.TypeNode>>;
@@ -2135,9 +2136,42 @@ declare class TypeTemplateTsDsl extends Mixed$1 {
   toAst(): ts.TemplateLiteralTypeNode;
 }
 //#endregion
+//#region src/ts-dsl/type/ternary.d.ts
+type Type$1 = NodeName | ts.TypeNode | TypeTsDsl;
+declare const Mixed$1: abstract new () => TsDsl<ts.ConditionalTypeNode, "typescript">;
+declare class TypeTernaryTsDsl extends Mixed$1 {
+  readonly '~dsl' = "TypeTernaryTsDsl";
+  scope: NodeScope;
+  protected _check?: Type$1;
+  protected _extends?: Type$1;
+  protected _true?: Type$1;
+  protected _false?: Type$1;
+  constructor(check?: Type$1);
+  analyze(ctx: AnalysisContext): void;
+  /** Returns true when all required builder calls are present. */
+  get isValid(): boolean;
+  /** Sets the checked type: `Check extends ...` */
+  check(type: Type$1): this;
+  /** Sets the constraint: `Check extends Extends ? ...` */
+  extends(type: Type$1): this;
+  /** Sets the true branch: `... ? Do : ...` */
+  do(type: Type$1): this;
+  /** Sets the false branch: `... : Otherwise` */
+  otherwise(type: Type$1): this;
+  toAst(): ts.ConditionalTypeNode;
+  $validate(): asserts this is this & {
+    _check: Type$1;
+    _extends: Type$1;
+    _false: Type$1;
+    _true: Type$1;
+  };
+  private missingRequiredCalls;
+  private resolveType;
+}
+//#endregion
 //#region src/ts-dsl/type/tuple.d.ts
 type TupleElement = string | ts.TypeNode | TypeTsDsl;
-declare const Mixed: abstract new () => TsDsl<ts.TupleTypeNode>;
+declare const Mixed: abstract new () => TsDsl<ts.TupleTypeNode, "typescript">;
 declare class TypeTupleTsDsl extends Mixed {
   readonly '~dsl' = "TypeTupleTsDsl";
   scope: NodeScope;
@@ -2280,7 +2314,7 @@ declare const $: ((id: any) => ExprTsDsl) & {
   class: (name: NodeName) => ClassTsDsl; /** Creates a constant variable declaration (`const`). */
   const: (name?: any) => VarTsDsl; /** Creates a postfix decrement expression (`i--`). */
   dec: (expr?: PostfixExpr | undefined, op?: ts.PostfixUnaryOperator | undefined) => PostfixTsDsl; /** Creates a decorator expression (e.g., `@decorator`). */
-  decorator: (name: NodeName, ...args: (string | ts.Expression | TsDsl<ts.Expression>)[]) => DecoratorTsDsl; /** Creates a JSDoc documentation block. */
+  decorator: (name: NodeName, ...args: (string | ts.Expression | TsDsl<ts.Expression, "typescript">)[]) => DecoratorTsDsl; /** Creates a JSDoc documentation block. */
   doc: (lines?: DocLines | undefined, fn?: DocFn | undefined) => DocTsDsl; /** Creates an enum declaration. */
   enum: (name: NodeName, fn?: ((e: EnumTsDsl) => void) | undefined) => EnumTsDsl; /** Creates a general expression node. */
   expr: (id: any) => ExprTsDsl; /** Creates a field declaration in a class or object. */
@@ -2292,7 +2326,7 @@ declare const $: ((id: any) => ExprTsDsl) & {
   }; /** Converts a runtime value into a corresponding expression node. */
   fromValue: (input: unknown, options?: {
     layout?: "pretty";
-  } | undefined) => TsDsl<ts.Expression>; /** Creates a function expression or declaration. */
+  } | undefined) => TsDsl<ts.Expression, "typescript">; /** Creates a function expression or declaration. */
   func: {
     (): FuncTsDsl<"arrow">;
     (fn: (f: FuncTsDsl<"arrow">) => void): FuncTsDsl<"arrow">;
@@ -2309,7 +2343,7 @@ declare const $: ((id: any) => ExprTsDsl) & {
   lazy: <T extends ts.Node>(thunk: LazyThunk<T>) => LazyTsDsl<T>; /** Creates a let variable declaration (`let`). */
   let: (name?: any) => VarTsDsl; /** Creates a literal value (e.g., string, number, boolean). */
   literal: (value: TsLiteralValue) => LiteralTsDsl; /** Creates an enum member declaration. */
-  member: (name: NodeName, value?: ((string | number | ts.Expression | TsDsl<ts.Expression>) | ((m: EnumMemberTsDsl) => void)) | undefined) => EnumMemberTsDsl; /** Creates a method declaration inside a class or object. */
+  member: (name: NodeName, value?: ((string | number | ts.Expression | TsDsl<ts.Expression, "typescript">) | ((m: EnumMemberTsDsl) => void)) | undefined) => EnumMemberTsDsl; /** Creates a method declaration inside a class or object. */
   method: (name: NodeName, fn?: ((m: MethodTsDsl) => void) | undefined) => MethodTsDsl; /** Creates a negation expression (`-x`). */
   neg: (expr?: PrefixExpr | undefined, op?: ts.PrefixUnaryOperator | undefined) => PrefixTsDsl; /** Creates a new expression (e.g., `new ClassName()`). */
   new: (expr: any, ...args: any[]) => NewTsDsl; /** Creates a newline (for formatting purposes). */
@@ -2343,10 +2377,10 @@ declare const $: ((id: any) => ExprTsDsl) & {
   return: (expr?: any) => ReturnTsDsl; /** Creates a setter method declaration. */
   setter: (name: NodeName, fn?: ((s: SetterTsDsl) => void) | undefined) => SetterTsDsl; /** Creates a spread element from an expression (e.g., `...expr`). */
   spread: (expr: any) => SpreadTsDsl; /** Wraps an expression or statement-like value into a `StmtTsDsl`. */
-  stmt: (inner: ts.Expression | ts.Statement | TsDsl<any>) => StmtTsDsl; /** Creates a template literal expression. */
+  stmt: (inner: ts.Expression | ts.Statement | TsDsl<any, "typescript">) => StmtTsDsl; /** Creates a template literal expression. */
   template: (value?: any) => TemplateTsDsl; /** Creates a ternary conditional expression (if ? then : else). */
-  ternary: (condition?: string | ts.Expression | TsDsl<ts.Expression> | undefined) => TernaryTsDsl; /** Creates a throw statement. */
-  throw: (error: string | ts.Expression | TsDsl<ts.Expression>, useNew?: boolean | undefined) => ThrowTsDsl; /** Creates a syntax token (e.g., `?`, `readonly`, `+`, `-`). */
+  ternary: (condition?: string | ts.Expression | TsDsl<ts.Expression, "typescript"> | undefined) => TernaryTsDsl; /** Creates a throw statement. */
+  throw: (error: string | ts.Expression | TsDsl<ts.Expression, "typescript">, 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: NodeName, fn?: TypeExprFn | undefined) => TypeExprTsDsl) & {
@@ -2354,9 +2388,9 @@ declare const $: ((id: any) => ExprTsDsl) & {
     and: (...args: ConstructorParameters<typeof TypeAndTsDsl>) => TypeAndTsDsl; /** Creates a qualified type reference (e.g., Foo.Bar). */
     attr: (right: any) => TypeAttrTsDsl; /** Creates a basic type reference or type expression (e.g., Foo or Foo<T>). */
     expr: (name: NodeName, fn?: TypeExprFn | undefined) => TypeExprTsDsl; /** Converts a runtime value into a corresponding type expression node. */
-    fromValue: (input: unknown) => TsDsl<ts.TypeNode>; /** Creates a function type node (e.g., `(a: string) => number`). */
+    fromValue: (input: unknown) => TsDsl<ts.TypeNode, "typescript">; /** Creates a function type node (e.g., `(a: string) => number`). */
     func: (...args: ConstructorParameters<typeof TypeFuncTsDsl>) => TypeFuncTsDsl; /** Creates an indexed-access type (e.g., `Foo<T>[K]`). */
-    idx: (base: string | ts.TypeNode | TsDsl<ts.TypeNode>, index: string | number | ts.TypeNode | TsDsl<ts.TypeNode>) => TypeIdxTsDsl; /** Creates a literal type node (e.g., 'foo', 42, or true). */
+    idx: (base: string | ts.TypeNode | TsDsl<ts.TypeNode, "typescript">, index: string | number | ts.TypeNode | TsDsl<ts.TypeNode, "typescript">) => TypeIdxTsDsl; /** Creates a literal type node (e.g., 'foo', 42, or true). */
     literal: (value: TsLiteralValue) => TypeLiteralTsDsl; /** Creates a mapped type (e.g., `{ [K in keyof T]: U }`). */
     mapped: (name?: any) => TypeMappedTsDsl; /** Creates a type literal node (e.g., { foo: string }). */
     object: () => TypeObjectTsDsl; /** Creates a type operator node (e.g., `readonly T`, `keyof T`, `unique T`). */
@@ -2364,7 +2398,8 @@ declare const $: ((id: any) => ExprTsDsl) & {
     or: (...args: ConstructorParameters<typeof TypeOrTsDsl>) => TypeOrTsDsl; /** Creates a type parameter (e.g., `<T>`). */
     param: (name?: any, fn?: ((name: TypeParamTsDsl) => void) | undefined) => TypeParamTsDsl; /** Creates a type query node (e.g., `typeof Foo`). */
     query: (expr: any) => TypeQueryTsDsl; /** Builds a TypeScript template literal *type* (e.g., `${Foo}-${Bar}` as a type). */
-    template: (value?: string | ts.TypeNode | TsDsl<ts.TypeNode> | undefined) => TypeTemplateTsDsl; /** Creates a tuple type (e.g., [A, B, C]). */
+    template: (value?: string | ts.TypeNode | TsDsl<ts.TypeNode, "typescript"> | undefined) => TypeTemplateTsDsl; /** Creates a ternary conditional type (e.g., `T extends U ? X : Y`). */
+    ternary: (check?: any) => TypeTernaryTsDsl; /** Creates a tuple type (e.g., [A, B, C]). */
     tuple: (...args: ConstructorParameters<typeof TypeTupleTsDsl>) => TypeTupleTsDsl; /** Creates a named tuple element (e.g., `[resolver?: R]`). */
     tupleMember: (name: NodeName) => TypeTupleMemberTsDsl;
   }; /** Creates a `typeof` expression (e.g., `typeof value`). */
@@ -3852,6 +3887,7 @@ interface OperationsConfig {
 //#region src/plugins/@hey-api/sdk/symbols.d.ts
 declare function sdkSymbols(plugin: PluginInstance$1): {
   Client: any;
+  ClientMeta: any;
   Composable: any;
   Options: any;
   RequestResult: any;
@@ -11324,7 +11360,7 @@ declare function clientPluginHandler({
 //#endregion
 //#region src/index.d.ts
 declare module '@hey-api/codegen-core' {
-  interface ProjectRenderMeta {
+  interface ProjectMeta {
     /**
      * If specified, this will be the file extension used when importing
      * other modules. By default, we don't add a file extension and let the