@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 { MaybeArray, MaybeFunc, MaybePromise } from "@hey-api/types";
4
5
  import { RangeOptions, SemVer } from "semver";
5
6
  import ts from "typescript";
@@ -3406,7 +3407,7 @@ type DropFirst<T extends Array<any>> = T extends [any, ...infer Rest] ? Rest : n
3406
3407
  type MixinCtor<T extends BaseCtor<any>, K$1> = abstract new (...args: Array<any>) => InstanceType<T> & K$1;
3407
3408
  //#endregion
3408
3409
  //#region src/ts-dsl/mixins/type-args.d.ts
3409
- type Arg$1 = NodeName$1 | MaybeTsDsl<TypeTsDsl>;
3410
+ type Arg$1 = NodeName | MaybeTsDsl<TypeTsDsl>;
3410
3411
  interface TypeArgsMethods extends Node {
3411
3412
  /** Returns the type arguments as an array of ts.TypeNode nodes. */
3412
3413
  $generics(): ReadonlyArray<ts.TypeNode> | undefined;
@@ -3423,8 +3424,8 @@ interface AsMethods extends Node {
3423
3424
  }
3424
3425
  //#endregion
3425
3426
  //#region src/ts-dsl/expr/as.d.ts
3426
- type AsExpr = NodeName$1 | MaybeTsDsl<ts.Expression>;
3427
- type AsType = NodeName$1 | TypeTsDsl;
3427
+ type AsExpr = NodeName | MaybeTsDsl<ts.Expression>;
3428
+ type AsType = NodeName | TypeTsDsl;
3428
3429
  type AsCtor = (expr: AsExpr, type: AsType) => AsTsDsl;
3429
3430
  declare const Mixed$52: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.AsExpression>, ExprMethods>, AsMethods>;
3430
3431
  declare class AsTsDsl extends Mixed$52 {
@@ -3446,7 +3447,7 @@ interface OptionalMethods extends Node {
3446
3447
  }
3447
3448
  //#endregion
3448
3449
  //#region src/ts-dsl/expr/binary.d.ts
3449
- type Expr$3 = NodeName$1 | MaybeTsDsl<ts.Expression>;
3450
+ type Expr$3 = NodeName | MaybeTsDsl<ts.Expression>;
3450
3451
  type Op$1 = Operator | ts.BinaryOperator;
3451
3452
  type Operator = '!=' | '!==' | '&&' | '*' | '+' | '-' | '/' | '<' | '<=' | '=' | '==' | '===' | '>' | '>=' | '??' | '??=' | '||';
3452
3453
  declare const Mixed$51: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.BinaryExpression>, ExprMethods>, AsMethods>;
@@ -3498,7 +3499,7 @@ declare class BinaryTsDsl extends Mixed$51 {
3498
3499
  }
3499
3500
  //#endregion
3500
3501
  //#region src/ts-dsl/mixins/operator.d.ts
3501
- type Expr$2 = NodeName$1 | MaybeTsDsl<ts.Expression>;
3502
+ type Expr$2 = NodeName | MaybeTsDsl<ts.Expression>;
3502
3503
  interface OperatorMethods extends Node {
3503
3504
  /** Logical AND — `this && expr` */
3504
3505
  and(expr: Expr$2): BinaryTsDsl;
@@ -3537,19 +3538,19 @@ interface OperatorMethods extends Node {
3537
3538
  }
3538
3539
  //#endregion
3539
3540
  //#region src/ts-dsl/expr/attr.d.ts
3540
- type AttrLeft = NodeName$1 | MaybeTsDsl<ts.Expression>;
3541
- type AttrCtor = (left: AttrLeft, right: NodeName$1) => AttrTsDsl;
3541
+ type AttrLeft = NodeName | MaybeTsDsl<ts.Expression>;
3542
+ type AttrCtor = (left: AttrLeft, right: NodeName) => AttrTsDsl;
3542
3543
  declare const Mixed$50: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.PropertyAccessExpression | ts.ElementAccessExpression>, OptionalMethods>, OperatorMethods>, ExprMethods>, AsMethods>;
3543
3544
  declare class AttrTsDsl extends Mixed$50 {
3544
3545
  readonly '~dsl' = "AttrTsDsl";
3545
3546
  protected left: Ref<AttrLeft>;
3546
- constructor(left: AttrLeft, right: NodeName$1);
3547
+ constructor(left: AttrLeft, right: NodeName);
3547
3548
  analyze(ctx: AnalysisContext): void;
3548
3549
  toAst(): ts.PropertyAccessExpression | ts.ElementAccessExpression;
3549
3550
  }
3550
3551
  //#endregion
3551
3552
  //#region src/ts-dsl/expr/await.d.ts
3552
- type AwaitExpr = NodeName$1 | MaybeTsDsl<ts.Expression>;
3553
+ type AwaitExpr = NodeName | MaybeTsDsl<ts.Expression>;
3553
3554
  type AwaitCtor = (expr: AwaitExpr) => AwaitTsDsl;
3554
3555
  declare const Mixed$49: MixinCtor<abstract new () => TsDsl<ts.AwaitExpression>, ExprMethods>;
3555
3556
  declare class AwaitTsDsl extends Mixed$49 {
@@ -3561,7 +3562,7 @@ declare class AwaitTsDsl extends Mixed$49 {
3561
3562
  }
3562
3563
  //#endregion
3563
3564
  //#region src/ts-dsl/mixins/args.d.ts
3564
- type Arg = NodeName$1 | MaybeTsDsl<ts.Expression>;
3565
+ type Arg = NodeName | MaybeTsDsl<ts.Expression>;
3565
3566
  interface ArgsMethods extends Node {
3566
3567
  /** Renders the arguments into an array of `Expression`s. */
3567
3568
  $args(): ReadonlyArray<ts.Expression>;
@@ -3573,7 +3574,7 @@ interface ArgsMethods extends Node {
3573
3574
  //#endregion
3574
3575
  //#region src/ts-dsl/expr/new.d.ts
3575
3576
  type NewArgs = ReadonlyArray<NewExpr | undefined>;
3576
- type NewExpr = NodeName$1 | MaybeTsDsl<ts.Expression>;
3577
+ type NewExpr = NodeName | MaybeTsDsl<ts.Expression>;
3577
3578
  type NewCtor = (expr: NewExpr, ...args: NewArgs) => NewTsDsl;
3578
3579
  declare const Mixed$48: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.NewExpression>, TypeArgsMethods>, ExprMethods>, AsMethods>, ArgsMethods>;
3579
3580
  declare class NewTsDsl extends Mixed$48 {
@@ -3597,7 +3598,7 @@ declare class TypeOfExprTsDsl extends Mixed$47 {
3597
3598
  }
3598
3599
  //#endregion
3599
3600
  //#region src/ts-dsl/stmt/return.d.ts
3600
- type ReturnExpr = NodeName$1 | MaybeTsDsl<ts.Expression>;
3601
+ type ReturnExpr = NodeName | MaybeTsDsl<ts.Expression>;
3601
3602
  type ReturnCtor = (expr?: ReturnExpr) => ReturnTsDsl;
3602
3603
  declare const Mixed$46: abstract new () => TsDsl<ts.ReturnStatement>;
3603
3604
  declare class ReturnTsDsl extends Mixed$46 {
@@ -3627,8 +3628,8 @@ interface TypeExprMethods extends Node {
3627
3628
  }
3628
3629
  //#endregion
3629
3630
  //#region src/ts-dsl/type/attr.d.ts
3630
- type Base$1 = NodeName$1 | MaybeTsDsl<ts.EntityName>;
3631
- type Right = NodeName$1 | ts.Identifier;
3631
+ type Base$1 = NodeName | MaybeTsDsl<ts.EntityName>;
3632
+ type Right = NodeName | ts.Identifier;
3632
3633
  declare const Mixed$45: MixinCtor<abstract new () => TsDsl<ts.QualifiedName>, TypeExprMethods>;
3633
3634
  declare class TypeAttrTsDsl extends Mixed$45 {
3634
3635
  readonly '~dsl' = "TypeAttrTsDsl";
@@ -3644,9 +3645,9 @@ declare class TypeAttrTsDsl extends Mixed$45 {
3644
3645
  }
3645
3646
  //#endregion
3646
3647
  //#region src/ts-dsl/type/expr.d.ts
3647
- type TypeExprExpr = NodeName$1 | TypeAttrTsDsl;
3648
+ type TypeExprExpr = NodeName | TypeAttrTsDsl;
3648
3649
  type TypeExprFn = (t: TypeExprTsDsl) => void;
3649
- type TypeExprCtor = (nameOrFn?: NodeName$1 | TypeExprFn, fn?: TypeExprFn) => TypeExprTsDsl;
3650
+ type TypeExprCtor = (nameOrFn?: NodeName | TypeExprFn, fn?: TypeExprFn) => TypeExprTsDsl;
3650
3651
  declare const Mixed$44: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.TypeReferenceNode>, TypeExprMethods>, TypeArgsMethods>;
3651
3652
  declare class TypeExprTsDsl extends Mixed$44 {
3652
3653
  readonly '~dsl' = "TypeExprTsDsl";
@@ -3654,8 +3655,8 @@ declare class TypeExprTsDsl extends Mixed$44 {
3654
3655
  protected _exprInput?: Ref<TypeExprExpr>;
3655
3656
  constructor();
3656
3657
  constructor(fn: TypeExprFn);
3657
- constructor(name: NodeName$1);
3658
- constructor(name: NodeName$1, fn?: TypeExprFn);
3658
+ constructor(name: NodeName);
3659
+ constructor(name: NodeName, fn?: TypeExprFn);
3659
3660
  analyze(ctx: AnalysisContext): void;
3660
3661
  /** Accesses a nested type (e.g. `Foo.Bar`). */
3661
3662
  attr(right: string | ts.Identifier | TypeAttrTsDsl): this;
@@ -3783,7 +3784,7 @@ interface ExprMethods extends Node {
3783
3784
  //#endregion
3784
3785
  //#region src/ts-dsl/expr/call.d.ts
3785
3786
  type CallArgs = ReadonlyArray<CallExpr | undefined>;
3786
- type CallExpr = NodeName$1 | MaybeTsDsl<ts.Expression>;
3787
+ type CallExpr = NodeName | MaybeTsDsl<ts.Expression>;
3787
3788
  type CallCtor = (expr: CallExpr, ...args: CallArgs) => CallTsDsl;
3788
3789
  declare const Mixed$40: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.CallExpression>, TypeArgsMethods>, ExprMethods>, AsMethods>, ArgsMethods>;
3789
3790
  declare class CallTsDsl extends Mixed$40 {
@@ -3868,7 +3869,7 @@ declare abstract class TsDsl<T extends ts.Node = ts.Node> implements Node<T> {
3868
3869
  structuralParents?: Map<TsDsl, NodeRelationship>;
3869
3870
  symbol?: Symbol;
3870
3871
  toAst(): T;
3871
- readonly '~brand': any;
3872
+ readonly '~brand' = "heyapi.node";
3872
3873
  /** Branding property to identify the DSL class at runtime. */
3873
3874
  abstract readonly '~dsl': string & {};
3874
3875
  /** Conditionally applies a callback to this builder. */
@@ -3889,7 +3890,7 @@ declare abstract class TsDsl<T extends ts.Node = ts.Node> implements Node<T> {
3889
3890
  length: number;
3890
3891
  }): TsDsl | undefined;
3891
3892
  protected $maybeId<T extends string | ts.Expression>(expr: T): T extends string ? ts.Identifier : T;
3892
- protected $name(name: Ref<NodeName$1>): string;
3893
+ protected $name(name: Ref<NodeName>): string;
3893
3894
  protected $node<I>(value: I): NodeOfMaybe<I>;
3894
3895
  protected $type<I>(value: I, args?: ReadonlyArray<ts.TypeNode>): TypeOfMaybe<I>;
3895
3896
  private _name?;
@@ -3974,7 +3975,7 @@ declare class LiteralTsDsl extends Mixed$38 {
3974
3975
  protected value: LiteralValue;
3975
3976
  constructor(value: LiteralValue);
3976
3977
  analyze(ctx: AnalysisContext): void;
3977
- toAst(): any;
3978
+ toAst(): ts.BigIntLiteral | ts.TrueLiteral | ts.FalseLiteral | ts.NullLiteral | ts.NumericLiteral | ts.PrefixUnaryExpression | ts.StringLiteral;
3978
3979
  }
3979
3980
  //#endregion
3980
3981
  //#region src/ts-dsl/layout/note.d.ts
@@ -3991,15 +3992,27 @@ declare class NoteTsDsl extends TsDsl<ts.Node> {
3991
3992
  toAst(): ts.Node;
3992
3993
  }
3993
3994
  //#endregion
3995
+ //#region src/ts-dsl/expr/template.d.ts
3996
+ type TemplatePart = NodeName | MaybeTsDsl<ts.Expression>;
3997
+ declare const Mixed$37: abstract new () => TsDsl<ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral>;
3998
+ declare class TemplateTsDsl extends Mixed$37 {
3999
+ readonly '~dsl' = "TemplateTsDsl";
4000
+ protected parts: Array<Ref<TemplatePart>>;
4001
+ constructor(value?: TemplatePart);
4002
+ analyze(ctx: AnalysisContext): void;
4003
+ add(value: TemplatePart): this;
4004
+ toAst(): ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral;
4005
+ }
4006
+ //#endregion
3994
4007
  //#region src/ts-dsl/type/param.d.ts
3995
- type TypeParamExpr = NodeName$1 | boolean | MaybeTsDsl<TypeTsDsl>;
3996
- declare const Mixed$37: abstract new () => TsDsl<ts.TypeParameterDeclaration>;
3997
- declare class TypeParamTsDsl extends Mixed$37 {
4008
+ type TypeParamExpr = NodeName | boolean | MaybeTsDsl<TypeTsDsl>;
4009
+ declare const Mixed$36: abstract new () => TsDsl<ts.TypeParameterDeclaration>;
4010
+ declare class TypeParamTsDsl extends Mixed$36 {
3998
4011
  readonly '~dsl' = "TypeParamTsDsl";
3999
4012
  scope: NodeScope;
4000
4013
  protected constraint?: Ref<TypeParamExpr>;
4001
4014
  protected defaultValue?: Ref<TypeParamExpr>;
4002
- constructor(name?: NodeName$1, fn?: (name: TypeParamTsDsl) => void);
4015
+ constructor(name?: NodeName, fn?: (name: TypeParamTsDsl) => void);
4003
4016
  analyze(ctx: AnalysisContext): void;
4004
4017
  default(value: TypeParamExpr): this;
4005
4018
  extends(constraint: TypeParamExpr): this;
@@ -4013,7 +4026,7 @@ interface TypeParamsMethods extends Node {
4013
4026
  /** Adds a single type parameter (e.g. `T` in `Array<T>`). */
4014
4027
  generic(...args: ConstructorParameters<typeof TypeParamTsDsl>): this;
4015
4028
  /** Adds type parameters (e.g. `Map<string, T>`). */
4016
- generics(...args: ReadonlyArray<NodeName$1 | MaybeTsDsl<TypeParamTsDsl>>): this;
4029
+ generics(...args: ReadonlyArray<NodeName | MaybeTsDsl<TypeParamTsDsl>>): this;
4017
4030
  }
4018
4031
  //#endregion
4019
4032
  //#region src/ts-dsl/mixins/modifiers.d.ts
@@ -4130,7 +4143,7 @@ interface DecoratorMethods extends Node {
4130
4143
  /** Renders the decorators into an array of `ts.Decorator`s. */
4131
4144
  $decorators(): ReadonlyArray<ts.Decorator>;
4132
4145
  /** Adds a decorator (e.g. `@sealed({ in: 'root' })`). */
4133
- decorator(name: NodeName$1 | MaybeTsDsl<ts.Expression>, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>): this;
4146
+ decorator(name: NodeName | MaybeTsDsl<ts.Expression>, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>): this;
4134
4147
  }
4135
4148
  //#endregion
4136
4149
  //#region src/ts-dsl/mixins/value.d.ts
@@ -4142,13 +4155,13 @@ interface ValueMethods extends Node {
4142
4155
  }
4143
4156
  //#endregion
4144
4157
  //#region src/ts-dsl/decl/field.d.ts
4145
- type FieldType = NodeName$1 | TypeTsDsl;
4146
- 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>;
4147
- declare class FieldTsDsl extends Mixed$36 {
4158
+ type FieldType = NodeName | TypeTsDsl;
4159
+ 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>;
4160
+ declare class FieldTsDsl extends Mixed$35 {
4148
4161
  readonly '~dsl' = "FieldTsDsl";
4149
4162
  readonly nameSanitizer: (name: string) => string;
4150
4163
  protected _type?: TypeTsDsl;
4151
- constructor(name: NodeName$1, fn?: (f: FieldTsDsl) => void);
4164
+ constructor(name: NodeName, fn?: (f: FieldTsDsl) => void);
4152
4165
  analyze(ctx: AnalysisContext): void;
4153
4166
  /** Sets the field type. */
4154
4167
  type(type: FieldType): this;
@@ -4168,12 +4181,12 @@ interface PatternMethods extends Node {
4168
4181
  }
4169
4182
  //#endregion
4170
4183
  //#region src/ts-dsl/decl/param.d.ts
4171
- type ParamCtor = (name: NodeName$1 | ((p: ParamTsDsl) => void), fn?: (p: ParamTsDsl) => void) => ParamTsDsl;
4172
- declare const Mixed$35: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ParameterDeclaration>, ValueMethods>, PatternMethods>, OptionalMethods>, DecoratorMethods>;
4173
- declare class ParamTsDsl extends Mixed$35 {
4184
+ type ParamCtor = (name: NodeName | ((p: ParamTsDsl) => void), fn?: (p: ParamTsDsl) => void) => ParamTsDsl;
4185
+ declare const Mixed$34: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ParameterDeclaration>, ValueMethods>, PatternMethods>, OptionalMethods>, DecoratorMethods>;
4186
+ declare class ParamTsDsl extends Mixed$34 {
4174
4187
  readonly '~dsl' = "ParamTsDsl";
4175
4188
  protected _type?: TypeTsDsl;
4176
- constructor(name: NodeName$1 | ((p: ParamTsDsl) => void), fn?: (p: ParamTsDsl) => void);
4189
+ constructor(name: NodeName | ((p: ParamTsDsl) => void), fn?: (p: ParamTsDsl) => void);
4177
4190
  analyze(ctx: AnalysisContext): void;
4178
4191
  /** Sets the parameter type. */
4179
4192
  type(type: string | TypeTsDsl): this;
@@ -4191,8 +4204,8 @@ interface ParamMethods extends Node {
4191
4204
  }
4192
4205
  //#endregion
4193
4206
  //#region src/ts-dsl/decl/init.d.ts
4194
- declare const Mixed$34: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ConstructorDeclaration>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>;
4195
- declare class InitTsDsl extends Mixed$34 {
4207
+ declare const Mixed$33: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ConstructorDeclaration>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>;
4208
+ declare class InitTsDsl extends Mixed$33 {
4196
4209
  readonly '~dsl' = "InitTsDsl";
4197
4210
  constructor(fn?: (i: InitTsDsl) => void);
4198
4211
  analyze(ctx: AnalysisContext): void;
@@ -4204,41 +4217,41 @@ interface TypeReturnsMethods extends Node {
4204
4217
  /** Returns the return type node. */
4205
4218
  $returns(): ts.TypeNode | undefined;
4206
4219
  /** Sets the return type. */
4207
- returns(type: NodeName$1 | TypeTsDsl): this;
4220
+ returns(type: NodeName | TypeTsDsl): this;
4208
4221
  }
4209
4222
  //#endregion
4210
4223
  //#region src/ts-dsl/decl/method.d.ts
4211
- 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>;
4212
- declare class MethodTsDsl extends Mixed$33 {
4224
+ 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>;
4225
+ declare class MethodTsDsl extends Mixed$32 {
4213
4226
  readonly '~dsl' = "MethodTsDsl";
4214
4227
  readonly nameSanitizer: (name: string) => string;
4215
- constructor(name: NodeName$1, fn?: (m: MethodTsDsl) => void);
4228
+ constructor(name: NodeName, fn?: (m: MethodTsDsl) => void);
4216
4229
  analyze(ctx: AnalysisContext): void;
4217
4230
  toAst(): ts.MethodDeclaration;
4218
4231
  }
4219
4232
  //#endregion
4220
4233
  //#region src/ts-dsl/decl/class.d.ts
4221
4234
  type Body = Array<MaybeTsDsl<ts.ClassElement | ts.Node>>;
4222
- declare const Mixed$32: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ClassDeclaration>, TypeParamsMethods>, ExportMethods>, DocMethods>, DefaultMethods>, DecoratorMethods>, AbstractMethods>;
4223
- declare class ClassTsDsl extends Mixed$32 {
4235
+ declare const Mixed$31: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ClassDeclaration>, TypeParamsMethods>, ExportMethods>, DocMethods>, DefaultMethods>, DecoratorMethods>, AbstractMethods>;
4236
+ declare class ClassTsDsl extends Mixed$31 {
4224
4237
  readonly '~dsl' = "ClassTsDsl";
4225
4238
  readonly nameSanitizer: (name: string) => string;
4226
- protected baseClass?: Ref<NodeName$1>;
4239
+ protected baseClass?: Ref<NodeName>;
4227
4240
  protected body: Body;
4228
- constructor(name: NodeName$1);
4241
+ constructor(name: NodeName);
4229
4242
  analyze(ctx: AnalysisContext): void;
4230
4243
  /** Returns true if the class has any members. */
4231
4244
  get hasBody(): boolean;
4232
4245
  /** Adds one or more class members (fields, methods, etc.). */
4233
4246
  do(...items: Body): this;
4234
4247
  /** Records a base class to extend from. */
4235
- extends(base?: NodeName$1): this;
4248
+ extends(base?: NodeName): this;
4236
4249
  /** Adds a class field. */
4237
- field(name: NodeName$1, fn?: (f: FieldTsDsl) => void): this;
4250
+ field(name: NodeName, fn?: (f: FieldTsDsl) => void): this;
4238
4251
  /** Adds a class constructor. */
4239
4252
  init(fn?: InitTsDsl | ((i: InitTsDsl) => void)): this;
4240
4253
  /** Adds a class method. */
4241
- method(name: NodeName$1, fn?: (m: MethodTsDsl) => void): this;
4254
+ method(name: NodeName, fn?: (m: MethodTsDsl) => void): this;
4242
4255
  /** Inserts an empty line between members for formatting. */
4243
4256
  newline(): this;
4244
4257
  toAst(): ts.ClassDeclaration;
@@ -4247,11 +4260,11 @@ declare class ClassTsDsl extends Mixed$32 {
4247
4260
  }
4248
4261
  //#endregion
4249
4262
  //#region src/ts-dsl/decl/decorator.d.ts
4250
- declare const Mixed$31: MixinCtor<abstract new () => TsDsl<ts.Decorator>, ArgsMethods>;
4251
- declare class DecoratorTsDsl extends Mixed$31 {
4263
+ declare const Mixed$30: MixinCtor<abstract new () => TsDsl<ts.Decorator>, ArgsMethods>;
4264
+ declare class DecoratorTsDsl extends Mixed$30 {
4252
4265
  readonly '~dsl' = "DecoratorTsDsl";
4253
4266
  readonly nameSanitizer: (name: string) => string;
4254
- constructor(name: NodeName$1, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>);
4267
+ constructor(name: NodeName, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>);
4255
4268
  analyze(ctx: AnalysisContext): void;
4256
4269
  toAst(): ts.Decorator;
4257
4270
  }
@@ -4259,11 +4272,11 @@ declare class DecoratorTsDsl extends Mixed$31 {
4259
4272
  //#region src/ts-dsl/decl/member.d.ts
4260
4273
  type Value$2 = string | number | MaybeTsDsl<ts.Expression>;
4261
4274
  type ValueFn$1 = Value$2 | ((m: EnumMemberTsDsl) => void);
4262
- declare const Mixed$30: MixinCtor<abstract new () => TsDsl<ts.EnumMember>, DocMethods>;
4263
- declare class EnumMemberTsDsl extends Mixed$30 {
4275
+ declare const Mixed$29: MixinCtor<abstract new () => TsDsl<ts.EnumMember>, DocMethods>;
4276
+ declare class EnumMemberTsDsl extends Mixed$29 {
4264
4277
  readonly '~dsl' = "EnumMemberTsDsl";
4265
4278
  private _value?;
4266
- constructor(name: NodeName$1, value?: ValueFn$1);
4279
+ constructor(name: NodeName, value?: ValueFn$1);
4267
4280
  analyze(ctx: AnalysisContext): void;
4268
4281
  /** Sets the enum member value. */
4269
4282
  value(value?: Value$2): this;
@@ -4273,12 +4286,12 @@ declare class EnumMemberTsDsl extends Mixed$30 {
4273
4286
  //#region src/ts-dsl/decl/enum.d.ts
4274
4287
  type Value$1 = string | number | MaybeTsDsl<ts.Expression>;
4275
4288
  type ValueFn = Value$1 | ((m: EnumMemberTsDsl) => void);
4276
- declare const Mixed$29: MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.EnumDeclaration>, ExportMethods>, DocMethods>, ConstMethods>;
4277
- declare class EnumTsDsl extends Mixed$29 {
4289
+ declare const Mixed$28: MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.EnumDeclaration>, ExportMethods>, DocMethods>, ConstMethods>;
4290
+ declare class EnumTsDsl extends Mixed$28 {
4278
4291
  readonly '~dsl' = "EnumTsDsl";
4279
4292
  readonly nameSanitizer: (name: string) => string;
4280
4293
  private _members;
4281
- constructor(name: NodeName$1, fn?: (e: EnumTsDsl) => void);
4294
+ constructor(name: NodeName, fn?: (e: EnumTsDsl) => void);
4282
4295
  analyze(ctx: AnalysisContext): void;
4283
4296
  /** Adds an enum member. */
4284
4297
  member(name: string, value?: ValueFn): this;
@@ -4289,15 +4302,15 @@ declare class EnumTsDsl extends Mixed$29 {
4289
4302
  //#endregion
4290
4303
  //#region src/ts-dsl/decl/func.d.ts
4291
4304
  type FuncMode = 'arrow' | 'decl' | 'expr';
4292
- 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>;
4293
- declare class ImplFuncTsDsl<M extends FuncMode = 'arrow'> extends Mixed$28 {
4305
+ 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>;
4306
+ declare class ImplFuncTsDsl<M extends FuncMode = 'arrow'> extends Mixed$27 {
4294
4307
  readonly '~dsl' = "FuncTsDsl";
4295
4308
  readonly nameSanitizer: (name: string) => string;
4296
4309
  protected mode?: FuncMode;
4297
4310
  constructor();
4298
4311
  constructor(fn: (f: ImplFuncTsDsl<'arrow'>) => void);
4299
- constructor(name: NodeName$1);
4300
- constructor(name: NodeName$1, fn: (f: ImplFuncTsDsl<'decl'>) => void);
4312
+ constructor(name: NodeName);
4313
+ constructor(name: NodeName, fn: (f: ImplFuncTsDsl<'decl'>) => void);
4301
4314
  analyze(ctx: AnalysisContext): void;
4302
4315
  /** Switches the function to an arrow function form. */
4303
4316
  arrow(): FuncTsDsl<'arrow'>;
@@ -4310,27 +4323,27 @@ declare class ImplFuncTsDsl<M extends FuncMode = 'arrow'> extends Mixed$28 {
4310
4323
  declare const FuncTsDsl: {
4311
4324
  new (): FuncTsDsl<"arrow">;
4312
4325
  new (fn: (f: FuncTsDsl<"arrow">) => void): FuncTsDsl<"arrow">;
4313
- new (name: NodeName$1): FuncTsDsl<"decl">;
4314
- new (name: NodeName$1, fn: (f: FuncTsDsl<"decl">) => void): FuncTsDsl<"decl">;
4326
+ new (name: NodeName): FuncTsDsl<"decl">;
4327
+ new (name: NodeName, fn: (f: FuncTsDsl<"decl">) => void): FuncTsDsl<"decl">;
4315
4328
  } & typeof ImplFuncTsDsl;
4316
4329
  type FuncTsDsl<M extends FuncMode = 'arrow'> = ImplFuncTsDsl<M>;
4317
4330
  //#endregion
4318
4331
  //#region src/ts-dsl/decl/getter.d.ts
4319
- 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>;
4320
- declare class GetterTsDsl extends Mixed$27 {
4332
+ 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>;
4333
+ declare class GetterTsDsl extends Mixed$26 {
4321
4334
  readonly '~dsl' = "GetterTsDsl";
4322
4335
  readonly nameSanitizer: (name: string) => string;
4323
- constructor(name: NodeName$1, fn?: (g: GetterTsDsl) => void);
4336
+ constructor(name: NodeName, fn?: (g: GetterTsDsl) => void);
4324
4337
  analyze(ctx: AnalysisContext): void;
4325
4338
  toAst(): ts.GetAccessorDeclaration;
4326
4339
  }
4327
4340
  //#endregion
4328
4341
  //#region src/ts-dsl/decl/pattern.d.ts
4329
- declare const Mixed$26: abstract new () => TsDsl<ts.BindingName>;
4342
+ declare const Mixed$25: abstract new () => TsDsl<ts.BindingName>;
4330
4343
  /**
4331
4344
  * Builds binding patterns (e.g. `{ foo, bar }`, `[a, b, ...rest]`).
4332
4345
  */
4333
- declare class PatternTsDsl extends Mixed$26 {
4346
+ declare class PatternTsDsl extends Mixed$25 {
4334
4347
  readonly '~dsl' = "PatternTsDsl";
4335
4348
  protected pattern?: {
4336
4349
  kind: 'array';
@@ -4352,11 +4365,11 @@ declare class PatternTsDsl extends Mixed$26 {
4352
4365
  }
4353
4366
  //#endregion
4354
4367
  //#region src/ts-dsl/decl/setter.d.ts
4355
- 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>;
4356
- declare class SetterTsDsl extends Mixed$25 {
4368
+ 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>;
4369
+ declare class SetterTsDsl extends Mixed$24 {
4357
4370
  readonly '~dsl' = "SetterTsDsl";
4358
4371
  readonly nameSanitizer: (name: string) => string;
4359
- constructor(name: NodeName$1, fn?: (s: SetterTsDsl) => void);
4372
+ constructor(name: NodeName, fn?: (s: SetterTsDsl) => void);
4360
4373
  analyze(ctx: AnalysisContext): void;
4361
4374
  toAst(): ts.SetAccessorDeclaration;
4362
4375
  }
@@ -4374,8 +4387,8 @@ interface LayoutMethods extends Node {
4374
4387
  }
4375
4388
  //#endregion
4376
4389
  //#region src/ts-dsl/expr/array.d.ts
4377
- declare const Mixed$24: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ArrayLiteralExpression>, LayoutMethods>, AsMethods>;
4378
- declare class ArrayTsDsl extends Mixed$24 {
4390
+ declare const Mixed$23: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ArrayLiteralExpression>, LayoutMethods>, AsMethods>;
4391
+ declare class ArrayTsDsl extends Mixed$23 {
4379
4392
  readonly '~dsl' = "ArrayTsDsl";
4380
4393
  protected _elements: Array<{
4381
4394
  expr: MaybeTsDsl<ts.Expression>;
@@ -4396,19 +4409,19 @@ declare class ArrayTsDsl extends Mixed$24 {
4396
4409
  }
4397
4410
  //#endregion
4398
4411
  //#region src/ts-dsl/expr/expr.d.ts
4399
- type Id = NodeName$1 | MaybeTsDsl<ts.Expression>;
4400
- declare const Mixed$23: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.Expression>, TypeExprMethods>, OperatorMethods>, ExprMethods>, AsMethods>;
4401
- declare class ExprTsDsl extends Mixed$23 {
4412
+ type Id = NodeName | MaybeTsDsl<ts.Expression>;
4413
+ declare const Mixed$22: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.Expression>, TypeExprMethods>, OperatorMethods>, ExprMethods>, AsMethods>;
4414
+ declare class ExprTsDsl extends Mixed$22 {
4402
4415
  readonly '~dsl' = "ExprTsDsl";
4403
4416
  protected _exprInput: Ref<Id>;
4404
4417
  constructor(id: Id);
4405
4418
  analyze(ctx: AnalysisContext): void;
4406
- toAst(): any;
4419
+ toAst(): ts.Expression;
4407
4420
  }
4408
4421
  //#endregion
4409
4422
  //#region src/ts-dsl/expr/id.d.ts
4410
- declare const Mixed$22: abstract new () => TsDsl<ts.Identifier>;
4411
- declare class IdTsDsl extends Mixed$22 {
4423
+ declare const Mixed$21: abstract new () => TsDsl<ts.Identifier>;
4424
+ declare class IdTsDsl extends Mixed$21 {
4412
4425
  readonly '~dsl' = "IdTsDsl";
4413
4426
  constructor(name: string);
4414
4427
  analyze(ctx: AnalysisContext): void;
@@ -4422,8 +4435,8 @@ interface HintMethods extends Node {
4422
4435
  }
4423
4436
  //#endregion
4424
4437
  //#region src/ts-dsl/expr/prop.d.ts
4425
- type Expr$1 = NodeName$1 | MaybeTsDsl<ts.Expression>;
4426
- type Stmt$1 = NodeName$1 | MaybeTsDsl<ts.Statement>;
4438
+ type Expr$1 = NodeName | MaybeTsDsl<ts.Expression>;
4439
+ type Stmt$1 = NodeName | MaybeTsDsl<ts.Statement>;
4427
4440
  type ObjectPropKind = 'computed' | 'getter' | 'prop' | 'setter' | 'spread';
4428
4441
  type Meta = {
4429
4442
  kind: 'computed';
@@ -4441,8 +4454,8 @@ type Meta = {
4441
4454
  kind: 'spread';
4442
4455
  name?: undefined;
4443
4456
  };
4444
- declare const Mixed$21: MixinCtor<abstract new () => TsDsl<ts.ObjectLiteralElementLike>, DocMethods>;
4445
- declare class ObjectPropTsDsl extends Mixed$21 {
4457
+ declare const Mixed$20: MixinCtor<abstract new () => TsDsl<ts.ObjectLiteralElementLike>, DocMethods>;
4458
+ declare class ObjectPropTsDsl extends Mixed$20 {
4446
4459
  readonly '~dsl' = "ObjectPropTsDsl";
4447
4460
  protected _value?: Ref<Expr$1 | Stmt$1>;
4448
4461
  protected _meta: Meta;
@@ -4452,7 +4465,7 @@ declare class ObjectPropTsDsl extends Mixed$21 {
4452
4465
  analyze(ctx: AnalysisContext): void;
4453
4466
  get isValid(): boolean;
4454
4467
  value(value: Expr$1 | Stmt$1 | ((p: ObjectPropTsDsl) => void)): this;
4455
- toAst(): any;
4468
+ toAst(): ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ts.PropertyAssignment | ts.ShorthandPropertyAssignment | ts.SpreadAssignment;
4456
4469
  $validate(): asserts this is this & {
4457
4470
  _value: Expr$1 | Stmt$1;
4458
4471
  kind: ObjectPropKind;
@@ -4461,12 +4474,12 @@ declare class ObjectPropTsDsl extends Mixed$21 {
4461
4474
  }
4462
4475
  //#endregion
4463
4476
  //#region src/ts-dsl/expr/object.d.ts
4464
- type Expr = NodeName$1 | MaybeTsDsl<ts.Expression>;
4465
- type Stmt = NodeName$1 | MaybeTsDsl<ts.Statement>;
4477
+ type Expr = NodeName | MaybeTsDsl<ts.Expression>;
4478
+ type Stmt = NodeName | MaybeTsDsl<ts.Statement>;
4466
4479
  type ExprFn = Expr | ((p: ObjectPropTsDsl) => void);
4467
4480
  type StmtFn = Stmt | ((p: ObjectPropTsDsl) => void);
4468
- declare const Mixed$20: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ObjectLiteralExpression>, LayoutMethods>, HintMethods>, ExprMethods>, AsMethods>;
4469
- declare class ObjectTsDsl extends Mixed$20 {
4481
+ declare const Mixed$19: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ObjectLiteralExpression>, LayoutMethods>, HintMethods>, ExprMethods>, AsMethods>;
4482
+ declare class ObjectTsDsl extends Mixed$19 {
4470
4483
  readonly '~dsl' = "ObjectTsDsl";
4471
4484
  protected _props: Map<string, ObjectPropTsDsl>;
4472
4485
  protected _spreadCounter: number;
@@ -4494,8 +4507,8 @@ declare class ObjectTsDsl extends Mixed$20 {
4494
4507
  }
4495
4508
  //#endregion
4496
4509
  //#region src/ts-dsl/expr/prefix.d.ts
4497
- declare const Mixed$19: abstract new () => TsDsl<ts.PrefixUnaryExpression>;
4498
- declare class PrefixTsDsl extends Mixed$19 {
4510
+ declare const Mixed$18: abstract new () => TsDsl<ts.PrefixUnaryExpression>;
4511
+ declare class PrefixTsDsl extends Mixed$18 {
4499
4512
  readonly '~dsl' = "PrefixTsDsl";
4500
4513
  protected _expr?: string | MaybeTsDsl<ts.Expression>;
4501
4514
  protected _op?: ts.PrefixUnaryOperator;
@@ -4515,8 +4528,8 @@ declare class PrefixTsDsl extends Mixed$19 {
4515
4528
  //#region src/ts-dsl/expr/regexp.d.ts
4516
4529
  type RegexFlag = 'g' | 'i' | 'm' | 's' | 'u' | 'y';
4517
4530
  type RegexFlags<Avail extends string = RegexFlag> = '' | { [K in Avail]: `${K}${RegexFlags<Exclude<Avail, K>>}` }[Avail];
4518
- declare const Mixed$18: abstract new () => TsDsl<ts.RegularExpressionLiteral>;
4519
- declare class RegExpTsDsl extends Mixed$18 {
4531
+ declare const Mixed$17: abstract new () => TsDsl<ts.RegularExpressionLiteral>;
4532
+ declare class RegExpTsDsl extends Mixed$17 {
4520
4533
  readonly '~dsl' = "RegExpTsDsl";
4521
4534
  protected pattern: string;
4522
4535
  protected flags?: RegexFlags;
@@ -4525,18 +4538,6 @@ declare class RegExpTsDsl extends Mixed$18 {
4525
4538
  toAst(): ts.RegularExpressionLiteral;
4526
4539
  }
4527
4540
  //#endregion
4528
- //#region src/ts-dsl/expr/template.d.ts
4529
- type TemplatePart = NodeName$1 | MaybeTsDsl<ts.Expression>;
4530
- declare const Mixed$17: abstract new () => TsDsl<ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral>;
4531
- declare class TemplateTsDsl extends Mixed$17 {
4532
- readonly '~dsl' = "TemplateTsDsl";
4533
- protected parts: Array<Ref<TemplatePart>>;
4534
- constructor(value?: TemplatePart);
4535
- analyze(ctx: AnalysisContext): void;
4536
- add(value: TemplatePart): this;
4537
- toAst(): ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral;
4538
- }
4539
- //#endregion
4540
4541
  //#region src/ts-dsl/expr/ternary.d.ts
4541
4542
  declare const Mixed$16: abstract new () => TsDsl<ts.ConditionalExpression>;
4542
4543
  declare class TernaryTsDsl extends Mixed$16 {
@@ -4596,13 +4597,13 @@ declare const Mixed$12: abstract new () => TsDsl<ts.TryStatement>;
4596
4597
  declare class TryTsDsl extends Mixed$12 {
4597
4598
  readonly '~dsl' = "TryTsDsl";
4598
4599
  protected _catch?: Array<DoExpr>;
4599
- protected _catchArg?: NodeName$1;
4600
+ protected _catchArg?: NodeName;
4600
4601
  protected _finally?: Array<DoExpr>;
4601
4602
  protected _try?: Array<DoExpr>;
4602
4603
  constructor(...tryBlock: Array<DoExpr>);
4603
4604
  analyze(ctx: AnalysisContext): void;
4604
4605
  catch(...items: Array<DoExpr>): this;
4605
- catchArg(arg: NodeName$1): this;
4606
+ catchArg(arg: NodeName): this;
4606
4607
  finally(...items: Array<DoExpr>): this;
4607
4608
  try(...items: Array<DoExpr>): this;
4608
4609
  toAst(): ts.TryStatement;
@@ -4615,7 +4616,7 @@ declare class VarTsDsl extends Mixed$11 {
4615
4616
  readonly nameSanitizer: (name: string) => string;
4616
4617
  protected kind: ts.NodeFlags;
4617
4618
  protected _type?: TypeTsDsl;
4618
- constructor(name?: NodeName$1);
4619
+ constructor(name?: NodeName);
4619
4620
  analyze(ctx: AnalysisContext): void;
4620
4621
  const(): this;
4621
4622
  let(): this;
@@ -4654,7 +4655,7 @@ declare class TypeAliasTsDsl extends Mixed$10 {
4654
4655
  readonly nameSanitizer: (name: string) => string;
4655
4656
  scope: NodeScope;
4656
4657
  protected value?: Value;
4657
- constructor(name: NodeName$1, fn?: (t: TypeAliasTsDsl) => void);
4658
+ constructor(name: NodeName, fn?: (t: TypeAliasTsDsl) => void);
4658
4659
  analyze(ctx: AnalysisContext): void;
4659
4660
  /** Sets the type expression on the right-hand side of `= ...`. */
4660
4661
  type(node: Value): this;
@@ -4662,7 +4663,7 @@ declare class TypeAliasTsDsl extends Mixed$10 {
4662
4663
  }
4663
4664
  //#endregion
4664
4665
  //#region src/ts-dsl/type/and.d.ts
4665
- type Type$1 = NodeName$1 | ts.TypeNode | TypeTsDsl;
4666
+ type Type$1 = NodeName | ts.TypeNode | TypeTsDsl;
4666
4667
  declare const Mixed$9: abstract new () => TsDsl<ts.IntersectionTypeNode>;
4667
4668
  declare class TypeAndTsDsl extends Mixed$9 {
4668
4669
  readonly '~dsl' = "TypeAndTsDsl";
@@ -4703,7 +4704,7 @@ declare class TypeMappedTsDsl extends Mixed$6 {
4703
4704
  protected readonlyToken?: TokenTsDsl<ts.SyntaxKind.ReadonlyKeyword | ts.SyntaxKind.MinusToken | ts.SyntaxKind.PlusToken>;
4704
4705
  protected _key?: string | MaybeTsDsl<ts.TypeNode>;
4705
4706
  protected _type?: string | MaybeTsDsl<ts.TypeNode>;
4706
- constructor(name?: NodeName$1);
4707
+ constructor(name?: NodeName);
4707
4708
  analyze(ctx: AnalysisContext): void;
4708
4709
  /** Returns true when all required builder calls are present. */
4709
4710
  get isValid(): boolean;
@@ -4736,7 +4737,7 @@ declare class TypeIdxSigTsDsl extends Mixed$5 {
4736
4737
  scope: NodeScope;
4737
4738
  protected _key?: TypeIdxSigType;
4738
4739
  protected _type?: TypeIdxSigType;
4739
- constructor(name: NodeName$1, fn?: (i: TypeIdxSigTsDsl) => void);
4740
+ constructor(name: NodeName, fn?: (i: TypeIdxSigTsDsl) => void);
4740
4741
  /** Element kind. */
4741
4742
  get kind(): TypeIdxSigKind;
4742
4743
  /** Index signature parameter name. */
@@ -4757,14 +4758,14 @@ declare class TypeIdxSigTsDsl extends Mixed$5 {
4757
4758
  }
4758
4759
  //#endregion
4759
4760
  //#region src/ts-dsl/type/prop.d.ts
4760
- type TypePropType = NodeName$1 | MaybeTsDsl<ts.TypeNode>;
4761
+ type TypePropType = NodeName | MaybeTsDsl<ts.TypeNode>;
4761
4762
  type TypePropKind = 'prop';
4762
4763
  declare const Mixed$4: MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.TypeElement>, ReadonlyMethods>, OptionalMethods>, DocMethods>;
4763
4764
  declare class TypePropTsDsl extends Mixed$4 {
4764
4765
  readonly '~dsl' = "TypePropTsDsl";
4765
4766
  scope: NodeScope;
4766
4767
  protected _type?: Ref<TypePropType>;
4767
- constructor(name: NodeName$1, fn: (p: TypePropTsDsl) => void);
4768
+ constructor(name: NodeName, fn: (p: TypePropTsDsl) => void);
4768
4769
  /** Element kind. */
4769
4770
  get kind(): TypePropKind;
4770
4771
  /** Property name. */
@@ -4796,7 +4797,7 @@ declare class TypeObjectTsDsl extends Mixed$3 {
4796
4797
  }
4797
4798
  //#endregion
4798
4799
  //#region src/ts-dsl/type/or.d.ts
4799
- type Type = NodeName$1 | ts.TypeNode | TypeTsDsl;
4800
+ type Type = NodeName | ts.TypeNode | TypeTsDsl;
4800
4801
  declare const Mixed$2: abstract new () => TsDsl<ts.UnionTypeNode>;
4801
4802
  declare class TypeOrTsDsl extends Mixed$2 {
4802
4803
  readonly '~dsl' = "TypeOrTsDsl";
@@ -4963,35 +4964,35 @@ declare const reserved: {
4963
4964
  };
4964
4965
  //#endregion
4965
4966
  //#region src/ts-dsl/index.d.ts
4966
- declare const $: ((id: any) => ExprTsDsl) & {
4967
+ declare const $: ((id: ts.Expression | TsDsl<ts.Expression> | _hey_api_codegen_core0.NodeName) => ExprTsDsl) & {
4967
4968
  /** Creates an array literal expression (e.g. `[1, 2, 3]`). */
4968
4969
  array: (...args: ConstructorParameters<typeof ArrayTsDsl>) => ArrayTsDsl;
4969
4970
  /** Creates an `as` type assertion expression (e.g. `value as Type`). */
4970
- as: (expr: any, type: any) => AsTsDsl;
4971
+ as: (expr: AsExpr, type: AsType) => AsTsDsl;
4971
4972
  /** Creates a property access expression (e.g. `obj.foo`). */
4972
- attr: (left: any, right: NodeName) => AttrTsDsl;
4973
+ attr: (left: AttrLeft, right: _hey_api_codegen_core0.NodeName) => AttrTsDsl;
4973
4974
  /** Creates an await expression (e.g. `await promise`). */
4974
- await: (expr: any) => AwaitTsDsl;
4975
+ await: (expr: AwaitExpr) => AwaitTsDsl;
4975
4976
  /** Creates a binary expression (e.g. `a + b`). */
4976
- binary: (base: any, op?: (("!=" | "!==" | "&&" | "*" | "+" | "-" | "/" | "<" | "<=" | "=" | "==" | "===" | ">" | ">=" | "??" | "??=" | "||") | ts.BinaryOperator) | undefined, expr?: any) => BinaryTsDsl;
4977
+ 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;
4977
4978
  /** Creates a statement block (`{ ... }`). */
4978
4979
  block: (...args: ConstructorParameters<typeof BlockTsDsl>) => BlockTsDsl;
4979
4980
  /** Creates a function or method call expression (e.g. `fn(arg)`). */
4980
- call: (expr: any, ...args: any[]) => CallTsDsl;
4981
+ call: (expr: CallExpr, ...args: (CallExpr | undefined)[]) => CallTsDsl;
4981
4982
  /** Creates a class declaration or expression. */
4982
- class: (name: NodeName) => ClassTsDsl;
4983
+ class: (name: _hey_api_codegen_core0.NodeName) => ClassTsDsl;
4983
4984
  /** Creates a constant variable declaration (`const`). */
4984
- const: (name?: any) => VarTsDsl;
4985
+ const: (name?: _hey_api_codegen_core0.NodeName | undefined) => VarTsDsl;
4985
4986
  /** Creates a decorator expression (e.g. `@decorator`). */
4986
- decorator: (name: NodeName, ...args: (string | ts.Expression | TsDsl<ts.Expression>)[]) => DecoratorTsDsl;
4987
+ decorator: (name: _hey_api_codegen_core0.NodeName, ...args: (string | ts.Expression | TsDsl<ts.Expression>)[]) => DecoratorTsDsl;
4987
4988
  /** Creates a JSDoc documentation block. */
4988
4989
  doc: (lines?: DocLines | undefined, fn?: DocFn | undefined) => DocTsDsl;
4989
4990
  /** Creates an enum declaration. */
4990
- enum: (name: NodeName, fn?: ((e: EnumTsDsl) => void) | undefined) => EnumTsDsl;
4991
+ enum: (name: _hey_api_codegen_core0.NodeName, fn?: ((e: EnumTsDsl) => void) | undefined) => EnumTsDsl;
4991
4992
  /** Creates a general expression node. */
4992
- expr: (id: any) => ExprTsDsl;
4993
+ expr: (id: ts.Expression | TsDsl<ts.Expression> | _hey_api_codegen_core0.NodeName) => ExprTsDsl;
4993
4994
  /** Creates a field declaration in a class or object. */
4994
- field: (name: NodeName, fn?: ((f: FieldTsDsl) => void) | undefined) => FieldTsDsl;
4995
+ field: (name: _hey_api_codegen_core0.NodeName, fn?: ((f: FieldTsDsl) => void) | undefined) => FieldTsDsl;
4995
4996
  /** Converts a runtime value into a corresponding expression node. */
4996
4997
  fromValue: (input: unknown, options?: {
4997
4998
  layout?: "pretty";
@@ -5005,7 +5006,7 @@ declare const $: ((id: any) => ExprTsDsl) & {
5005
5006
  (name?: string, fn?: (f: FuncTsDsl<"decl">) => void): FuncTsDsl<"arrow"> | FuncTsDsl<"decl">;
5006
5007
  };
5007
5008
  /** Creates a getter method declaration. */
5008
- getter: (name: NodeName, fn?: ((g: GetterTsDsl) => void) | undefined) => GetterTsDsl;
5009
+ getter: (name: _hey_api_codegen_core0.NodeName, fn?: ((g: GetterTsDsl) => void) | undefined) => GetterTsDsl;
5009
5010
  /** Creates a single-line comment (//). */
5010
5011
  hint: (lines?: HintLines | undefined, fn?: HintFn | undefined) => HintTsDsl;
5011
5012
  /** Creates an identifier (e.g. `foo`). */
@@ -5017,17 +5018,17 @@ declare const $: ((id: any) => ExprTsDsl) & {
5017
5018
  /** Creates a lazy, context-aware node with deferred evaluation. */
5018
5019
  lazy: <T extends ts.Node>(thunk: LazyThunk<T>) => LazyTsDsl<T>;
5019
5020
  /** Creates a let variable declaration (`let`). */
5020
- let: (name?: any) => VarTsDsl;
5021
+ let: (name?: _hey_api_codegen_core0.NodeName | undefined) => VarTsDsl;
5021
5022
  /** Creates a literal value (e.g. string, number, boolean). */
5022
5023
  literal: (value: LiteralValue) => LiteralTsDsl;
5023
5024
  /** Creates an enum member declaration. */
5024
- member: (name: NodeName, value?: ((string | number | ts.Expression | TsDsl<ts.Expression>) | ((m: EnumMemberTsDsl) => void)) | undefined) => EnumMemberTsDsl;
5025
+ member: (name: _hey_api_codegen_core0.NodeName, value?: ((string | number | ts.Expression | TsDsl<ts.Expression>) | ((m: EnumMemberTsDsl) => void)) | undefined) => EnumMemberTsDsl;
5025
5026
  /** Creates a method declaration inside a class or object. */
5026
- method: (name: NodeName, fn?: ((m: MethodTsDsl) => void) | undefined) => MethodTsDsl;
5027
+ method: (name: _hey_api_codegen_core0.NodeName, fn?: ((m: MethodTsDsl) => void) | undefined) => MethodTsDsl;
5027
5028
  /** Creates a negation expression (`-x`). */
5028
5029
  neg: (expr?: string | ts.Expression | TsDsl<ts.Expression> | undefined, op?: ts.PrefixUnaryOperator | undefined) => PrefixTsDsl;
5029
5030
  /** Creates a new expression (e.g. `new ClassName()`). */
5030
- new: (expr: any, ...args: any[]) => NewTsDsl;
5031
+ new: (expr: NewExpr, ...args: (NewExpr | undefined)[]) => NewTsDsl;
5031
5032
  /** Creates a newline (for formatting purposes). */
5032
5033
  newline: () => NewlineTsDsl;
5033
5034
  /** Creates a logical NOT expression (`!x`). */
@@ -5037,7 +5038,7 @@ declare const $: ((id: any) => ExprTsDsl) & {
5037
5038
  /** Creates an object literal expression. */
5038
5039
  object: (...args: ConstructorParameters<typeof ObjectTsDsl>) => ObjectTsDsl;
5039
5040
  /** Creates a parameter declaration for functions or methods. */
5040
- param: (name: any, fn?: ((p: ParamTsDsl) => void) | undefined) => ParamTsDsl;
5041
+ param: (name: _hey_api_codegen_core0.NodeName | ((p: ParamTsDsl) => void), fn?: ((p: ParamTsDsl) => void) | undefined) => ParamTsDsl;
5041
5042
  /** Creates a pattern for destructuring or matching. */
5042
5043
  pattern: () => PatternTsDsl;
5043
5044
  /** Creates a prefix unary expression (e.g. `-x`, `!x`, `~x`). */
@@ -5062,13 +5063,13 @@ declare const $: ((id: any) => ExprTsDsl) & {
5062
5063
  /** Creates a regular expression literal (e.g. `/foo/gi`). */
5063
5064
  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;
5064
5065
  /** Creates a return statement. */
5065
- return: (expr?: any) => ReturnTsDsl;
5066
+ return: (expr?: ReturnExpr | undefined) => ReturnTsDsl;
5066
5067
  /** Creates a setter method declaration. */
5067
- setter: (name: NodeName, fn?: ((s: SetterTsDsl) => void) | undefined) => SetterTsDsl;
5068
+ setter: (name: _hey_api_codegen_core0.NodeName, fn?: ((s: SetterTsDsl) => void) | undefined) => SetterTsDsl;
5068
5069
  /** Wraps an expression or statement-like value into a `StmtTsDsl`. */
5069
5070
  stmt: (inner: ts.Expression | ts.Statement | TsDsl<any>) => StmtTsDsl;
5070
5071
  /** Creates a template literal expression. */
5071
- template: (value?: any) => TemplateTsDsl;
5072
+ template: (value?: TemplatePart | undefined) => TemplateTsDsl;
5072
5073
  /** Creates a ternary conditional expression (if ? then : else). */
5073
5074
  ternary: (condition?: string | ts.Expression | TsDsl<ts.Expression> | undefined) => TernaryTsDsl;
5074
5075
  /** Creates a throw statement. */
@@ -5078,15 +5079,15 @@ declare const $: ((id: any) => ExprTsDsl) & {
5078
5079
  /** Creates a try/catch/finally statement. */
5079
5080
  try: (...args: ConstructorParameters<typeof TryTsDsl>) => TryTsDsl;
5080
5081
  /** Creates a basic type reference or type expression (e.g. Foo or Foo<T>). */
5081
- type: ((name: NodeName, fn?: TypeExprFn | undefined) => TypeExprTsDsl) & {
5082
+ type: ((name: _hey_api_codegen_core0.NodeName, fn?: TypeExprFn | undefined) => TypeExprTsDsl) & {
5082
5083
  /** Creates a type alias declaration (e.g. `type Foo = Bar`). */
5083
- alias: (name: NodeName, fn?: ((t: TypeAliasTsDsl) => void) | undefined) => TypeAliasTsDsl;
5084
+ alias: (name: _hey_api_codegen_core0.NodeName, fn?: ((t: TypeAliasTsDsl) => void) | undefined) => TypeAliasTsDsl;
5084
5085
  /** Creates an intersection type (e.g. `A & B`). */
5085
5086
  and: (...args: ConstructorParameters<typeof TypeAndTsDsl>) => TypeAndTsDsl;
5086
5087
  /** Creates a qualified type reference (e.g. Foo.Bar). */
5087
- attr: (right: any) => TypeAttrTsDsl;
5088
+ attr: (right: _hey_api_codegen_core0.NodeName | ts.Identifier) => TypeAttrTsDsl;
5088
5089
  /** Creates a basic type reference or type expression (e.g. Foo or Foo<T>). */
5089
- expr: (name: NodeName, fn?: TypeExprFn | undefined) => TypeExprTsDsl;
5090
+ expr: (name: _hey_api_codegen_core0.NodeName, fn?: TypeExprFn | undefined) => TypeExprTsDsl;
5090
5091
  /** Converts a runtime value into a corresponding type expression node. */
5091
5092
  fromValue: (input: unknown) => TsDsl<ts.TypeNode>;
5092
5093
  /** Creates a function type node (e.g. `(a: string) => number`). */
@@ -5096,7 +5097,7 @@ declare const $: ((id: any) => ExprTsDsl) & {
5096
5097
  /** Creates a literal type node (e.g. 'foo', 42, or true). */
5097
5098
  literal: (value: string | number | boolean | null) => TypeLiteralTsDsl;
5098
5099
  /** Creates a mapped type (e.g. `{ [K in keyof T]: U }`). */
5099
- mapped: (name?: any) => TypeMappedTsDsl;
5100
+ mapped: (name?: _hey_api_codegen_core0.NodeName | undefined) => TypeMappedTsDsl;
5100
5101
  /** Creates a type literal node (e.g. { foo: string }). */
5101
5102
  object: () => TypeObjectTsDsl;
5102
5103
  /** Creates a type operator node (e.g. `readonly T`, `keyof T`, `unique T`). */
@@ -5104,7 +5105,7 @@ declare const $: ((id: any) => ExprTsDsl) & {
5104
5105
  /** Represents a union type (e.g. `A | B | C`). */
5105
5106
  or: (...args: ConstructorParameters<typeof TypeOrTsDsl>) => TypeOrTsDsl;
5106
5107
  /** Creates a type parameter (e.g. `<T>`). */
5107
- param: (name?: any, fn?: ((name: TypeParamTsDsl) => void) | undefined) => TypeParamTsDsl;
5108
+ param: (name?: _hey_api_codegen_core0.NodeName | undefined, fn?: ((name: TypeParamTsDsl) => void) | undefined) => TypeParamTsDsl;
5108
5109
  /** Creates a type query node (e.g. `typeof Foo`). */
5109
5110
  query: (expr: TypeQueryExpr) => TypeQueryTsDsl;
5110
5111
  /** Builds a TypeScript template literal *type* (e.g. `${Foo}-${Bar}` as a type). */
@@ -5115,7 +5116,7 @@ declare const $: ((id: any) => ExprTsDsl) & {
5115
5116
  /** Creates a `typeof` expression (e.g. `typeof value`). */
5116
5117
  typeofExpr: (expr: TypeOfExpr) => TypeOfExprTsDsl;
5117
5118
  /** Creates a variable declaration (`var`). */
5118
- var: (name?: any) => VarTsDsl;
5119
+ var: (name?: _hey_api_codegen_core0.NodeName | undefined) => VarTsDsl;
5119
5120
  };
5120
5121
  type DollarTsDsl = {
5121
5122
  /**
@@ -15596,4 +15597,4 @@ type Config = Omit<Required<UserConfig>, 'input' | 'logs' | 'output' | 'parser'
15596
15597
  };
15597
15598
  //#endregion
15598
15599
  export { CallArgs as A, keywords as C, ExampleOptions as D, TypeTsDsl as E, OperationStrategy as M, Casing as N, TsDslContext as O, IR as P, regexp as S, TsDsl as T, PluginHandler as _, Plugin as a, reserved as b, OpenApiOperationObject as c, OpenApiResponseObject as d, OpenApiSchemaObject as f, Client as g, ExpressionTransformer as h, DefinePlugin as i, OperationPath as j, ctx 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, $ as v, MaybeTsDsl as w, TypeScriptRenderer as x, DollarTsDsl as y };
15599
- //# sourceMappingURL=types-WLqvV8HC.d.cts.map
15600
+ //# sourceMappingURL=types-BcLsQaJ_.d.cts.map