@hey-api/openapi-ts 0.90.9 → 0.90.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,5 +1,6 @@
1
1
 
2
- import { AnalysisContext, BindingKind, ExportModule, File, FromRef, IProject, ImportModule, Language, Logger, NameConflictResolver, Node, NodeName as NodeName$1, NodeNameSanitizer, NodeRelationship, NodeScope, Project, Ref, Refs, RenderContext, Renderer, StructureLocation, Symbol, SymbolIdentifier, SymbolIn, SymbolMeta } from "@hey-api/codegen-core";
2
+ import * as _hey_api_codegen_core0 from "@hey-api/codegen-core";
3
+ import { AnalysisContext, BindingKind, ExportModule, File, FromRef, IProject, ImportModule, Language, Logger, NameConflictResolver, Node, NodeName, NodeNameSanitizer, NodeRelationship, NodeScope, Project, Ref, Refs, RenderContext, Renderer, StructureLocation, Symbol, SymbolIdentifier, SymbolIn, SymbolMeta } from "@hey-api/codegen-core";
3
4
  import ts from "typescript";
4
5
  import { RangeOptions, SemVer } from "semver";
5
6
  import { MaybeArray, MaybeFunc, MaybePromise } from "@hey-api/types";
@@ -3412,7 +3413,7 @@ type DropFirst<T extends Array<any>> = T extends [any, ...infer Rest] ? Rest : n
3412
3413
  type MixinCtor<T extends BaseCtor<any>, K$1> = abstract new (...args: Array<any>) => InstanceType<T> & K$1;
3413
3414
  //#endregion
3414
3415
  //#region src/ts-dsl/mixins/type-args.d.ts
3415
- type Arg$1 = NodeName$1 | MaybeTsDsl<TypeTsDsl>;
3416
+ type Arg$1 = NodeName | MaybeTsDsl<TypeTsDsl>;
3416
3417
  interface TypeArgsMethods extends Node {
3417
3418
  /** Returns the type arguments as an array of ts.TypeNode nodes. */
3418
3419
  $generics(): ReadonlyArray<ts.TypeNode> | undefined;
@@ -3429,8 +3430,8 @@ interface AsMethods extends Node {
3429
3430
  }
3430
3431
  //#endregion
3431
3432
  //#region src/ts-dsl/expr/as.d.ts
3432
- type AsExpr = NodeName$1 | MaybeTsDsl<ts.Expression>;
3433
- type AsType = NodeName$1 | TypeTsDsl;
3433
+ type AsExpr = NodeName | MaybeTsDsl<ts.Expression>;
3434
+ type AsType = NodeName | TypeTsDsl;
3434
3435
  type AsCtor = (expr: AsExpr, type: AsType) => AsTsDsl;
3435
3436
  declare const Mixed$52: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.AsExpression>, ExprMethods>, AsMethods>;
3436
3437
  declare class AsTsDsl extends Mixed$52 {
@@ -3452,7 +3453,7 @@ interface OptionalMethods extends Node {
3452
3453
  }
3453
3454
  //#endregion
3454
3455
  //#region src/ts-dsl/expr/binary.d.ts
3455
- type Expr$3 = NodeName$1 | MaybeTsDsl<ts.Expression>;
3456
+ type Expr$3 = NodeName | MaybeTsDsl<ts.Expression>;
3456
3457
  type Op$1 = Operator | ts.BinaryOperator;
3457
3458
  type Operator = '!=' | '!==' | '&&' | '*' | '+' | '-' | '/' | '<' | '<=' | '=' | '==' | '===' | '>' | '>=' | '??' | '??=' | '||';
3458
3459
  declare const Mixed$51: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.BinaryExpression>, ExprMethods>, AsMethods>;
@@ -3504,7 +3505,7 @@ declare class BinaryTsDsl extends Mixed$51 {
3504
3505
  }
3505
3506
  //#endregion
3506
3507
  //#region src/ts-dsl/mixins/operator.d.ts
3507
- type Expr$2 = NodeName$1 | MaybeTsDsl<ts.Expression>;
3508
+ type Expr$2 = NodeName | MaybeTsDsl<ts.Expression>;
3508
3509
  interface OperatorMethods extends Node {
3509
3510
  /** Logical AND — `this && expr` */
3510
3511
  and(expr: Expr$2): BinaryTsDsl;
@@ -3543,19 +3544,19 @@ interface OperatorMethods extends Node {
3543
3544
  }
3544
3545
  //#endregion
3545
3546
  //#region src/ts-dsl/expr/attr.d.ts
3546
- type AttrLeft = NodeName$1 | MaybeTsDsl<ts.Expression>;
3547
- type AttrCtor = (left: AttrLeft, right: NodeName$1) => AttrTsDsl;
3547
+ type AttrLeft = NodeName | MaybeTsDsl<ts.Expression>;
3548
+ type AttrCtor = (left: AttrLeft, right: NodeName) => AttrTsDsl;
3548
3549
  declare const Mixed$50: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.PropertyAccessExpression | ts.ElementAccessExpression>, OptionalMethods>, OperatorMethods>, ExprMethods>, AsMethods>;
3549
3550
  declare class AttrTsDsl extends Mixed$50 {
3550
3551
  readonly '~dsl' = "AttrTsDsl";
3551
3552
  protected left: Ref<AttrLeft>;
3552
- constructor(left: AttrLeft, right: NodeName$1);
3553
+ constructor(left: AttrLeft, right: NodeName);
3553
3554
  analyze(ctx: AnalysisContext): void;
3554
3555
  toAst(): ts.PropertyAccessExpression | ts.ElementAccessExpression;
3555
3556
  }
3556
3557
  //#endregion
3557
3558
  //#region src/ts-dsl/expr/await.d.ts
3558
- type AwaitExpr = NodeName$1 | MaybeTsDsl<ts.Expression>;
3559
+ type AwaitExpr = NodeName | MaybeTsDsl<ts.Expression>;
3559
3560
  type AwaitCtor = (expr: AwaitExpr) => AwaitTsDsl;
3560
3561
  declare const Mixed$49: MixinCtor<abstract new () => TsDsl<ts.AwaitExpression>, ExprMethods>;
3561
3562
  declare class AwaitTsDsl extends Mixed$49 {
@@ -3567,7 +3568,7 @@ declare class AwaitTsDsl extends Mixed$49 {
3567
3568
  }
3568
3569
  //#endregion
3569
3570
  //#region src/ts-dsl/mixins/args.d.ts
3570
- type Arg = NodeName$1 | MaybeTsDsl<ts.Expression>;
3571
+ type Arg = NodeName | MaybeTsDsl<ts.Expression>;
3571
3572
  interface ArgsMethods extends Node {
3572
3573
  /** Renders the arguments into an array of `Expression`s. */
3573
3574
  $args(): ReadonlyArray<ts.Expression>;
@@ -3579,7 +3580,7 @@ interface ArgsMethods extends Node {
3579
3580
  //#endregion
3580
3581
  //#region src/ts-dsl/expr/new.d.ts
3581
3582
  type NewArgs = ReadonlyArray<NewExpr | undefined>;
3582
- type NewExpr = NodeName$1 | MaybeTsDsl<ts.Expression>;
3583
+ type NewExpr = NodeName | MaybeTsDsl<ts.Expression>;
3583
3584
  type NewCtor = (expr: NewExpr, ...args: NewArgs) => NewTsDsl;
3584
3585
  declare const Mixed$48: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.NewExpression>, TypeArgsMethods>, ExprMethods>, AsMethods>, ArgsMethods>;
3585
3586
  declare class NewTsDsl extends Mixed$48 {
@@ -3603,7 +3604,7 @@ declare class TypeOfExprTsDsl extends Mixed$47 {
3603
3604
  }
3604
3605
  //#endregion
3605
3606
  //#region src/ts-dsl/stmt/return.d.ts
3606
- type ReturnExpr = NodeName$1 | MaybeTsDsl<ts.Expression>;
3607
+ type ReturnExpr = NodeName | MaybeTsDsl<ts.Expression>;
3607
3608
  type ReturnCtor = (expr?: ReturnExpr) => ReturnTsDsl;
3608
3609
  declare const Mixed$46: abstract new () => TsDsl<ts.ReturnStatement>;
3609
3610
  declare class ReturnTsDsl extends Mixed$46 {
@@ -3633,8 +3634,8 @@ interface TypeExprMethods extends Node {
3633
3634
  }
3634
3635
  //#endregion
3635
3636
  //#region src/ts-dsl/type/attr.d.ts
3636
- type Base$1 = NodeName$1 | MaybeTsDsl<ts.EntityName>;
3637
- type Right = NodeName$1 | ts.Identifier;
3637
+ type Base$1 = NodeName | MaybeTsDsl<ts.EntityName>;
3638
+ type Right = NodeName | ts.Identifier;
3638
3639
  declare const Mixed$45: MixinCtor<abstract new () => TsDsl<ts.QualifiedName>, TypeExprMethods>;
3639
3640
  declare class TypeAttrTsDsl extends Mixed$45 {
3640
3641
  readonly '~dsl' = "TypeAttrTsDsl";
@@ -3650,9 +3651,9 @@ declare class TypeAttrTsDsl extends Mixed$45 {
3650
3651
  }
3651
3652
  //#endregion
3652
3653
  //#region src/ts-dsl/type/expr.d.ts
3653
- type TypeExprExpr = NodeName$1 | TypeAttrTsDsl;
3654
+ type TypeExprExpr = NodeName | TypeAttrTsDsl;
3654
3655
  type TypeExprFn = (t: TypeExprTsDsl) => void;
3655
- type TypeExprCtor = (nameOrFn?: NodeName$1 | TypeExprFn, fn?: TypeExprFn) => TypeExprTsDsl;
3656
+ type TypeExprCtor = (nameOrFn?: NodeName | TypeExprFn, fn?: TypeExprFn) => TypeExprTsDsl;
3656
3657
  declare const Mixed$44: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.TypeReferenceNode>, TypeExprMethods>, TypeArgsMethods>;
3657
3658
  declare class TypeExprTsDsl extends Mixed$44 {
3658
3659
  readonly '~dsl' = "TypeExprTsDsl";
@@ -3660,8 +3661,8 @@ declare class TypeExprTsDsl extends Mixed$44 {
3660
3661
  protected _exprInput?: Ref<TypeExprExpr>;
3661
3662
  constructor();
3662
3663
  constructor(fn: TypeExprFn);
3663
- constructor(name: NodeName$1);
3664
- constructor(name: NodeName$1, fn?: TypeExprFn);
3664
+ constructor(name: NodeName);
3665
+ constructor(name: NodeName, fn?: TypeExprFn);
3665
3666
  analyze(ctx: AnalysisContext): void;
3666
3667
  /** Accesses a nested type (e.g. `Foo.Bar`). */
3667
3668
  attr(right: string | ts.Identifier | TypeAttrTsDsl): this;
@@ -3789,7 +3790,7 @@ interface ExprMethods extends Node {
3789
3790
  //#endregion
3790
3791
  //#region src/ts-dsl/expr/call.d.ts
3791
3792
  type CallArgs = ReadonlyArray<CallExpr | undefined>;
3792
- type CallExpr = NodeName$1 | MaybeTsDsl<ts.Expression>;
3793
+ type CallExpr = NodeName | MaybeTsDsl<ts.Expression>;
3793
3794
  type CallCtor = (expr: CallExpr, ...args: CallArgs) => CallTsDsl;
3794
3795
  declare const Mixed$40: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.CallExpression>, TypeArgsMethods>, ExprMethods>, AsMethods>, ArgsMethods>;
3795
3796
  declare class CallTsDsl extends Mixed$40 {
@@ -3874,7 +3875,7 @@ declare abstract class TsDsl<T extends ts.Node = ts.Node> implements Node<T> {
3874
3875
  structuralParents?: Map<TsDsl, NodeRelationship>;
3875
3876
  symbol?: Symbol;
3876
3877
  toAst(): T;
3877
- readonly '~brand': any;
3878
+ readonly '~brand' = "heyapi.node";
3878
3879
  /** Branding property to identify the DSL class at runtime. */
3879
3880
  abstract readonly '~dsl': string & {};
3880
3881
  /** Conditionally applies a callback to this builder. */
@@ -3895,7 +3896,7 @@ declare abstract class TsDsl<T extends ts.Node = ts.Node> implements Node<T> {
3895
3896
  length: number;
3896
3897
  }): TsDsl | undefined;
3897
3898
  protected $maybeId<T extends string | ts.Expression>(expr: T): T extends string ? ts.Identifier : T;
3898
- protected $name(name: Ref<NodeName$1>): string;
3899
+ protected $name(name: Ref<NodeName>): string;
3899
3900
  protected $node<I>(value: I): NodeOfMaybe<I>;
3900
3901
  protected $type<I>(value: I, args?: ReadonlyArray<ts.TypeNode>): TypeOfMaybe<I>;
3901
3902
  private _name?;
@@ -3980,7 +3981,7 @@ declare class LiteralTsDsl extends Mixed$38 {
3980
3981
  protected value: LiteralValue;
3981
3982
  constructor(value: LiteralValue);
3982
3983
  analyze(ctx: AnalysisContext): void;
3983
- toAst(): any;
3984
+ toAst(): ts.BigIntLiteral | ts.TrueLiteral | ts.FalseLiteral | ts.NullLiteral | ts.NumericLiteral | ts.PrefixUnaryExpression | ts.StringLiteral;
3984
3985
  }
3985
3986
  //#endregion
3986
3987
  //#region src/ts-dsl/layout/note.d.ts
@@ -3997,15 +3998,27 @@ declare class NoteTsDsl extends TsDsl<ts.Node> {
3997
3998
  toAst(): ts.Node;
3998
3999
  }
3999
4000
  //#endregion
4001
+ //#region src/ts-dsl/expr/template.d.ts
4002
+ type TemplatePart = NodeName | MaybeTsDsl<ts.Expression>;
4003
+ declare const Mixed$37: abstract new () => TsDsl<ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral>;
4004
+ declare class TemplateTsDsl extends Mixed$37 {
4005
+ readonly '~dsl' = "TemplateTsDsl";
4006
+ protected parts: Array<Ref<TemplatePart>>;
4007
+ constructor(value?: TemplatePart);
4008
+ analyze(ctx: AnalysisContext): void;
4009
+ add(value: TemplatePart): this;
4010
+ toAst(): ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral;
4011
+ }
4012
+ //#endregion
4000
4013
  //#region src/ts-dsl/type/param.d.ts
4001
- type TypeParamExpr = NodeName$1 | boolean | MaybeTsDsl<TypeTsDsl>;
4002
- declare const Mixed$37: abstract new () => TsDsl<ts.TypeParameterDeclaration>;
4003
- declare class TypeParamTsDsl extends Mixed$37 {
4014
+ type TypeParamExpr = NodeName | boolean | MaybeTsDsl<TypeTsDsl>;
4015
+ declare const Mixed$36: abstract new () => TsDsl<ts.TypeParameterDeclaration>;
4016
+ declare class TypeParamTsDsl extends Mixed$36 {
4004
4017
  readonly '~dsl' = "TypeParamTsDsl";
4005
4018
  scope: NodeScope;
4006
4019
  protected constraint?: Ref<TypeParamExpr>;
4007
4020
  protected defaultValue?: Ref<TypeParamExpr>;
4008
- constructor(name?: NodeName$1, fn?: (name: TypeParamTsDsl) => void);
4021
+ constructor(name?: NodeName, fn?: (name: TypeParamTsDsl) => void);
4009
4022
  analyze(ctx: AnalysisContext): void;
4010
4023
  default(value: TypeParamExpr): this;
4011
4024
  extends(constraint: TypeParamExpr): this;
@@ -4019,7 +4032,7 @@ interface TypeParamsMethods extends Node {
4019
4032
  /** Adds a single type parameter (e.g. `T` in `Array<T>`). */
4020
4033
  generic(...args: ConstructorParameters<typeof TypeParamTsDsl>): this;
4021
4034
  /** Adds type parameters (e.g. `Map<string, T>`). */
4022
- generics(...args: ReadonlyArray<NodeName$1 | MaybeTsDsl<TypeParamTsDsl>>): this;
4035
+ generics(...args: ReadonlyArray<NodeName | MaybeTsDsl<TypeParamTsDsl>>): this;
4023
4036
  }
4024
4037
  //#endregion
4025
4038
  //#region src/ts-dsl/mixins/modifiers.d.ts
@@ -4136,7 +4149,7 @@ interface DecoratorMethods extends Node {
4136
4149
  /** Renders the decorators into an array of `ts.Decorator`s. */
4137
4150
  $decorators(): ReadonlyArray<ts.Decorator>;
4138
4151
  /** Adds a decorator (e.g. `@sealed({ in: 'root' })`). */
4139
- decorator(name: NodeName$1 | MaybeTsDsl<ts.Expression>, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>): this;
4152
+ decorator(name: NodeName | MaybeTsDsl<ts.Expression>, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>): this;
4140
4153
  }
4141
4154
  //#endregion
4142
4155
  //#region src/ts-dsl/mixins/value.d.ts
@@ -4148,13 +4161,13 @@ interface ValueMethods extends Node {
4148
4161
  }
4149
4162
  //#endregion
4150
4163
  //#region src/ts-dsl/decl/field.d.ts
4151
- type FieldType = NodeName$1 | TypeTsDsl;
4152
- 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>;
4153
- declare class FieldTsDsl extends Mixed$36 {
4164
+ type FieldType = NodeName | TypeTsDsl;
4165
+ declare const Mixed$35: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.PropertyDeclaration>, ValueMethods>, StaticMethods>, ReadonlyMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, OptionalMethods>, DocMethods>, DecoratorMethods>;
4166
+ declare class FieldTsDsl extends Mixed$35 {
4154
4167
  readonly '~dsl' = "FieldTsDsl";
4155
4168
  readonly nameSanitizer: (name: string) => string;
4156
4169
  protected _type?: TypeTsDsl;
4157
- constructor(name: NodeName$1, fn?: (f: FieldTsDsl) => void);
4170
+ constructor(name: NodeName, fn?: (f: FieldTsDsl) => void);
4158
4171
  analyze(ctx: AnalysisContext): void;
4159
4172
  /** Sets the field type. */
4160
4173
  type(type: FieldType): this;
@@ -4174,12 +4187,12 @@ interface PatternMethods extends Node {
4174
4187
  }
4175
4188
  //#endregion
4176
4189
  //#region src/ts-dsl/decl/param.d.ts
4177
- type ParamCtor = (name: NodeName$1 | ((p: ParamTsDsl) => void), fn?: (p: ParamTsDsl) => void) => ParamTsDsl;
4178
- declare const Mixed$35: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ParameterDeclaration>, ValueMethods>, PatternMethods>, OptionalMethods>, DecoratorMethods>;
4179
- declare class ParamTsDsl extends Mixed$35 {
4190
+ type ParamCtor = (name: NodeName | ((p: ParamTsDsl) => void), fn?: (p: ParamTsDsl) => void) => ParamTsDsl;
4191
+ declare const Mixed$34: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ParameterDeclaration>, ValueMethods>, PatternMethods>, OptionalMethods>, DecoratorMethods>;
4192
+ declare class ParamTsDsl extends Mixed$34 {
4180
4193
  readonly '~dsl' = "ParamTsDsl";
4181
4194
  protected _type?: TypeTsDsl;
4182
- constructor(name: NodeName$1 | ((p: ParamTsDsl) => void), fn?: (p: ParamTsDsl) => void);
4195
+ constructor(name: NodeName | ((p: ParamTsDsl) => void), fn?: (p: ParamTsDsl) => void);
4183
4196
  analyze(ctx: AnalysisContext): void;
4184
4197
  /** Sets the parameter type. */
4185
4198
  type(type: string | TypeTsDsl): this;
@@ -4197,8 +4210,8 @@ interface ParamMethods extends Node {
4197
4210
  }
4198
4211
  //#endregion
4199
4212
  //#region src/ts-dsl/decl/init.d.ts
4200
- declare const Mixed$34: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ConstructorDeclaration>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>;
4201
- declare class InitTsDsl extends Mixed$34 {
4213
+ declare const Mixed$33: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ConstructorDeclaration>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>;
4214
+ declare class InitTsDsl extends Mixed$33 {
4202
4215
  readonly '~dsl' = "InitTsDsl";
4203
4216
  constructor(fn?: (i: InitTsDsl) => void);
4204
4217
  analyze(ctx: AnalysisContext): void;
@@ -4210,41 +4223,41 @@ interface TypeReturnsMethods extends Node {
4210
4223
  /** Returns the return type node. */
4211
4224
  $returns(): ts.TypeNode | undefined;
4212
4225
  /** Sets the return type. */
4213
- returns(type: NodeName$1 | TypeTsDsl): this;
4226
+ returns(type: NodeName | TypeTsDsl): this;
4214
4227
  }
4215
4228
  //#endregion
4216
4229
  //#region src/ts-dsl/decl/method.d.ts
4217
- declare const Mixed$33: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.MethodDeclaration>, TypeReturnsMethods>, TypeParamsMethods>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, OptionalMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AbstractMethods>;
4218
- declare class MethodTsDsl extends Mixed$33 {
4230
+ declare const Mixed$32: 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>;
4231
+ declare class MethodTsDsl extends Mixed$32 {
4219
4232
  readonly '~dsl' = "MethodTsDsl";
4220
4233
  readonly nameSanitizer: (name: string) => string;
4221
- constructor(name: NodeName$1, fn?: (m: MethodTsDsl) => void);
4234
+ constructor(name: NodeName, fn?: (m: MethodTsDsl) => void);
4222
4235
  analyze(ctx: AnalysisContext): void;
4223
4236
  toAst(): ts.MethodDeclaration;
4224
4237
  }
4225
4238
  //#endregion
4226
4239
  //#region src/ts-dsl/decl/class.d.ts
4227
4240
  type Body = Array<MaybeTsDsl<ts.ClassElement | ts.Node>>;
4228
- declare const Mixed$32: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ClassDeclaration>, TypeParamsMethods>, ExportMethods>, DocMethods>, DefaultMethods>, DecoratorMethods>, AbstractMethods>;
4229
- declare class ClassTsDsl extends Mixed$32 {
4241
+ declare const Mixed$31: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ClassDeclaration>, TypeParamsMethods>, ExportMethods>, DocMethods>, DefaultMethods>, DecoratorMethods>, AbstractMethods>;
4242
+ declare class ClassTsDsl extends Mixed$31 {
4230
4243
  readonly '~dsl' = "ClassTsDsl";
4231
4244
  readonly nameSanitizer: (name: string) => string;
4232
- protected baseClass?: Ref<NodeName$1>;
4245
+ protected baseClass?: Ref<NodeName>;
4233
4246
  protected body: Body;
4234
- constructor(name: NodeName$1);
4247
+ constructor(name: NodeName);
4235
4248
  analyze(ctx: AnalysisContext): void;
4236
4249
  /** Returns true if the class has any members. */
4237
4250
  get hasBody(): boolean;
4238
4251
  /** Adds one or more class members (fields, methods, etc.). */
4239
4252
  do(...items: Body): this;
4240
4253
  /** Records a base class to extend from. */
4241
- extends(base?: NodeName$1): this;
4254
+ extends(base?: NodeName): this;
4242
4255
  /** Adds a class field. */
4243
- field(name: NodeName$1, fn?: (f: FieldTsDsl) => void): this;
4256
+ field(name: NodeName, fn?: (f: FieldTsDsl) => void): this;
4244
4257
  /** Adds a class constructor. */
4245
4258
  init(fn?: InitTsDsl | ((i: InitTsDsl) => void)): this;
4246
4259
  /** Adds a class method. */
4247
- method(name: NodeName$1, fn?: (m: MethodTsDsl) => void): this;
4260
+ method(name: NodeName, fn?: (m: MethodTsDsl) => void): this;
4248
4261
  /** Inserts an empty line between members for formatting. */
4249
4262
  newline(): this;
4250
4263
  toAst(): ts.ClassDeclaration;
@@ -4253,11 +4266,11 @@ declare class ClassTsDsl extends Mixed$32 {
4253
4266
  }
4254
4267
  //#endregion
4255
4268
  //#region src/ts-dsl/decl/decorator.d.ts
4256
- declare const Mixed$31: MixinCtor<abstract new () => TsDsl<ts.Decorator>, ArgsMethods>;
4257
- declare class DecoratorTsDsl extends Mixed$31 {
4269
+ declare const Mixed$30: MixinCtor<abstract new () => TsDsl<ts.Decorator>, ArgsMethods>;
4270
+ declare class DecoratorTsDsl extends Mixed$30 {
4258
4271
  readonly '~dsl' = "DecoratorTsDsl";
4259
4272
  readonly nameSanitizer: (name: string) => string;
4260
- constructor(name: NodeName$1, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>);
4273
+ constructor(name: NodeName, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>);
4261
4274
  analyze(ctx: AnalysisContext): void;
4262
4275
  toAst(): ts.Decorator;
4263
4276
  }
@@ -4265,11 +4278,11 @@ declare class DecoratorTsDsl extends Mixed$31 {
4265
4278
  //#region src/ts-dsl/decl/member.d.ts
4266
4279
  type Value$2 = string | number | MaybeTsDsl<ts.Expression>;
4267
4280
  type ValueFn$1 = Value$2 | ((m: EnumMemberTsDsl) => void);
4268
- declare const Mixed$30: MixinCtor<abstract new () => TsDsl<ts.EnumMember>, DocMethods>;
4269
- declare class EnumMemberTsDsl extends Mixed$30 {
4281
+ declare const Mixed$29: MixinCtor<abstract new () => TsDsl<ts.EnumMember>, DocMethods>;
4282
+ declare class EnumMemberTsDsl extends Mixed$29 {
4270
4283
  readonly '~dsl' = "EnumMemberTsDsl";
4271
4284
  private _value?;
4272
- constructor(name: NodeName$1, value?: ValueFn$1);
4285
+ constructor(name: NodeName, value?: ValueFn$1);
4273
4286
  analyze(ctx: AnalysisContext): void;
4274
4287
  /** Sets the enum member value. */
4275
4288
  value(value?: Value$2): this;
@@ -4279,12 +4292,12 @@ declare class EnumMemberTsDsl extends Mixed$30 {
4279
4292
  //#region src/ts-dsl/decl/enum.d.ts
4280
4293
  type Value$1 = string | number | MaybeTsDsl<ts.Expression>;
4281
4294
  type ValueFn = Value$1 | ((m: EnumMemberTsDsl) => void);
4282
- declare const Mixed$29: MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.EnumDeclaration>, ExportMethods>, DocMethods>, ConstMethods>;
4283
- declare class EnumTsDsl extends Mixed$29 {
4295
+ declare const Mixed$28: MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.EnumDeclaration>, ExportMethods>, DocMethods>, ConstMethods>;
4296
+ declare class EnumTsDsl extends Mixed$28 {
4284
4297
  readonly '~dsl' = "EnumTsDsl";
4285
4298
  readonly nameSanitizer: (name: string) => string;
4286
4299
  private _members;
4287
- constructor(name: NodeName$1, fn?: (e: EnumTsDsl) => void);
4300
+ constructor(name: NodeName, fn?: (e: EnumTsDsl) => void);
4288
4301
  analyze(ctx: AnalysisContext): void;
4289
4302
  /** Adds an enum member. */
4290
4303
  member(name: string, value?: ValueFn): this;
@@ -4295,15 +4308,15 @@ declare class EnumTsDsl extends Mixed$29 {
4295
4308
  //#endregion
4296
4309
  //#region src/ts-dsl/decl/func.d.ts
4297
4310
  type FuncMode = 'arrow' | 'decl' | 'expr';
4298
- declare const Mixed$28: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ArrowFunction>, TypeReturnsMethods>, TypeParamsMethods>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AsMethods>, AbstractMethods>;
4299
- declare class ImplFuncTsDsl<M extends FuncMode = 'arrow'> extends Mixed$28 {
4311
+ declare const Mixed$27: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ArrowFunction>, TypeReturnsMethods>, TypeParamsMethods>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AsMethods>, AbstractMethods>;
4312
+ declare class ImplFuncTsDsl<M extends FuncMode = 'arrow'> extends Mixed$27 {
4300
4313
  readonly '~dsl' = "FuncTsDsl";
4301
4314
  readonly nameSanitizer: (name: string) => string;
4302
4315
  protected mode?: FuncMode;
4303
4316
  constructor();
4304
4317
  constructor(fn: (f: ImplFuncTsDsl<'arrow'>) => void);
4305
- constructor(name: NodeName$1);
4306
- constructor(name: NodeName$1, fn: (f: ImplFuncTsDsl<'decl'>) => void);
4318
+ constructor(name: NodeName);
4319
+ constructor(name: NodeName, fn: (f: ImplFuncTsDsl<'decl'>) => void);
4307
4320
  analyze(ctx: AnalysisContext): void;
4308
4321
  /** Switches the function to an arrow function form. */
4309
4322
  arrow(): FuncTsDsl<'arrow'>;
@@ -4316,27 +4329,27 @@ declare class ImplFuncTsDsl<M extends FuncMode = 'arrow'> extends Mixed$28 {
4316
4329
  declare const FuncTsDsl: {
4317
4330
  new (): FuncTsDsl<"arrow">;
4318
4331
  new (fn: (f: FuncTsDsl<"arrow">) => void): FuncTsDsl<"arrow">;
4319
- new (name: NodeName$1): FuncTsDsl<"decl">;
4320
- new (name: NodeName$1, fn: (f: FuncTsDsl<"decl">) => void): FuncTsDsl<"decl">;
4332
+ new (name: NodeName): FuncTsDsl<"decl">;
4333
+ new (name: NodeName, fn: (f: FuncTsDsl<"decl">) => void): FuncTsDsl<"decl">;
4321
4334
  } & typeof ImplFuncTsDsl;
4322
4335
  type FuncTsDsl<M extends FuncMode = 'arrow'> = ImplFuncTsDsl<M>;
4323
4336
  //#endregion
4324
4337
  //#region src/ts-dsl/decl/getter.d.ts
4325
- declare const Mixed$27: 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>;
4326
- declare class GetterTsDsl extends Mixed$27 {
4338
+ declare const Mixed$26: 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>;
4339
+ declare class GetterTsDsl extends Mixed$26 {
4327
4340
  readonly '~dsl' = "GetterTsDsl";
4328
4341
  readonly nameSanitizer: (name: string) => string;
4329
- constructor(name: NodeName$1, fn?: (g: GetterTsDsl) => void);
4342
+ constructor(name: NodeName, fn?: (g: GetterTsDsl) => void);
4330
4343
  analyze(ctx: AnalysisContext): void;
4331
4344
  toAst(): ts.GetAccessorDeclaration;
4332
4345
  }
4333
4346
  //#endregion
4334
4347
  //#region src/ts-dsl/decl/pattern.d.ts
4335
- declare const Mixed$26: abstract new () => TsDsl<ts.BindingName>;
4348
+ declare const Mixed$25: abstract new () => TsDsl<ts.BindingName>;
4336
4349
  /**
4337
4350
  * Builds binding patterns (e.g. `{ foo, bar }`, `[a, b, ...rest]`).
4338
4351
  */
4339
- declare class PatternTsDsl extends Mixed$26 {
4352
+ declare class PatternTsDsl extends Mixed$25 {
4340
4353
  readonly '~dsl' = "PatternTsDsl";
4341
4354
  protected pattern?: {
4342
4355
  kind: 'array';
@@ -4358,11 +4371,11 @@ declare class PatternTsDsl extends Mixed$26 {
4358
4371
  }
4359
4372
  //#endregion
4360
4373
  //#region src/ts-dsl/decl/setter.d.ts
4361
- declare const Mixed$25: 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>;
4362
- declare class SetterTsDsl extends Mixed$25 {
4374
+ declare const Mixed$24: 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>;
4375
+ declare class SetterTsDsl extends Mixed$24 {
4363
4376
  readonly '~dsl' = "SetterTsDsl";
4364
4377
  readonly nameSanitizer: (name: string) => string;
4365
- constructor(name: NodeName$1, fn?: (s: SetterTsDsl) => void);
4378
+ constructor(name: NodeName, fn?: (s: SetterTsDsl) => void);
4366
4379
  analyze(ctx: AnalysisContext): void;
4367
4380
  toAst(): ts.SetAccessorDeclaration;
4368
4381
  }
@@ -4380,8 +4393,8 @@ interface LayoutMethods extends Node {
4380
4393
  }
4381
4394
  //#endregion
4382
4395
  //#region src/ts-dsl/expr/array.d.ts
4383
- declare const Mixed$24: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ArrayLiteralExpression>, LayoutMethods>, AsMethods>;
4384
- declare class ArrayTsDsl extends Mixed$24 {
4396
+ declare const Mixed$23: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ArrayLiteralExpression>, LayoutMethods>, AsMethods>;
4397
+ declare class ArrayTsDsl extends Mixed$23 {
4385
4398
  readonly '~dsl' = "ArrayTsDsl";
4386
4399
  protected _elements: Array<{
4387
4400
  expr: MaybeTsDsl<ts.Expression>;
@@ -4402,19 +4415,19 @@ declare class ArrayTsDsl extends Mixed$24 {
4402
4415
  }
4403
4416
  //#endregion
4404
4417
  //#region src/ts-dsl/expr/expr.d.ts
4405
- type Id = NodeName$1 | MaybeTsDsl<ts.Expression>;
4406
- declare const Mixed$23: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.Expression>, TypeExprMethods>, OperatorMethods>, ExprMethods>, AsMethods>;
4407
- declare class ExprTsDsl extends Mixed$23 {
4418
+ type Id = NodeName | MaybeTsDsl<ts.Expression>;
4419
+ declare const Mixed$22: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.Expression>, TypeExprMethods>, OperatorMethods>, ExprMethods>, AsMethods>;
4420
+ declare class ExprTsDsl extends Mixed$22 {
4408
4421
  readonly '~dsl' = "ExprTsDsl";
4409
4422
  protected _exprInput: Ref<Id>;
4410
4423
  constructor(id: Id);
4411
4424
  analyze(ctx: AnalysisContext): void;
4412
- toAst(): any;
4425
+ toAst(): ts.Expression;
4413
4426
  }
4414
4427
  //#endregion
4415
4428
  //#region src/ts-dsl/expr/id.d.ts
4416
- declare const Mixed$22: abstract new () => TsDsl<ts.Identifier>;
4417
- declare class IdTsDsl extends Mixed$22 {
4429
+ declare const Mixed$21: abstract new () => TsDsl<ts.Identifier>;
4430
+ declare class IdTsDsl extends Mixed$21 {
4418
4431
  readonly '~dsl' = "IdTsDsl";
4419
4432
  constructor(name: string);
4420
4433
  analyze(ctx: AnalysisContext): void;
@@ -4428,8 +4441,8 @@ interface HintMethods extends Node {
4428
4441
  }
4429
4442
  //#endregion
4430
4443
  //#region src/ts-dsl/expr/prop.d.ts
4431
- type Expr$1 = NodeName$1 | MaybeTsDsl<ts.Expression>;
4432
- type Stmt$1 = NodeName$1 | MaybeTsDsl<ts.Statement>;
4444
+ type Expr$1 = NodeName | MaybeTsDsl<ts.Expression>;
4445
+ type Stmt$1 = NodeName | MaybeTsDsl<ts.Statement>;
4433
4446
  type ObjectPropKind = 'computed' | 'getter' | 'prop' | 'setter' | 'spread';
4434
4447
  type Meta = {
4435
4448
  kind: 'computed';
@@ -4447,8 +4460,8 @@ type Meta = {
4447
4460
  kind: 'spread';
4448
4461
  name?: undefined;
4449
4462
  };
4450
- declare const Mixed$21: MixinCtor<abstract new () => TsDsl<ts.ObjectLiteralElementLike>, DocMethods>;
4451
- declare class ObjectPropTsDsl extends Mixed$21 {
4463
+ declare const Mixed$20: MixinCtor<abstract new () => TsDsl<ts.ObjectLiteralElementLike>, DocMethods>;
4464
+ declare class ObjectPropTsDsl extends Mixed$20 {
4452
4465
  readonly '~dsl' = "ObjectPropTsDsl";
4453
4466
  protected _value?: Ref<Expr$1 | Stmt$1>;
4454
4467
  protected _meta: Meta;
@@ -4458,7 +4471,7 @@ declare class ObjectPropTsDsl extends Mixed$21 {
4458
4471
  analyze(ctx: AnalysisContext): void;
4459
4472
  get isValid(): boolean;
4460
4473
  value(value: Expr$1 | Stmt$1 | ((p: ObjectPropTsDsl) => void)): this;
4461
- toAst(): any;
4474
+ toAst(): ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ts.PropertyAssignment | ts.ShorthandPropertyAssignment | ts.SpreadAssignment;
4462
4475
  $validate(): asserts this is this & {
4463
4476
  _value: Expr$1 | Stmt$1;
4464
4477
  kind: ObjectPropKind;
@@ -4467,12 +4480,12 @@ declare class ObjectPropTsDsl extends Mixed$21 {
4467
4480
  }
4468
4481
  //#endregion
4469
4482
  //#region src/ts-dsl/expr/object.d.ts
4470
- type Expr = NodeName$1 | MaybeTsDsl<ts.Expression>;
4471
- type Stmt = NodeName$1 | MaybeTsDsl<ts.Statement>;
4483
+ type Expr = NodeName | MaybeTsDsl<ts.Expression>;
4484
+ type Stmt = NodeName | MaybeTsDsl<ts.Statement>;
4472
4485
  type ExprFn = Expr | ((p: ObjectPropTsDsl) => void);
4473
4486
  type StmtFn = Stmt | ((p: ObjectPropTsDsl) => void);
4474
- declare const Mixed$20: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ObjectLiteralExpression>, LayoutMethods>, HintMethods>, ExprMethods>, AsMethods>;
4475
- declare class ObjectTsDsl extends Mixed$20 {
4487
+ declare const Mixed$19: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ObjectLiteralExpression>, LayoutMethods>, HintMethods>, ExprMethods>, AsMethods>;
4488
+ declare class ObjectTsDsl extends Mixed$19 {
4476
4489
  readonly '~dsl' = "ObjectTsDsl";
4477
4490
  protected _props: Map<string, ObjectPropTsDsl>;
4478
4491
  protected _spreadCounter: number;
@@ -4500,8 +4513,8 @@ declare class ObjectTsDsl extends Mixed$20 {
4500
4513
  }
4501
4514
  //#endregion
4502
4515
  //#region src/ts-dsl/expr/prefix.d.ts
4503
- declare const Mixed$19: abstract new () => TsDsl<ts.PrefixUnaryExpression>;
4504
- declare class PrefixTsDsl extends Mixed$19 {
4516
+ declare const Mixed$18: abstract new () => TsDsl<ts.PrefixUnaryExpression>;
4517
+ declare class PrefixTsDsl extends Mixed$18 {
4505
4518
  readonly '~dsl' = "PrefixTsDsl";
4506
4519
  protected _expr?: string | MaybeTsDsl<ts.Expression>;
4507
4520
  protected _op?: ts.PrefixUnaryOperator;
@@ -4521,8 +4534,8 @@ declare class PrefixTsDsl extends Mixed$19 {
4521
4534
  //#region src/ts-dsl/expr/regexp.d.ts
4522
4535
  type RegexFlag = 'g' | 'i' | 'm' | 's' | 'u' | 'y';
4523
4536
  type RegexFlags<Avail extends string = RegexFlag> = '' | { [K in Avail]: `${K}${RegexFlags<Exclude<Avail, K>>}` }[Avail];
4524
- declare const Mixed$18: abstract new () => TsDsl<ts.RegularExpressionLiteral>;
4525
- declare class RegExpTsDsl extends Mixed$18 {
4537
+ declare const Mixed$17: abstract new () => TsDsl<ts.RegularExpressionLiteral>;
4538
+ declare class RegExpTsDsl extends Mixed$17 {
4526
4539
  readonly '~dsl' = "RegExpTsDsl";
4527
4540
  protected pattern: string;
4528
4541
  protected flags?: RegexFlags;
@@ -4531,18 +4544,6 @@ declare class RegExpTsDsl extends Mixed$18 {
4531
4544
  toAst(): ts.RegularExpressionLiteral;
4532
4545
  }
4533
4546
  //#endregion
4534
- //#region src/ts-dsl/expr/template.d.ts
4535
- type TemplatePart = NodeName$1 | MaybeTsDsl<ts.Expression>;
4536
- declare const Mixed$17: abstract new () => TsDsl<ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral>;
4537
- declare class TemplateTsDsl extends Mixed$17 {
4538
- readonly '~dsl' = "TemplateTsDsl";
4539
- protected parts: Array<Ref<TemplatePart>>;
4540
- constructor(value?: TemplatePart);
4541
- analyze(ctx: AnalysisContext): void;
4542
- add(value: TemplatePart): this;
4543
- toAst(): ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral;
4544
- }
4545
- //#endregion
4546
4547
  //#region src/ts-dsl/expr/ternary.d.ts
4547
4548
  declare const Mixed$16: abstract new () => TsDsl<ts.ConditionalExpression>;
4548
4549
  declare class TernaryTsDsl extends Mixed$16 {
@@ -4602,13 +4603,13 @@ declare const Mixed$12: abstract new () => TsDsl<ts.TryStatement>;
4602
4603
  declare class TryTsDsl extends Mixed$12 {
4603
4604
  readonly '~dsl' = "TryTsDsl";
4604
4605
  protected _catch?: Array<DoExpr>;
4605
- protected _catchArg?: NodeName$1;
4606
+ protected _catchArg?: NodeName;
4606
4607
  protected _finally?: Array<DoExpr>;
4607
4608
  protected _try?: Array<DoExpr>;
4608
4609
  constructor(...tryBlock: Array<DoExpr>);
4609
4610
  analyze(ctx: AnalysisContext): void;
4610
4611
  catch(...items: Array<DoExpr>): this;
4611
- catchArg(arg: NodeName$1): this;
4612
+ catchArg(arg: NodeName): this;
4612
4613
  finally(...items: Array<DoExpr>): this;
4613
4614
  try(...items: Array<DoExpr>): this;
4614
4615
  toAst(): ts.TryStatement;
@@ -4621,7 +4622,7 @@ declare class VarTsDsl extends Mixed$11 {
4621
4622
  readonly nameSanitizer: (name: string) => string;
4622
4623
  protected kind: ts.NodeFlags;
4623
4624
  protected _type?: TypeTsDsl;
4624
- constructor(name?: NodeName$1);
4625
+ constructor(name?: NodeName);
4625
4626
  analyze(ctx: AnalysisContext): void;
4626
4627
  const(): this;
4627
4628
  let(): this;
@@ -4660,7 +4661,7 @@ declare class TypeAliasTsDsl extends Mixed$10 {
4660
4661
  readonly nameSanitizer: (name: string) => string;
4661
4662
  scope: NodeScope;
4662
4663
  protected value?: Value;
4663
- constructor(name: NodeName$1, fn?: (t: TypeAliasTsDsl) => void);
4664
+ constructor(name: NodeName, fn?: (t: TypeAliasTsDsl) => void);
4664
4665
  analyze(ctx: AnalysisContext): void;
4665
4666
  /** Sets the type expression on the right-hand side of `= ...`. */
4666
4667
  type(node: Value): this;
@@ -4668,7 +4669,7 @@ declare class TypeAliasTsDsl extends Mixed$10 {
4668
4669
  }
4669
4670
  //#endregion
4670
4671
  //#region src/ts-dsl/type/and.d.ts
4671
- type Type$1 = NodeName$1 | ts.TypeNode | TypeTsDsl;
4672
+ type Type$1 = NodeName | ts.TypeNode | TypeTsDsl;
4672
4673
  declare const Mixed$9: abstract new () => TsDsl<ts.IntersectionTypeNode>;
4673
4674
  declare class TypeAndTsDsl extends Mixed$9 {
4674
4675
  readonly '~dsl' = "TypeAndTsDsl";
@@ -4709,7 +4710,7 @@ declare class TypeMappedTsDsl extends Mixed$6 {
4709
4710
  protected readonlyToken?: TokenTsDsl<ts.SyntaxKind.ReadonlyKeyword | ts.SyntaxKind.MinusToken | ts.SyntaxKind.PlusToken>;
4710
4711
  protected _key?: string | MaybeTsDsl<ts.TypeNode>;
4711
4712
  protected _type?: string | MaybeTsDsl<ts.TypeNode>;
4712
- constructor(name?: NodeName$1);
4713
+ constructor(name?: NodeName);
4713
4714
  analyze(ctx: AnalysisContext): void;
4714
4715
  /** Returns true when all required builder calls are present. */
4715
4716
  get isValid(): boolean;
@@ -4742,7 +4743,7 @@ declare class TypeIdxSigTsDsl extends Mixed$5 {
4742
4743
  scope: NodeScope;
4743
4744
  protected _key?: TypeIdxSigType;
4744
4745
  protected _type?: TypeIdxSigType;
4745
- constructor(name: NodeName$1, fn?: (i: TypeIdxSigTsDsl) => void);
4746
+ constructor(name: NodeName, fn?: (i: TypeIdxSigTsDsl) => void);
4746
4747
  /** Element kind. */
4747
4748
  get kind(): TypeIdxSigKind;
4748
4749
  /** Index signature parameter name. */
@@ -4763,14 +4764,14 @@ declare class TypeIdxSigTsDsl extends Mixed$5 {
4763
4764
  }
4764
4765
  //#endregion
4765
4766
  //#region src/ts-dsl/type/prop.d.ts
4766
- type TypePropType = NodeName$1 | MaybeTsDsl<ts.TypeNode>;
4767
+ type TypePropType = NodeName | MaybeTsDsl<ts.TypeNode>;
4767
4768
  type TypePropKind = 'prop';
4768
4769
  declare const Mixed$4: MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.TypeElement>, ReadonlyMethods>, OptionalMethods>, DocMethods>;
4769
4770
  declare class TypePropTsDsl extends Mixed$4 {
4770
4771
  readonly '~dsl' = "TypePropTsDsl";
4771
4772
  scope: NodeScope;
4772
4773
  protected _type?: Ref<TypePropType>;
4773
- constructor(name: NodeName$1, fn: (p: TypePropTsDsl) => void);
4774
+ constructor(name: NodeName, fn: (p: TypePropTsDsl) => void);
4774
4775
  /** Element kind. */
4775
4776
  get kind(): TypePropKind;
4776
4777
  /** Property name. */
@@ -4802,7 +4803,7 @@ declare class TypeObjectTsDsl extends Mixed$3 {
4802
4803
  }
4803
4804
  //#endregion
4804
4805
  //#region src/ts-dsl/type/or.d.ts
4805
- type Type = NodeName$1 | ts.TypeNode | TypeTsDsl;
4806
+ type Type = NodeName | ts.TypeNode | TypeTsDsl;
4806
4807
  declare const Mixed$2: abstract new () => TsDsl<ts.UnionTypeNode>;
4807
4808
  declare class TypeOrTsDsl extends Mixed$2 {
4808
4809
  readonly '~dsl' = "TypeOrTsDsl";
@@ -4969,35 +4970,35 @@ declare const reserved: {
4969
4970
  };
4970
4971
  //#endregion
4971
4972
  //#region src/ts-dsl/index.d.ts
4972
- declare const $: ((id: any) => ExprTsDsl) & {
4973
+ declare const $: ((id: ts.Expression | TsDsl<ts.Expression> | _hey_api_codegen_core0.NodeName) => ExprTsDsl) & {
4973
4974
  /** Creates an array literal expression (e.g. `[1, 2, 3]`). */
4974
4975
  array: (...args: ConstructorParameters<typeof ArrayTsDsl>) => ArrayTsDsl;
4975
4976
  /** Creates an `as` type assertion expression (e.g. `value as Type`). */
4976
- as: (expr: any, type: any) => AsTsDsl;
4977
+ as: (expr: AsExpr, type: AsType) => AsTsDsl;
4977
4978
  /** Creates a property access expression (e.g. `obj.foo`). */
4978
- attr: (left: any, right: NodeName) => AttrTsDsl;
4979
+ attr: (left: AttrLeft, right: _hey_api_codegen_core0.NodeName) => AttrTsDsl;
4979
4980
  /** Creates an await expression (e.g. `await promise`). */
4980
- await: (expr: any) => AwaitTsDsl;
4981
+ await: (expr: AwaitExpr) => AwaitTsDsl;
4981
4982
  /** Creates a binary expression (e.g. `a + b`). */
4982
- binary: (base: any, op?: (("!=" | "!==" | "&&" | "*" | "+" | "-" | "/" | "<" | "<=" | "=" | "==" | "===" | ">" | ">=" | "??" | "??=" | "||") | ts.BinaryOperator) | undefined, expr?: any) => BinaryTsDsl;
4983
+ binary: (base: ts.Expression | TsDsl<ts.Expression> | _hey_api_codegen_core0.NodeName, op?: (("!=" | "!==" | "&&" | "*" | "+" | "-" | "/" | "<" | "<=" | "=" | "==" | "===" | ">" | ">=" | "??" | "??=" | "||") | ts.BinaryOperator) | undefined, expr?: (ts.Expression | TsDsl<ts.Expression> | _hey_api_codegen_core0.NodeName) | undefined) => BinaryTsDsl;
4983
4984
  /** Creates a statement block (`{ ... }`). */
4984
4985
  block: (...args: ConstructorParameters<typeof BlockTsDsl>) => BlockTsDsl;
4985
4986
  /** Creates a function or method call expression (e.g. `fn(arg)`). */
4986
- call: (expr: any, ...args: any[]) => CallTsDsl;
4987
+ call: (expr: CallExpr, ...args: (CallExpr | undefined)[]) => CallTsDsl;
4987
4988
  /** Creates a class declaration or expression. */
4988
- class: (name: NodeName) => ClassTsDsl;
4989
+ class: (name: _hey_api_codegen_core0.NodeName) => ClassTsDsl;
4989
4990
  /** Creates a constant variable declaration (`const`). */
4990
- const: (name?: any) => VarTsDsl;
4991
+ const: (name?: _hey_api_codegen_core0.NodeName | undefined) => VarTsDsl;
4991
4992
  /** Creates a decorator expression (e.g. `@decorator`). */
4992
- decorator: (name: NodeName, ...args: (string | ts.Expression | TsDsl<ts.Expression>)[]) => DecoratorTsDsl;
4993
+ decorator: (name: _hey_api_codegen_core0.NodeName, ...args: (string | ts.Expression | TsDsl<ts.Expression>)[]) => DecoratorTsDsl;
4993
4994
  /** Creates a JSDoc documentation block. */
4994
4995
  doc: (lines?: DocLines | undefined, fn?: DocFn | undefined) => DocTsDsl;
4995
4996
  /** Creates an enum declaration. */
4996
- enum: (name: NodeName, fn?: ((e: EnumTsDsl) => void) | undefined) => EnumTsDsl;
4997
+ enum: (name: _hey_api_codegen_core0.NodeName, fn?: ((e: EnumTsDsl) => void) | undefined) => EnumTsDsl;
4997
4998
  /** Creates a general expression node. */
4998
- expr: (id: any) => ExprTsDsl;
4999
+ expr: (id: ts.Expression | TsDsl<ts.Expression> | _hey_api_codegen_core0.NodeName) => ExprTsDsl;
4999
5000
  /** Creates a field declaration in a class or object. */
5000
- field: (name: NodeName, fn?: ((f: FieldTsDsl) => void) | undefined) => FieldTsDsl;
5001
+ field: (name: _hey_api_codegen_core0.NodeName, fn?: ((f: FieldTsDsl) => void) | undefined) => FieldTsDsl;
5001
5002
  /** Converts a runtime value into a corresponding expression node. */
5002
5003
  fromValue: (input: unknown, options?: {
5003
5004
  layout?: "pretty";
@@ -5011,7 +5012,7 @@ declare const $: ((id: any) => ExprTsDsl) & {
5011
5012
  (name?: string, fn?: (f: FuncTsDsl<"decl">) => void): FuncTsDsl<"arrow"> | FuncTsDsl<"decl">;
5012
5013
  };
5013
5014
  /** Creates a getter method declaration. */
5014
- getter: (name: NodeName, fn?: ((g: GetterTsDsl) => void) | undefined) => GetterTsDsl;
5015
+ getter: (name: _hey_api_codegen_core0.NodeName, fn?: ((g: GetterTsDsl) => void) | undefined) => GetterTsDsl;
5015
5016
  /** Creates a single-line comment (//). */
5016
5017
  hint: (lines?: HintLines | undefined, fn?: HintFn | undefined) => HintTsDsl;
5017
5018
  /** Creates an identifier (e.g. `foo`). */
@@ -5023,17 +5024,17 @@ declare const $: ((id: any) => ExprTsDsl) & {
5023
5024
  /** Creates a lazy, context-aware node with deferred evaluation. */
5024
5025
  lazy: <T extends ts.Node>(thunk: LazyThunk<T>) => LazyTsDsl<T>;
5025
5026
  /** Creates a let variable declaration (`let`). */
5026
- let: (name?: any) => VarTsDsl;
5027
+ let: (name?: _hey_api_codegen_core0.NodeName | undefined) => VarTsDsl;
5027
5028
  /** Creates a literal value (e.g. string, number, boolean). */
5028
5029
  literal: (value: LiteralValue) => LiteralTsDsl;
5029
5030
  /** Creates an enum member declaration. */
5030
- member: (name: NodeName, value?: ((string | number | ts.Expression | TsDsl<ts.Expression>) | ((m: EnumMemberTsDsl) => void)) | undefined) => EnumMemberTsDsl;
5031
+ member: (name: _hey_api_codegen_core0.NodeName, value?: ((string | number | ts.Expression | TsDsl<ts.Expression>) | ((m: EnumMemberTsDsl) => void)) | undefined) => EnumMemberTsDsl;
5031
5032
  /** Creates a method declaration inside a class or object. */
5032
- method: (name: NodeName, fn?: ((m: MethodTsDsl) => void) | undefined) => MethodTsDsl;
5033
+ method: (name: _hey_api_codegen_core0.NodeName, fn?: ((m: MethodTsDsl) => void) | undefined) => MethodTsDsl;
5033
5034
  /** Creates a negation expression (`-x`). */
5034
5035
  neg: (expr?: string | ts.Expression | TsDsl<ts.Expression> | undefined, op?: ts.PrefixUnaryOperator | undefined) => PrefixTsDsl;
5035
5036
  /** Creates a new expression (e.g. `new ClassName()`). */
5036
- new: (expr: any, ...args: any[]) => NewTsDsl;
5037
+ new: (expr: NewExpr, ...args: (NewExpr | undefined)[]) => NewTsDsl;
5037
5038
  /** Creates a newline (for formatting purposes). */
5038
5039
  newline: () => NewlineTsDsl;
5039
5040
  /** Creates a logical NOT expression (`!x`). */
@@ -5043,7 +5044,7 @@ declare const $: ((id: any) => ExprTsDsl) & {
5043
5044
  /** Creates an object literal expression. */
5044
5045
  object: (...args: ConstructorParameters<typeof ObjectTsDsl>) => ObjectTsDsl;
5045
5046
  /** Creates a parameter declaration for functions or methods. */
5046
- param: (name: any, fn?: ((p: ParamTsDsl) => void) | undefined) => ParamTsDsl;
5047
+ param: (name: _hey_api_codegen_core0.NodeName | ((p: ParamTsDsl) => void), fn?: ((p: ParamTsDsl) => void) | undefined) => ParamTsDsl;
5047
5048
  /** Creates a pattern for destructuring or matching. */
5048
5049
  pattern: () => PatternTsDsl;
5049
5050
  /** Creates a prefix unary expression (e.g. `-x`, `!x`, `~x`). */
@@ -5068,13 +5069,13 @@ declare const $: ((id: any) => ExprTsDsl) & {
5068
5069
  /** Creates a regular expression literal (e.g. `/foo/gi`). */
5069
5070
  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;
5070
5071
  /** Creates a return statement. */
5071
- return: (expr?: any) => ReturnTsDsl;
5072
+ return: (expr?: ReturnExpr | undefined) => ReturnTsDsl;
5072
5073
  /** Creates a setter method declaration. */
5073
- setter: (name: NodeName, fn?: ((s: SetterTsDsl) => void) | undefined) => SetterTsDsl;
5074
+ setter: (name: _hey_api_codegen_core0.NodeName, fn?: ((s: SetterTsDsl) => void) | undefined) => SetterTsDsl;
5074
5075
  /** Wraps an expression or statement-like value into a `StmtTsDsl`. */
5075
5076
  stmt: (inner: ts.Expression | ts.Statement | TsDsl<any>) => StmtTsDsl;
5076
5077
  /** Creates a template literal expression. */
5077
- template: (value?: any) => TemplateTsDsl;
5078
+ template: (value?: TemplatePart | undefined) => TemplateTsDsl;
5078
5079
  /** Creates a ternary conditional expression (if ? then : else). */
5079
5080
  ternary: (condition?: string | ts.Expression | TsDsl<ts.Expression> | undefined) => TernaryTsDsl;
5080
5081
  /** Creates a throw statement. */
@@ -5084,15 +5085,15 @@ declare const $: ((id: any) => ExprTsDsl) & {
5084
5085
  /** Creates a try/catch/finally statement. */
5085
5086
  try: (...args: ConstructorParameters<typeof TryTsDsl>) => TryTsDsl;
5086
5087
  /** Creates a basic type reference or type expression (e.g. Foo or Foo<T>). */
5087
- type: ((name: NodeName, fn?: TypeExprFn | undefined) => TypeExprTsDsl) & {
5088
+ type: ((name: _hey_api_codegen_core0.NodeName, fn?: TypeExprFn | undefined) => TypeExprTsDsl) & {
5088
5089
  /** Creates a type alias declaration (e.g. `type Foo = Bar`). */
5089
- alias: (name: NodeName, fn?: ((t: TypeAliasTsDsl) => void) | undefined) => TypeAliasTsDsl;
5090
+ alias: (name: _hey_api_codegen_core0.NodeName, fn?: ((t: TypeAliasTsDsl) => void) | undefined) => TypeAliasTsDsl;
5090
5091
  /** Creates an intersection type (e.g. `A & B`). */
5091
5092
  and: (...args: ConstructorParameters<typeof TypeAndTsDsl>) => TypeAndTsDsl;
5092
5093
  /** Creates a qualified type reference (e.g. Foo.Bar). */
5093
- attr: (right: any) => TypeAttrTsDsl;
5094
+ attr: (right: _hey_api_codegen_core0.NodeName | ts.Identifier) => TypeAttrTsDsl;
5094
5095
  /** Creates a basic type reference or type expression (e.g. Foo or Foo<T>). */
5095
- expr: (name: NodeName, fn?: TypeExprFn | undefined) => TypeExprTsDsl;
5096
+ expr: (name: _hey_api_codegen_core0.NodeName, fn?: TypeExprFn | undefined) => TypeExprTsDsl;
5096
5097
  /** Converts a runtime value into a corresponding type expression node. */
5097
5098
  fromValue: (input: unknown) => TsDsl<ts.TypeNode>;
5098
5099
  /** Creates a function type node (e.g. `(a: string) => number`). */
@@ -5102,7 +5103,7 @@ declare const $: ((id: any) => ExprTsDsl) & {
5102
5103
  /** Creates a literal type node (e.g. 'foo', 42, or true). */
5103
5104
  literal: (value: string | number | boolean | null) => TypeLiteralTsDsl;
5104
5105
  /** Creates a mapped type (e.g. `{ [K in keyof T]: U }`). */
5105
- mapped: (name?: any) => TypeMappedTsDsl;
5106
+ mapped: (name?: _hey_api_codegen_core0.NodeName | undefined) => TypeMappedTsDsl;
5106
5107
  /** Creates a type literal node (e.g. { foo: string }). */
5107
5108
  object: () => TypeObjectTsDsl;
5108
5109
  /** Creates a type operator node (e.g. `readonly T`, `keyof T`, `unique T`). */
@@ -5110,7 +5111,7 @@ declare const $: ((id: any) => ExprTsDsl) & {
5110
5111
  /** Represents a union type (e.g. `A | B | C`). */
5111
5112
  or: (...args: ConstructorParameters<typeof TypeOrTsDsl>) => TypeOrTsDsl;
5112
5113
  /** Creates a type parameter (e.g. `<T>`). */
5113
- param: (name?: any, fn?: ((name: TypeParamTsDsl) => void) | undefined) => TypeParamTsDsl;
5114
+ param: (name?: _hey_api_codegen_core0.NodeName | undefined, fn?: ((name: TypeParamTsDsl) => void) | undefined) => TypeParamTsDsl;
5114
5115
  /** Creates a type query node (e.g. `typeof Foo`). */
5115
5116
  query: (expr: TypeQueryExpr) => TypeQueryTsDsl;
5116
5117
  /** Builds a TypeScript template literal *type* (e.g. `${Foo}-${Bar}` as a type). */
@@ -5121,7 +5122,7 @@ declare const $: ((id: any) => ExprTsDsl) & {
5121
5122
  /** Creates a `typeof` expression (e.g. `typeof value`). */
5122
5123
  typeofExpr: (expr: TypeOfExpr) => TypeOfExprTsDsl;
5123
5124
  /** Creates a variable declaration (`var`). */
5124
- var: (name?: any) => VarTsDsl;
5125
+ var: (name?: _hey_api_codegen_core0.NodeName | undefined) => VarTsDsl;
5125
5126
  };
5126
5127
  type DollarTsDsl = {
5127
5128
  /**
@@ -16468,4 +16469,4 @@ type Config = Omit<Required<UserConfig>, 'input' | 'logs' | 'output' | 'parser'
16468
16469
  };
16469
16470
  //#endregion
16470
16471
  export { MaybeTsDsl as A, IR as B, Client$6 as C, TypeScriptRenderer as D, reserved as E, ctx as F, CallArgs as I, OperationPath as L, TypeTsDsl as M, ExampleOptions as N, regexp as O, TsDslContext as P, OperationStrategy as R, Client$5 as S, DollarTsDsl as T, PluginHandler as _, Plugin as a, Client$3 as b, OpenApiOperationObject as c, OpenApiResponseObject as d, OpenApiSchemaObject as f, Client as g, ExpressionTransformer as h, DefinePlugin as i, TsDsl as j, keywords as k, OpenApiParameterObject as l, TypeTransformer as m, UserConfig as n, OpenApi as o, Context as p, Input as r, OpenApiMetaObject as s, Config as t, OpenApiRequestBodyObject as u, Client$1 as v, $ as w, Client$4 as x, Client$2 as y, Casing as z };
16471
- //# sourceMappingURL=types-CQTciSfa.d.mts.map
16472
+ //# sourceMappingURL=types-CLcjoomL.d.mts.map