@hey-api/openapi-ts 0.88.2 → 0.89.1

package/dist/{config-C5xWXzTz.d.cts → config-Duuay7XM.d.cts}

@@ -1,46 +1,8 @@
-import { IProject, Project, Symbol, SymbolIdentifier, SymbolIn, SymbolMeta } from "@hey-api/codegen-core";
+import * as _hey_api_codegen_core0 from "@hey-api/codegen-core";
+import { AnalysisContext, AstContext, File, FromRef, IProject, Language, NameConflictResolver, Node, Project, Ref, Refs, RenderContext, Renderer, Symbol, SymbolIdentifier, SymbolIn, SymbolMeta } from "@hey-api/codegen-core";
 import { RangeOptions, SemVer } from "semver";
-import * as typescript0 from "typescript";
 import ts from "typescript";
 
-//#region src/plugins/shared/types/refs.d.ts
-
-/**
- * Ref wrapper which ensures a stable reference for a value.
- *
- * @example
- * ```ts
- * type NumRef = Ref<number>; // { value: number }
- * const num: NumRef = { value: 42 };
- * console.log(num.value); // 42
- * ```
- */
-type Ref<T> = {
-  value: T;
-};
-
-/**
- * Utility type: wraps a value in a Ref.
- *
- * @example
- * ```ts
- * type R = ToRef<number>; // { value: number }
- * ```
- */
-
-/**
- * Maps every property of `T` to a `Ref` of that property.
- *
- * @example
- * ```ts
- * type Foo = { a: number; b: string };
- * type Refs = ToRefs<Foo>; // { a: Ref<number>; b: Ref<string> }
- * const refs: Refs = { a: { value: 1 }, b: { value: 'x' } };
- * console.log(refs.a.value, refs.b.value); // 1 'x'
- * ```
- */
-type ToRefs<T> = { [K in keyof T]: Ref<T[K]> };
-//#endregion
 //#region src/openApi/shared/types/openapi-spec-extensions.d.ts
 interface EnumExtensions {
   /**
@@ -58,6 +20,7 @@ interface EnumExtensions {
 }
 //#endregion
 //#region src/types/utils.d.ts
+
 /**
  * Accepts a value, a function returning a value, or a function returning a promise of a value.
  */
@@ -68,12 +31,20 @@ type LazyOrAsync<T> = T | (() => T) | (() => Promise<T>);
 type MaybeArray<T> = T | ReadonlyArray<T>;
 //#endregion
 //#region src/openApi/3.1.x/types/spec.d.ts
+/**
+ * OpenAPI Specification Extensions.
+ *
+ * See {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#specification-extensions Specification Extensions}.
+ */
+interface SpecificationExtensions$2 {
+  [extension: `x-${string}`]: unknown;
+}
 /**
  * This is the root object of the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#openapi-document OpenAPI document}.
  *
  * This object MAY be extended with {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#specification-extensions Specification Extensions}.
  */
-interface OpenApiV3_1_X {
+interface OpenApiV3_1_X extends SpecificationExtensions$2 {
   /**
    * An element to hold various schemas for the document.
    */
@@ -196,11 +167,11 @@ interface OpenApiV3_1_X {
  *           description: callback successfully processed
  * ```
  */
-interface CallbackObject$1 {
+interface CallbackObject$1 extends SpecificationExtensions$2 {
   /**
    * A Path Item Object, or a reference to one, used to define a callback request and expected responses. A {@link https://github.com/OAI/OpenAPI-Specification/blob/main/examples/v3.0/callback-example.yaml complete example} is available.
    */
-  [expression: string]: PathItemObject$2 | ReferenceObject$1;
+  [expression: string]: PathItemObject$2 | ReferenceObject$1 | unknown;
 }
 /**
  * Holds a set of reusable objects for different aspects of the OAS. All objects defined within the components object will have no effect on the API unless they are explicitly referenced from properties outside the components object.
@@ -291,7 +262,7 @@ interface CallbackObject$1 {
  *             read:pets: read your pets
  * ```
  */
-interface ComponentsObject$1 {
+interface ComponentsObject$1 extends SpecificationExtensions$2 {
   /**
    * An object to hold reusable {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#callback-object Callback Objects}.
    */
@@ -345,7 +316,7 @@ interface ComponentsObject$1 {
  * email: support@example.com
  * ```
  */
-interface ContactObject$2 {
+interface ContactObject$2 extends SpecificationExtensions$2 {
   /**
    * The email address of the contact person/organization. This MUST be in the form of an email address.
    */
@@ -485,7 +456,7 @@ interface ContactObject$2 {
  *
  * will map to `Dog` because of the definition in the `mapping` element.
  */
-interface DiscriminatorObject$1 {
+interface DiscriminatorObject$1 extends SpecificationExtensions$2 {
   /**
    * An object to hold mappings between payload values and schema names or references.
    */
@@ -536,7 +507,7 @@ interface DiscriminatorObject$1 {
  *                 type: integer
  * ```
  */
-interface EncodingObject$1 {
+interface EncodingObject$1 extends SpecificationExtensions$2 {
   /**
    * Determines whether the parameter value SHOULD allow reserved characters, as defined by {@link https://tools.ietf.org/html/rfc3986#section-2.2 RFC3986} `:/?#[]@!$&'()*+,;=` to be included without percent-encoding. The default value is `false`. This property SHALL be ignored if the request body media type is not `application/x-www-form-urlencoded` or `multipart/form-data`. If a value is explicitly defined, then the value of {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#encodingContentType `contentType`} (implicit or explicit) SHALL be ignored.
    */
@@ -624,7 +595,7 @@ interface EncodingObject$1 {
  *             $ref: '#/components/examples/confirmation-success'
  * ```
  */
-interface ExampleObject$2 {
+interface ExampleObject$2 extends SpecificationExtensions$2 {
   /**
    * Long description for the example. {@link https://spec.commonmark.org/ CommonMark syntax} MAY be used for rich text representation.
    */
@@ -653,7 +624,7 @@ interface ExampleObject$2 {
  * url: https://example.com
  * ```
  */
-interface ExternalDocumentationObject$2 {
+interface ExternalDocumentationObject$2 extends SpecificationExtensions$2 {
   /**
    * A description of the target documentation. {@link https://spec.commonmark.org/ CommonMark syntax} MAY be used for rich text representation.
    */
@@ -699,7 +670,7 @@ type HeaderObject$2 = Omit<ParameterObject, 'in' | 'name'>;
  * version: 1.0.1
  * ```
  */
-interface InfoObject {
+interface InfoObject extends SpecificationExtensions$2 {
   /**
    * The contact information for the exposed API.
    */
@@ -740,7 +711,7 @@ interface InfoObject {
  * identifier: Apache-2.0
  * ```
  */
-interface LicenseObject$2 {
+interface LicenseObject$2 extends SpecificationExtensions$2 {
   /**
    * An {@link https://spdx.org/licenses/ SPDX} license expression for the API. The `identifier` field is mutually exclusive of the `url` field.
    */
@@ -901,7 +872,7 @@ interface LicenseObject$2 {
  *
  * Runtime expressions preserve the type of the referenced value. Expressions can be embedded into string values by surrounding the expression with `{}` curly braces.
  */
-interface LinkObject$1 {
+interface LinkObject$1 extends SpecificationExtensions$2 {
   /**
    * A description of the link. {@link https://spec.commonmark.org/ CommonMark syntax} MAY be used for rich text representation.
    */
@@ -960,7 +931,7 @@ interface LinkObject$1 {
  *       $ref: "#/components/examples/frog-example"
  * ```
  */
-interface MediaTypeObject$1 {
+interface MediaTypeObject$1 extends SpecificationExtensions$2 {
   /**
    * A map between a property name and its encoding information. The key, being the property name, MUST exist in the schema as a property. The encoding object SHALL only apply to `requestBody` objects when the media type is `multipart` or `application/x-www-form-urlencoded`.
    */
@@ -1001,7 +972,7 @@ interface MediaTypeObject$1 {
  *       read:pets: read your pets
  * ```
  */
-interface OAuthFlowObject$1 {
+interface OAuthFlowObject$1 extends SpecificationExtensions$2 {
   /**
    * **REQUIRED (`"implicit"`, `"authorizationCode"`)**. The authorization URL to be used for this flow. This MUST be in the form of a URL. The OAuth2 standard requires the use of TLS.
    */
@@ -1024,7 +995,7 @@ interface OAuthFlowObject$1 {
  *
  * This object MAY be extended with {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#specification-extensions Specification Extensions}.
  */
-interface OAuthFlowsObject$1 {
+interface OAuthFlowsObject$1 extends SpecificationExtensions$2 {
   /**
    * Configuration for the OAuth Authorization Code flow. Previously called `accessCode` in OpenAPI 2.0.
    */
@@ -1091,7 +1062,7 @@ interface OAuthFlowsObject$1 {
  *   - read:pets
  * ```
  */
-interface OperationObject {
+interface OperationObject extends SpecificationExtensions$2 {
   /**
    * A map of possible out-of band callbacks related to the parent operation. The key is a unique identifier for the Callback Object. Each value in the map is a {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#callback-object Callback Object} that describes a request that may be initiated by the API provider and the expected responses.
    */
@@ -1238,7 +1209,7 @@ interface OperationObject {
  *           type: number
  * ```
  */
-interface ParameterObject {
+interface ParameterObject extends SpecificationExtensions$2 {
   /**
    * Sets the ability to pass empty-valued parameters. This is valid only for `query` parameters and allows sending a parameter with an empty value. Default value is `false`. If {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameterStyle `style`} is used, and if behavior is `n/a` (cannot be serialized), the value of `allowEmptyValue` SHALL be ignored. Use of this property is NOT RECOMMENDED, as it is likely to be removed in a later revision.
    */
@@ -1333,7 +1304,7 @@ interface ParameterObject {
  *   style: simple
  * ```
  */
-interface PathItemObject$2 {
+interface PathItemObject$2 extends SpecificationExtensions$2 {
   /**
    * Allows for a referenced definition of this path item. The referenced structure MUST be in the form of a {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#path-item-object Path Item Object}. In case a Path Item Object field appears both in the defined object and the referenced object, the behavior is undefined. See the rules for resolving {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#relative-references-in-uris Relative References}.
    */
@@ -1432,7 +1403,7 @@ interface PathItemObject$2 {
  *                 $ref: '#/components/schemas/pet'
  * ```
  */
-interface PathsObject$2 {
+interface PathsObject$2 extends SpecificationExtensions$2 {
   /**
    * A relative path to an individual endpoint. The field name MUST begin with a forward slash (`/`). The path is **appended** (no relative URL resolution) to the expanded URL from the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#server-object `Server Object`}'s `url` field in order to construct the full URL. {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#path-templating Path templating} is allowed. When matching URLs, concrete (non-templated) paths would be matched before their templated counterparts. Templated paths with the same hierarchy but different templated names MUST NOT exist as they are identical. In case of ambiguous matching, it's up to the tooling to decide which one to use.
    */
@@ -1535,7 +1506,7 @@ interface ReferenceObject$1 {
  *         type: string
  * ```
  */
-interface RequestBodyObject {
+interface RequestBodyObject extends SpecificationExtensions$2 {
   /**
    * **REQUIRED**. The content of the request body. The key is a media type or {@link https://tools.ietf.org/html/rfc7231#appendix-D media type range} and the value describes it. For requests that match multiple keys, only the most specific key is applicable. e.g. text/plain overrides text/*
    */
@@ -1610,7 +1581,7 @@ interface RequestBodyObject {
  * description: object created
  * ```
  */
-interface ResponseObject {
+interface ResponseObject extends SpecificationExtensions$2 {
   /**
    * A map containing descriptions of potential response payloads. The key is a media type or {@link https://datatracker.ietf.org/doc/html/rfc7231#appendix-D media type range} and the value describes it. For responses that match multiple keys, only the most specific key is applicable. e.g. text/plain overrides text/*
    */
@@ -1657,11 +1628,11 @@ interface ResponseObject {
  *         $ref: '#/components/schemas/ErrorModel'
  * ```
  */
-interface ResponsesObject$2 {
+interface ResponsesObject$2 extends SpecificationExtensions$2 {
   /**
    * Any {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#http-status-codes HTTP status code} can be used as the property name, but only one property per code, to describe the expected response for that HTTP status code. This field MUST be enclosed in quotation marks (for example, "200") for compatibility between JSON and YAML. To define a range of response codes, this field MAY contain the uppercase wildcard character `X`. For example, `2XX` represents all response codes between `[200-299]`. Only the following range definitions are allowed: `1XX`, `2XX`, `3XX`, `4XX`, and `5XX`. If a response is defined using an explicit code, the explicit code definition takes precedence over the range definition for that code.
    */
-  [httpStatusCode: string]: ResponseObject | ReferenceObject$1 | undefined;
+  [httpStatusCode: string]: ResponseObject | ReferenceObject$1 | undefined | unknown;
   /**
    * The documentation of responses other than the ones declared for specific HTTP response codes. Use this field to cover undeclared responses.
    */
@@ -1691,7 +1662,7 @@ interface ResponsesObject$2 {
  *
  * This object MAY be extended with {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#specification-extensions Specification Extensions}, though as noted, additional properties MAY omit the `x-` prefix within this object.
  */
-type SchemaObject = JsonSchemaDraft2020_12;
+type SchemaObject = JsonSchemaDraft2020_12 & SpecificationExtensions$2;
 /**
  * Lists the required security schemes to execute this operation. The name used for each property MUST correspond to a security scheme declared in the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#componentsSecuritySchemes Security Schemes} under the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#components-object Components Object}.
  *
@@ -1776,7 +1747,7 @@ interface SecurityRequirementObject$2 {
  *       read:pets: read your pets
  * ```
  */
-type SecuritySchemeObject$2 = {
+type SecuritySchemeObject$2 = SpecificationExtensions$2 & {
   /**
    * A description for security scheme. {@link https://spec.commonmark.org/ CommonMark syntax} MAY be used for rich text representation.
    */
@@ -1842,7 +1813,7 @@ type SecuritySchemeObject$2 = {
  * description: Development server
  * ```
  */
-interface ServerObject$1 {
+interface ServerObject$1 extends SpecificationExtensions$2 {
   /**
    * An optional string describing the host designated by the URL. {@link https://spec.commonmark.org/ CommonMark syntax} MAY be used for rich text representation.
    */
@@ -1861,7 +1832,7 @@ interface ServerObject$1 {
  *
  * This object MAY be extended with {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#specification-extensions Specification Extensions}.
  */
-interface ServerVariableObject$1 {
+interface ServerVariableObject$1 extends SpecificationExtensions$2 {
   /**
    * **REQUIRED**. The default value to use for substitution, which SHALL be sent if an alternate value is _not_ supplied. Note this behavior is different than the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#schema-object Schema Object's} treatment of default values, because in those cases parameter values are optional. If the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#serverVariableEnum `enum`} is defined, the value MUST exist in the enum's values.
    */
@@ -1886,7 +1857,7 @@ interface ServerVariableObject$1 {
  * description: Pets operations
  * ```
  */
-interface TagObject$2 {
+interface TagObject$2 extends SpecificationExtensions$2 {
   /**
    * A description for the tag. {@link https://spec.commonmark.org/ CommonMark syntax} MAY be used for rich text representation.
    */
@@ -2092,7 +2063,7 @@ interface TagObject$2 {
  * </aliens>
  * ```
  */
-interface XMLObject$2 {
+interface XMLObject$2 extends SpecificationExtensions$2 {
   /**
    * Declares whether the property definition translates to an attribute instead of an element. Default value is `false`.
    */
@@ -2139,7 +2110,7 @@ interface OpenApiSchemaExtensions {
 //#endregion
 //#region src/openApi/3.1.x/types/json-schema-draft-2020-12.d.ts
 // TODO: left out some keywords related to structuring a complex schema and declaring a dialect
-interface JsonSchemaDraft2020_12 extends ArrayKeywords, NumberKeywords, ObjectKeywords, StringKeywords, EnumExtensions, OpenApiSchemaExtensions {
+interface JsonSchemaDraft2020_12 extends ArrayKeywords, NumberKeywords, ObjectKeywords, StringKeywords, EnumExtensions, OpenApiSchemaExtensions, SpecificationExtensions$2 {
   /**
    * The `$comment` {@link https://json-schema.org/learn/glossary#keyword keyword} is strictly intended for adding comments to a schema. Its value must always be a string. Unlike the annotations `title`, `description`, and `examples`, JSON schema {@link https://json-schema.org/learn/glossary#implementation implementations} aren't allowed to attach any meaning or behavior to it whatsoever, and may even strip them at any time. Therefore, they are useful for leaving notes to future editors of a JSON schema, but should not be used to communicate to users of the schema.
    */
@@ -2464,6 +2435,14 @@ type JsonSchemaTypes$1 = 'array' | 'boolean' | 'integer' | 'null' | 'number' | '
 type IRMediaType = 'form-data' | 'json' | 'text' | 'url-search-params' | 'octet-stream';
 //#endregion
 //#region src/ir/types.d.ts
+/**
+ * OpenAPI Specification Extensions.
+ *
+ * See {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#specification-extensions Specification Extensions}.
+ */
+interface SpecificationExtensions$1 {
+  [extension: `x-${string}`]: unknown;
+}
 interface IRBodyObject {
   mediaType: string;
   /**
@@ -2480,7 +2459,7 @@ interface IRComponentsObject {
   requestBodies?: Record<string, IRRequestBodyObject>;
   schemas?: Record<string, IRSchemaObject>;
 }
-interface IROperationObject {
+interface IROperationObject extends SpecificationExtensions$1 {
   body?: IRBodyObject;
   deprecated?: boolean;
   description?: string;
@@ -2501,7 +2480,7 @@ interface IRParametersObject {
   path?: Record<string, IRParameterObject>;
   query?: Record<string, IRParameterObject>;
 }
-interface IRParameterObject extends Pick<JsonSchemaDraft2020_12, 'deprecated' | 'description'> {
+interface IRParameterObject extends Pick<JsonSchemaDraft2020_12, 'deprecated' | 'description'>, SpecificationExtensions$1 {
   /**
    * Determines whether the parameter value SHOULD allow reserved characters, as defined by RFC3986 `:/?#[]@!$&'()*+,;=` to be included without percent-encoding. The default value is `false`. This property SHALL be ignored if the request body media type is not `application/x-www-form-urlencoded` or `multipart/form-data`. If a value is explicitly defined, then the value of `contentType` (implicit or explicit) SHALL be ignored.
    */
@@ -2559,7 +2538,7 @@ interface IRResponseObject {
   mediaType?: string;
   schema: IRSchemaObject;
 }
-interface IRSchemaObject extends Pick<JsonSchemaDraft2020_12, '$ref' | 'const' | 'default' | 'deprecated' | 'description' | 'exclusiveMaximum' | 'exclusiveMinimum' | 'maximum' | 'maxItems' | 'maxLength' | 'minimum' | 'minItems' | 'minLength' | 'pattern' | 'required' | 'title' | 'example'> {
+interface IRSchemaObject extends Pick<JsonSchemaDraft2020_12, '$ref' | 'const' | 'default' | 'deprecated' | 'description' | 'exclusiveMaximum' | 'exclusiveMinimum' | 'maximum' | 'maxItems' | 'maxLength' | 'minimum' | 'minItems' | 'minLength' | 'pattern' | 'required' | 'title' | 'example'>, SpecificationExtensions$1 {
   /**
    * If the schema is intended to be used as an object property, it can be
    * marked as read-only or write-only. This value controls whether the schema
@@ -2604,6 +2583,10 @@ interface IRSchemaObject extends Pick<JsonSchemaDraft2020_12, '$ref' | 'const' |
    * follow a specific convention.
    */
   propertyNames?: IRSchemaObject;
+  /**
+   * Reference to symbol instead of `$ref` string.
+   */
+  symbolRef?: Symbol;
   /**
    * Each schema eventually resolves into `type`.
    */
@@ -4779,12 +4762,20 @@ interface OpenApiV2_0_XTypes {
 }
 //#endregion
 //#region src/openApi/3.0.x/types/spec.d.ts
+/**
+ * OpenAPI Specification Extensions.
+ *
+ * See {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#specification-extensions Specification Extensions}.
+ */
+interface SpecificationExtensions {
+  [extension: `x-${string}`]: unknown;
+}
 /**
  * This is the root object of the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#openapi-description OpenAPI Description}.
  *
  * This object MAY be extended with {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#specification-extensions Specification Extensions}.
  */
-interface OpenApiV3_0_X {
+interface OpenApiV3_0_X extends SpecificationExtensions {
   /**
    * An element to hold various Objects for the OpenAPI Description.
    */
@@ -4825,11 +4816,11 @@ interface OpenApiV3_0_X {
  *
  * TODO: examples
  */
-interface CallbackObject {
+interface CallbackObject extends SpecificationExtensions {
   /**
    * A Path Item Object used to define a callback request and expected responses. A {@link https://learn.openapis.org/examples/v3.0/callback-example.html complete example} is available.
    */
-  [expression: string]: PathItemObject | ReferenceObject$2;
+  [expression: string]: PathItemObject | ReferenceObject$2 | unknown;
 }
 /**
  * Holds a set of reusable objects for different aspects of the OAS. All objects defined within the Components Object will have no effect on the API unless they are explicitly referenced from outside the Components Object.
@@ -4840,7 +4831,7 @@ interface CallbackObject {
  *
  * TODO: examples
  */
-interface ComponentsObject {
+interface ComponentsObject extends SpecificationExtensions {
   /**
    * An object to hold reusable {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#callback-object Callback Objects}.
    */
@@ -4889,7 +4880,7 @@ interface ComponentsObject {
  * email: support@example.com
  * ```
  */
-interface ContactObject {
+interface ContactObject extends SpecificationExtensions {
   /**
    * The email address of the contact person/organization. This MUST be in the form of an email address.
    */
@@ -4934,7 +4925,7 @@ interface DiscriminatorObject {
  * TODO: default values examples
  * TODO: examples
  */
-interface EncodingObject {
+interface EncodingObject extends SpecificationExtensions {
   /**
    * When this is true, parameter values are serialized using reserved expansion, as defined by {@link https://datatracker.ietf.org/doc/html/rfc6570#section-3.2.3 RFC6570}, which allows {@link https://datatracker.ietf.org/doc/html/rfc3986#section-2.2 RFC3986's reserved character set}, as well as percent-encoded triples, to pass through unchanged, while still percent-encoding all other disallowed characters (including `%` outside of percent-encoded triples). Applications are still responsible for percent-encoding reserved characters that are {@link https://datatracker.ietf.org/doc/html/rfc3986#section-3.4 not allowed in the query string} (`[`, `]`, `#`), or have a special meaning in `application/x-www-form-urlencoded` (`-`, `&`, `+`); see Appendices {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#appendix-c-using-rfc6570-based-serialization C} and {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#appendix-e-percent-encoding-and-form-media-types E} for details. The default value is `false`. This field SHALL be ignored if the request body media type is not `application/x-www-form-urlencoded`.
    */
@@ -4967,7 +4958,7 @@ interface EncodingObject {
  *
  * TODO: examples
  */
-interface ExampleObject {
+interface ExampleObject extends SpecificationExtensions {
   /**
    * Long description for the example. {@link https://spec.commonmark.org/ CommonMark syntax} MAY be used for rich text representation.
    */
@@ -4997,7 +4988,7 @@ interface ExampleObject {
  * url: https://example.com
  * ```
  */
-interface ExternalDocumentationObject {
+interface ExternalDocumentationObject extends SpecificationExtensions {
   /**
    * A description of the target documentation. {@link https://spec.commonmark.org/ CommonMark syntax} MAY be used for rich text representation.
    */
@@ -5039,7 +5030,7 @@ type HeaderObject = Omit<ParameterObject$1, 'in' | 'name'>;
  * version: 1.0.1
  * ```
  */
-interface InfoObject$1 {
+interface InfoObject$1 extends SpecificationExtensions {
   /**
    * The contact information for the exposed API.
    */
@@ -5075,7 +5066,7 @@ interface InfoObject$1 {
  * url: https://www.apache.org/licenses/LICENSE-2.0.html
  * ```
  */
-interface LicenseObject {
+interface LicenseObject extends SpecificationExtensions {
   /**
    * **REQUIRED**. The license name used for the API.
    */
@@ -5100,7 +5091,7 @@ interface LicenseObject {
  *
  * TODO: examples
  */
-interface LinkObject {
+interface LinkObject extends SpecificationExtensions {
   /**
    * A description of the link. {@link https://spec.commonmark.org/ CommonMark syntax} MAY be used for rich text representation.
    */
@@ -5135,7 +5126,7 @@ interface LinkObject {
  *
  * TODO: examples
  */
-interface MediaTypeObject {
+interface MediaTypeObject extends SpecificationExtensions {
   /**
    * A map between a property name and its encoding information. The key, being the property name, MUST exist in the schema as a property. The `encoding` field SHALL only apply to {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#request-body-object Request Body Objects}, and only when the media type is `multipart` or `application/x-www-form-urlencoded`. If no Encoding Object is provided for a property, the behavior is determined by the default values documented for the Encoding Object.
    */
@@ -5160,7 +5151,7 @@ interface MediaTypeObject {
  *
  * TODO: examples
  */
-interface OAuthFlowObject {
+interface OAuthFlowObject extends SpecificationExtensions {
   /**
    * **REQUIRED (`"implicit"`, `"authorizationCode"`)**. The authorization URL to be used for this flow. This MUST be in the form of a URL. The OAuth2 standard requires the use of TLS.
    */
@@ -5183,7 +5174,7 @@ interface OAuthFlowObject {
  *
  * This object MAY be extended with {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#specification-extensions Specification Extensions}.
  */
-interface OAuthFlowsObject {
+interface OAuthFlowsObject extends SpecificationExtensions {
   /**
    * Configuration for the OAuth Authorization Code flow. Previously called `accessCode` in OpenAPI 2.0.
    */
@@ -5208,7 +5199,7 @@ interface OAuthFlowsObject {
  *
  * TODO: examples
  */
-interface OperationObject$1 {
+interface OperationObject$1 extends SpecificationExtensions {
   /**
    * A map of possible out-of band callbacks related to the parent operation. The key is a unique identifier for the Callback Object. Each value in the map is a {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#callback-object Callback Object} that describes a request that may be initiated by the API provider and the expected responses.
    */
@@ -5302,7 +5293,7 @@ interface OperationObject$1 {
  *
  * TODO: examples
  */
-interface ParameterObject$1 {
+interface ParameterObject$1 extends SpecificationExtensions {
   /**
    * If `true`, clients MAY pass a zero-length string value in place of parameters that would otherwise be omitted entirely, which the server SHOULD interpret as the parameter being unused. Default value is `false`. If {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#parameter-style `style`} is used, and if {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#style-examples behavior is _n/a_ (cannot be serialized)}, the value of `allowEmptyValue` SHALL be ignored. Interactions between this field and the parameter's {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#schema-object Schema Object} are implementation-defined. This field is valid only for `query` parameters. Use of this field is NOT RECOMMENDED, and it is likely to be removed in a later revision.
    */
@@ -5366,7 +5357,7 @@ interface ParameterObject$1 {
  *
  * TODO: examples
  */
-interface PathItemObject {
+interface PathItemObject extends SpecificationExtensions {
   /**
    * Allows for a referenced definition of this path item. The value MUST be in the form of a URL, and the referenced structure MUST be in the form of a {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#path-item-object Path Item Object}. In case a Path Item Object field appears both in the defined object and the referenced object, the behavior is undefined. See the rules for resolving {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#relative-references-in-urls Relative References}.
    */
@@ -5427,7 +5418,7 @@ interface PathItemObject {
  *
  * TODO: examples
  */
-interface PathsObject {
+interface PathsObject extends SpecificationExtensions {
   /**
    * A relative path to an individual endpoint. The field name MUST begin with a forward slash (`/`). The path is **appended** (no relative URL resolution) to the expanded URL from the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#server-object Server Object}'s `url` field in order to construct the full URL. {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#path-templating Path templating} is allowed. When matching URLs, concrete (non-templated) paths would be matched before their templated counterparts. Templated paths with the same hierarchy but different templated names MUST NOT exist as they are identical. In case of ambiguous matching, it's up to the tooling to decide which one to use.
    */
@@ -5473,7 +5464,7 @@ interface ReferenceObject$2 {
  *
  * TODO: examples
  */
-interface RequestBodyObject$1 {
+interface RequestBodyObject$1 extends SpecificationExtensions {
   /**
    * **REQUIRED**. The content of the request body. The key is a media type or {@link https://tools.ietf.org/html/rfc7231#appendix-D media type range} and the value describes it. For requests that match multiple keys, only the most specific key is applicable. e.g. `"text/plain"` overrides `"text/*"`
    */
@@ -5494,7 +5485,7 @@ interface RequestBodyObject$1 {
  *
  * TODO: examples
  */
-interface ResponseObject$1 {
+interface ResponseObject$1 extends SpecificationExtensions {
   /**
    * A map containing descriptions of potential response payloads. The key is a media type or {@link https://tools.ietf.org/html/rfc7231#appendix-D media type range} and the value describes it. For responses that match multiple keys, only the most specific key is applicable. e.g. `"text/plain"` overrides `"text/*"`
    */
@@ -5525,11 +5516,11 @@ interface ResponseObject$1 {
  *
  * TODO: examples
  */
-interface ResponsesObject {
+interface ResponsesObject extends SpecificationExtensions {
   /**
    * Any {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#http-status-codes HTTP status code} can be used as the property name, but only one property per code, to describe the expected response for that HTTP status code. A {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#reference-object Reference Object} can link to a response that is defined in the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#components-responses OpenAPI Object's `components.responses`} section. This field MUST be enclosed in quotation marks (for example, "200") for compatibility between JSON and YAML. To define a range of response codes, this field MAY contain the uppercase wildcard character `X`. For example, `2XX` represents all response codes between `200` and `299`. Only the following range definitions are allowed: `1XX`, `2XX`, `3XX`, `4XX`, and `5XX`. If a response is defined using an explicit code, the explicit code definition takes precedence over the range definition for that code.
    */
-  [httpStatusCode: string]: ResponseObject$1 | ReferenceObject$2 | undefined;
+  [httpStatusCode: string]: ResponseObject$1 | ReferenceObject$2 | undefined | unknown;
   /**
    * The documentation of responses other than the ones declared for specific HTTP response codes. Use this field to cover undeclared responses. A {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#reference-object Reference Object} can link to a response that the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#components-responses OpenAPI Object's `components.responses`} section defines.
    */
@@ -5586,7 +5577,7 @@ interface ResponsesObject {
  *
  * TODO: content, examples
  */
-interface SchemaObject$1 extends EnumExtensions {
+interface SchemaObject$1 extends EnumExtensions, SpecificationExtensions {
   /**
    * The value of "additionalProperties" MUST be a boolean or a schema.
    *
@@ -5837,7 +5828,7 @@ interface SecurityRequirementObject {
  *
  * TODO: examples
  */
-type SecuritySchemeObject = {
+type SecuritySchemeObject = SpecificationExtensions & {
   /**
    * A description for security scheme. {@link https://spec.commonmark.org/ CommonMark syntax} MAY be used for rich text representation.
    */
@@ -5894,7 +5885,7 @@ type SecuritySchemeObject = {
  *
  * TODO: examples
  */
-interface ServerObject {
+interface ServerObject extends SpecificationExtensions {
   /**
    * An optional string describing the host designated by the URL. {@link https://spec.commonmark.org/ CommonMark syntax} MAY be used for rich text representation.
    */
@@ -5913,7 +5904,7 @@ interface ServerObject {
  *
  * This object MAY be extended with {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#specification-extensions Specification Extensions}.
  */
-interface ServerVariableObject {
+interface ServerVariableObject extends SpecificationExtensions {
   /**
    * **REQUIRED**. The default value to use for substitution, which SHALL be sent if an alternate value is _not_ supplied. If the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#server-variable-enum `enum`} is defined, the value SHOULD exist in the enum's values. Note that this behavior is different from the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#schema-object Schema Object}'s `default` keyword, which documents the receiver's behavior rather than inserting the value into the data.
    */
@@ -5939,7 +5930,7 @@ interface ServerVariableObject {
  * description: Pets operations
  * ```
  */
-interface TagObject {
+interface TagObject extends SpecificationExtensions {
   /**
    * A description for the tag. {@link https://spec.commonmark.org/ CommonMark syntax} MAY be used for rich text representation.
    */
@@ -5967,7 +5958,7 @@ interface TagObject {
  *
  * TODO: examples
  */
-interface XMLObject {
+interface XMLObject extends SpecificationExtensions {
   /**
    * Declares whether the property definition translates to an attribute instead of an element. Default value is `false`.
    */
@@ -6283,10 +6274,8 @@ type Config$13 = Plugin.Name<'@hey-api/sdk'> & Plugin.Hooks & {
    * Set `instance` to create an instantiable SDK. Using `true` will use the
    * default instance name; in practice, you want to define your own by passing
    * a string value.
-   *
-   * @default false
    */
-  instance: string | boolean;
+  instance: string;
   /**
    * Customise the name of methods within the service. By default,
    * {@link IR.OperationObject.id} is used.
@@ -6378,608 +6367,874 @@ type HeyApiSdkPlugin = DefinePlugin<UserConfig$14, Config$13>;
 //#endregion
 //#region src/ts-dsl/base.d.ts
 type MaybeArray$1<T> = T | ReadonlyArray<T>;
-interface ITsDsl<T extends ts.Node = ts.Node> {
-  $render(): T;
-}
-declare abstract class TsDsl<T extends ts.Node = ts.Node> implements ITsDsl<T> {
-  abstract $render(): T;
+declare abstract class TsDsl<T extends ts.Node = ts.Node> implements Node<T> {
+  analyze(_: AnalysisContext): void;
+  exported?: boolean;
+  file?: File;
+  language: Language;
+  parent?: Node;
+  root?: Node;
+  symbol?: Symbol;
+  toAst(_: AstContext): T;
+  readonly '~brand' = "heyapi.node";
+  /** Branding property to identify the DSL class at runtime. */
+  abstract readonly '~dsl': string;
   /** Conditionally applies a callback to this builder. */
-  $if<T extends TsDsl, V$1, R extends TsDsl = T>(this: T, value: V$1, ifTrue: (self: T, v: Exclude<V$1, false | null | undefined>) => R | void, ifFalse?: (self: T, v: Extract<V$1, false | null | undefined>) => R | void): R | T;
-  $if<T extends TsDsl, V$1, R extends TsDsl = T>(this: T, value: V$1, ifTrue: (v: Exclude<V$1, false | null | undefined>) => R | void, ifFalse?: (v: Extract<V$1, false | null | undefined>) => R | void): R | T;
-  $if<T extends TsDsl, V$1, R extends TsDsl = T>(this: T, value: V$1, ifTrue: () => R | void, ifFalse?: () => R | void): R | T;
+  $if<T extends TsDsl, V, R extends TsDsl = T>(this: T, value: V, ifTrue: (self: T, v: Exclude<V, false | null | undefined>) => R | void, ifFalse?: (self: T, v: Extract<V, false | null | undefined>) => R | void): R | T;
+  $if<T extends TsDsl, V, R extends TsDsl = T>(this: T, value: V, ifTrue: (v: Exclude<V, false | null | undefined>) => R | void, ifFalse?: (v: Extract<V, false | null | undefined>) => R | void): R | T;
+  $if<T extends TsDsl, V, R extends TsDsl = T>(this: T, value: V, ifTrue: () => R | void, ifFalse?: () => R | void): R | T;
   protected $maybeId<T extends string | ts.Expression>(expr: T): T extends string ? ts.Identifier : T;
-  protected $node<I>(value: I): NodeOfMaybe<I>;
-  protected $type<I>(value: I, args?: ReadonlyArray<ts.TypeNode>): TypeOfMaybe<I>;
-  protected unwrap<I>(value: I): I extends TsDsl<infer N> ? N : I;
+  protected $node<I>(ctx: AstContext, value: I): NodeOfMaybe<I>;
+  protected $type<I>(ctx: AstContext, value: I, args?: ReadonlyArray<ts.TypeNode>): TypeOfMaybe<I>;
+  /** Unwraps nested nodes into raw TypeScript AST. */
+  private unwrap;
 }
-type NodeOfMaybe<I> = undefined extends I ? NodeOf<NonNullable<I>> | undefined : NodeOf<I>;
+type NodeOfMaybe<I> = undefined extends I ? NodeOf<NonNullable<FromRef<I>>> | undefined : NodeOf<FromRef<I>>;
 type NodeOf<I> = I extends ReadonlyArray<infer U> ? ReadonlyArray<U extends TsDsl<infer N> ? N : U> : I extends string ? ts.Expression : I extends TsDsl<infer N> ? N : I extends ts.Node ? I : never;
 type MaybeTsDsl<T> = T extends TsDsl<infer U> ? U | TsDsl<U> : T extends ts.Node ? T | TsDsl<T> : never;
 declare abstract class TypeTsDsl<T extends ts.LiteralTypeNode | ts.QualifiedName | ts.TypeElement | ts.TypeNode | ts.TypeParameterDeclaration = ts.TypeNode> extends TsDsl<T> {}
-type TypeOfMaybe<I> = undefined extends I ? TypeOf<NonNullable<I>> | undefined : TypeOf<I>;
+type TypeOfMaybe<I> = undefined extends I ? TypeOf<NonNullable<FromRef<I>>> | undefined : TypeOf<FromRef<I>>;
 type TypeOf<I> = I extends ReadonlyArray<infer U> ? ReadonlyArray<TypeOf<U>> : I extends string ? ts.TypeNode : I extends boolean ? ts.LiteralTypeNode : I extends TsDsl<infer N> ? N : I extends ts.TypeNode ? I : never;
 //#endregion
-//#region src/ts-dsl/layout/newline.d.ts
-declare class NewlineTsDsl extends TsDsl<ts.Identifier> {
-  $render(): ts.Identifier;
+//#region src/ts-dsl/mixins/types.d.ts
+type BaseCtor<T> = abstract new (...args: Array<any>) => TsDsl<T>;
+type DropFirst<T extends Array<any>> = T extends [any, ...infer Rest] ? Rest : never;
+type MixinCtor<T extends BaseCtor<any>, K$1> = abstract new (...args: Array<any>) => InstanceType<T> & K$1;
+//#endregion
+//#region src/ts-dsl/mixins/optional.d.ts
+interface OptionalMethods extends Node {
+  _optional?: boolean;
+  /** Marks the node as optional when the condition is true. */
+  optional(condition?: boolean): this;
+  /** Marks the node as required when the condition is true. */
+  required(condition?: boolean): this;
+}
+//#endregion
+//#region src/ts-dsl/mixins/as.d.ts
+interface AsMethods extends Node {
+  /** Creates an `as` type assertion expression (e.g. `value as Type`). */
+  as(...args: DropFirst<Parameters<typeof f.as>>): ReturnType<typeof f.as>;
+}
+//#endregion
+//#region src/ts-dsl/expr/binary.d.ts
+type Expr$3 = Symbol | string | MaybeTsDsl<ts.Expression>;
+type Op$1 = Operator | ts.BinaryOperator;
+type Operator = '!=' | '!==' | '&&' | '*' | '+' | '-' | '/' | '<' | '<=' | '=' | '==' | '===' | '>' | '>=' | '??' | '??=' | '||';
+declare const Mixed$52: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.BinaryExpression>, ExprMethods>, AsMethods>;
+declare class BinaryTsDsl extends Mixed$52 {
+  readonly '~dsl' = "BinaryTsDsl";
+  protected _base: Ref<Expr$3>;
+  protected _expr?: Ref<Expr$3>;
+  protected _op?: Op$1;
+  constructor(base: Expr$3, op?: Op$1, expr?: Expr$3);
+  analyze(ctx: AnalysisContext): void;
+  /** Logical AND — `this && expr` */
+  and(expr: Expr$3): this;
+  /** Creates an assignment expression (e.g. `this = expr`). */
+  assign(expr: Expr$3): this;
+  /** Nullish coalescing — `this ?? expr` */
+  coalesce(expr: Expr$3): this;
+  /** Division — `this / expr` */
+  div(expr: Expr$3): this;
+  /** Strict equality — `this === expr` */
+  eq(expr: Expr$3): this;
+  /** Greater than — `this > expr` */
+  gt(expr: Expr$3): this;
+  /** Greater than or equal — `this >= expr` */
+  gte(expr: Expr$3): this;
+  /** Loose equality — `this == expr` */
+  looseEq(expr: Expr$3): this;
+  /** Loose inequality — `this != expr` */
+  looseNeq(expr: Expr$3): this;
+  /** Less than — `this < expr` */
+  lt(expr: Expr$3): this;
+  /** Less than or equal — `this <= expr` */
+  lte(expr: Expr$3): this;
+  /** Subtraction — `this - expr` */
+  minus(expr: Expr$3): this;
+  /** Strict inequality — `this !== expr` */
+  neq(expr: Expr$3): this;
+  /** Nullish assignment — `this ??= expr` */
+  nullishAssign(expr: Expr$3): this;
+  /** Logical OR — `this || expr` */
+  or(expr: Expr$3): this;
+  /** Addition — `this + expr` */
+  plus(expr: Expr$3): this;
+  /** Multiplication — `this * expr` */
+  times(expr: Expr$3): this;
+  toAst(ctx: AstContext): ts.BinaryExpression;
+  /** Sets the binary operator and right-hand operand for this expression. */
+  private opAndExpr;
+  private opToToken;
+}
+//#endregion
+//#region src/ts-dsl/mixins/operator.d.ts
+type Expr$2 = Symbol | string | MaybeTsDsl<ts.Expression>;
+interface OperatorMethods extends Node {
+  /** Logical AND — `this && expr` */
+  and(expr: Expr$2): BinaryTsDsl;
+  /** Creates an assignment expression (e.g. `this = expr`). */
+  assign(expr: Expr$2): BinaryTsDsl;
+  /** Nullish coalescing — `this ?? expr` */
+  coalesce(expr: Expr$2): BinaryTsDsl;
+  /** Division — `this / expr` */
+  div(expr: Expr$2): BinaryTsDsl;
+  /** Strict equality — `this === expr` */
+  eq(expr: Expr$2): BinaryTsDsl;
+  /** Greater than — `this > expr` */
+  gt(expr: Expr$2): BinaryTsDsl;
+  /** Greater than or equal — `this >= expr` */
+  gte(expr: Expr$2): BinaryTsDsl;
+  /** Loose equality — `this == expr` */
+  looseEq(expr: Expr$2): BinaryTsDsl;
+  /** Loose inequality — `this != expr` */
+  looseNeq(expr: Expr$2): BinaryTsDsl;
+  /** Less than — `this < expr` */
+  lt(expr: Expr$2): BinaryTsDsl;
+  /** Less than or equal — `this <= expr` */
+  lte(expr: Expr$2): BinaryTsDsl;
+  /** Subtraction — `this - expr` */
+  minus(expr: Expr$2): BinaryTsDsl;
+  /** Strict inequality — `this !== expr` */
+  neq(expr: Expr$2): BinaryTsDsl;
+  /** Nullish assignment — `this ??= expr` */
+  nullishAssign(expr: Expr$2): BinaryTsDsl;
+  /** Logical OR — `this || expr` */
+  or(expr: Expr$2): BinaryTsDsl;
+  /** Addition — `this + expr` */
+  plus(expr: Expr$2): BinaryTsDsl;
+  /** Multiplication — `this * expr` */
+  times(expr: Expr$2): BinaryTsDsl;
+}
+//#endregion
+//#region src/ts-dsl/expr/attr.d.ts
+type AttrLeft = Symbol | string | MaybeTsDsl<ts.Expression>;
+type AttrRight = Symbol | string | ts.MemberName | number;
+type AttrCtor = (left: AttrLeft, right: AttrRight) => AttrTsDsl;
+declare const Mixed$51: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.PropertyAccessExpression | ts.ElementAccessExpression>, OptionalMethods>, OperatorMethods>, ExprMethods>, AsMethods>;
+declare class AttrTsDsl extends Mixed$51 {
+  readonly '~dsl' = "AttrTsDsl";
+  protected left: Ref<AttrLeft>;
+  protected right: Ref<AttrRight>;
+  constructor(left: AttrLeft, right: AttrRight);
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): ts.PropertyAccessExpression | ts.ElementAccessExpression;
+}
+//#endregion
+//#region src/ts-dsl/expr/await.d.ts
+type AwaitExpr = Symbol | string | MaybeTsDsl<ts.Expression>;
+type AwaitCtor = (expr: AwaitExpr) => AwaitTsDsl;
+declare const Mixed$50: MixinCtor<abstract new () => TsDsl<ts.AwaitExpression>, ExprMethods>;
+declare class AwaitTsDsl extends Mixed$50 {
+  readonly '~dsl' = "AwaitTsDsl";
+  protected _awaitExpr: Ref<AwaitExpr>;
+  constructor(expr: AwaitExpr);
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): ts.AwaitExpression;
+}
+//#endregion
+//#region src/ts-dsl/mixins/type-args.d.ts
+type Arg$1 = Symbol | string | MaybeTsDsl<TypeTsDsl>;
+interface TypeArgsMethods extends Node {
+  /** Returns the type arguments as an array of ts.TypeNode nodes. */
+  $generics(ctx: AstContext): ReadonlyArray<ts.TypeNode> | undefined;
+  /** Adds a single type argument (e.g. `string` in `Foo<string>`). */
+  generic(arg: Arg$1): this;
+  /** Adds type arguments (e.g. `Map<string, number>`). */
+  generics(...args: ReadonlyArray<Arg$1>): this;
 }
 //#endregion
 //#region src/ts-dsl/mixins/args.d.ts
-/**
- * Adds `.arg()` and `.args()` for managing expression arguments in call-like nodes.
- */
-declare class ArgsMixin extends TsDsl {
-  protected _args?: Array<string | MaybeTsDsl<ts.Expression>>;
+type Arg = Symbol | string | MaybeTsDsl<ts.Expression>;
+interface ArgsMethods extends Node {
+  /** Renders the arguments into an array of `Expression`s. */
+  $args(ctx: AstContext): ReadonlyArray<ts.Expression>;
   /** Adds a single expression argument. */
-  arg(arg: string | MaybeTsDsl<ts.Expression>): this;
+  arg(arg: Arg | undefined): this;
   /** Adds one or more expression arguments. */
-  args(...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>): this;
-  /** Renders the arguments into an array of `Expression`s. */
-  protected $args(): ReadonlyArray<ts.Expression>;
-  $render(): ts.Node;
+  args(...args: ReadonlyArray<Arg | undefined>): this;
 }
 //#endregion
-//#region src/ts-dsl/decl/decorator.d.ts
-declare class DecoratorTsDsl extends TsDsl<ts.Decorator> {
-  protected name: string | ts.Expression;
-  constructor(name: string | ts.Expression, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>);
-  $render(): ts.Decorator;
+//#region src/ts-dsl/expr/call.d.ts
+type CallCallee = string | MaybeTsDsl<ts.Expression>;
+type CallArg = Symbol | string | MaybeTsDsl<ts.Expression>;
+type CallArgs = ReadonlyArray<CallArg | undefined>;
+type CallCtor = (callee: CallCallee, ...args: CallArgs) => CallTsDsl;
+declare const Mixed$49: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.CallExpression>, TypeArgsMethods>, ExprMethods>, AsMethods>, ArgsMethods>;
+declare class CallTsDsl extends Mixed$49 {
+  readonly '~dsl' = "CallTsDsl";
+  protected _callee: CallCallee;
+  constructor(callee: CallCallee, ...args: CallArgs);
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): ts.CallExpression;
 }
-interface DecoratorTsDsl extends ArgsMixin {}
 //#endregion
-//#region src/ts-dsl/mixins/decorator.d.ts
-declare class DecoratorMixin extends TsDsl {
-  protected decorators?: Array<DecoratorTsDsl>;
-  /** Adds a decorator (e.g. `@sealed({ in: 'root' })`). */
-  decorator(name: string | ts.Expression, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>): this;
-  /** Renders the decorators into an array of `ts.Decorator`s. */
-  protected $decorators(): ReadonlyArray<ts.Decorator>;
-  $render(): ts.Node;
+//#region src/ts-dsl/expr/typeof.d.ts
+type TypeOfExpr = string | MaybeTsDsl<ts.Expression>;
+type TypeOfExprCtor = (expr: TypeOfExpr) => TypeOfExprTsDsl;
+declare const Mixed$48: MixinCtor<abstract new () => TsDsl<ts.TypeOfExpression>, OperatorMethods>;
+declare class TypeOfExprTsDsl extends Mixed$48 {
+  readonly '~dsl' = "TypeOfExprTsDsl";
+  protected _expr: TypeOfExpr;
+  constructor(expr: TypeOfExpr);
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): ts.TypeOfExpression;
 }
 //#endregion
-//#region src/ts-dsl/layout/doc.d.ts
-declare class DocTsDsl extends TsDsl<ts.Node> {
-  protected _lines: Array<string>;
-  constructor(lines?: MaybeArray$1<string>, fn?: (d: DocTsDsl) => void);
-  add(...lines: ReadonlyArray<string>): this;
-  apply<T extends ts.Node>(node: T): T;
-  $render(): ts.Node;
+//#region src/ts-dsl/stmt/return.d.ts
+type ReturnExpr = Symbol | string | MaybeTsDsl<ts.Expression>;
+type ReturnCtor = (expr?: ReturnExpr) => ReturnTsDsl;
+declare const Mixed$47: abstract new () => TsDsl<ts.ReturnStatement>;
+declare class ReturnTsDsl extends Mixed$47 {
+  readonly '~dsl' = "ReturnTsDsl";
+  protected _returnExpr?: Ref<ReturnExpr>;
+  constructor(expr?: ReturnExpr);
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): ts.ReturnStatement;
 }
 //#endregion
-//#region src/ts-dsl/mixins/doc.d.ts
-declare function DocMixin<TBase extends new (...args: ReadonlyArray<any>) => ITsDsl>(Base: TBase): {
-  new (...args: ReadonlyArray<any>): {
-    _doc?: DocTsDsl;
-    doc(lines?: MaybeArray$1<string>, fn?: (d: DocTsDsl) => void): /*elided*/any;
-    $render(): any;
+//#region src/ts-dsl/mixins/type-expr.d.ts
+interface TypeExprMethods extends Node {
+  /** Creates an indexed-access type (e.g. `Foo<T>[K]`). */
+  idx(this: Parameters<typeof f.type.idx>[0], ...args: DropFirst<Parameters<typeof f.type.idx>>): ReturnType<typeof f.type.idx>;
+  /** Shorthand: builds `keyof T`. */
+  keyof(this: MaybeTsDsl<TypeTsDsl>): ReturnType<typeof f.type.operator>;
+  /** Shorthand: builds `readonly T`. */
+  readonly(this: MaybeTsDsl<TypeTsDsl>): ReturnType<typeof f.type.operator>;
+  /** Create a TypeExpr node representing ReturnType<this>. */
+  returnType(this: Parameters<typeof f.type.query>[0], ...args: DropFirst<Parameters<typeof f.type.query>>): ReturnType<typeof f.type.expr>;
+  /** Create a TypeOfExpr node representing typeof this. */
+  typeofExpr(this: Parameters<typeof f.typeofExpr>[0], ...args: DropFirst<Parameters<typeof f.typeofExpr>>): ReturnType<typeof f.typeofExpr>;
+  /** Create a TypeQuery node representing typeof this. */
+  typeofType(this: Parameters<typeof f.type.query>[0], ...args: DropFirst<Parameters<typeof f.type.query>>): ReturnType<typeof f.type.query>;
+  /** Shorthand: builds `unique T`. */
+  unique(this: MaybeTsDsl<TypeTsDsl>): ReturnType<typeof f.type.operator>;
+}
+//#endregion
+//#region src/ts-dsl/type/attr.d.ts
+type Base$2 = Symbol | string | MaybeTsDsl<ts.EntityName>;
+type Right = Symbol | string | ts.Identifier;
+declare const Mixed$46: MixinCtor<abstract new () => TsDsl<ts.QualifiedName>, TypeExprMethods>;
+declare class TypeAttrTsDsl extends Mixed$46 {
+  readonly '~dsl' = "TypeAttrTsDsl";
+  protected _base?: Ref<Base$2>;
+  protected _right: Ref<Right>;
+  constructor(base: Base$2 | Ref<Base$2>, right: string | ts.Identifier);
+  constructor(right: Right);
+  analyze(ctx: AnalysisContext): void;
+  base(base?: Base$2 | Ref<Base$2>): this;
+  right(right: Right): this;
+  toAst(ctx: AstContext): ts.QualifiedName;
+}
+//#endregion
+//#region src/ts-dsl/type/expr.d.ts
+type TypeExprName = Symbol | string;
+type TypeExprExpr = TypeExprName | TypeAttrTsDsl;
+type TypeExprFn = (t: TypeExprTsDsl) => void;
+type TypeExprCtor = (nameOrFn?: TypeExprName | TypeExprFn, fn?: TypeExprFn) => TypeExprTsDsl;
+declare const Mixed$45: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.TypeReferenceNode>, TypeExprMethods>, TypeArgsMethods>;
+declare class TypeExprTsDsl extends Mixed$45 {
+  readonly '~dsl' = "TypeExprTsDsl";
+  protected _exprInput?: Ref<TypeExprExpr>;
+  constructor();
+  constructor(fn: TypeExprFn);
+  constructor(name: TypeExprName);
+  constructor(name: TypeExprName, fn?: TypeExprFn);
+  analyze(ctx: AnalysisContext): void;
+  /** Accesses a nested type (e.g. `Foo.Bar`). */
+  attr(right: string | ts.Identifier | TypeAttrTsDsl): this;
+  toAst(ctx: AstContext): ts.TypeReferenceNode;
+}
+//#endregion
+//#region src/ts-dsl/type/idx.d.ts
+type Base$1 = string | MaybeTsDsl<ts.TypeNode>;
+type Index = string | number | MaybeTsDsl<ts.TypeNode>;
+type TypeIdxCtor = (base: Base$1, index: Index) => TypeIdxTsDsl;
+declare const Mixed$44: MixinCtor<abstract new () => TsDsl<ts.IndexedAccessTypeNode>, TypeExprMethods>;
+declare class TypeIdxTsDsl extends Mixed$44 {
+  readonly '~dsl' = "TypeIdxTsDsl";
+  protected _base: Base$1;
+  protected _index: Index;
+  constructor(base: Base$1, index: Index);
+  analyze(ctx: AnalysisContext): void;
+  base(base: Base$1): this;
+  index(index: Index): this;
+  toAst(ctx: AstContext): ts.IndexedAccessTypeNode;
+}
+//#endregion
+//#region src/ts-dsl/type/operator.d.ts
+type Op = ts.SyntaxKind.KeyOfKeyword | ts.SyntaxKind.ReadonlyKeyword | ts.SyntaxKind.UniqueKeyword;
+type Type$2 = string | MaybeTsDsl<ts.TypeNode>;
+type TypeOperatorCtor = () => TypeOperatorTsDsl;
+declare const Mixed$43: abstract new () => TsDsl<ts.TypeOperatorNode>;
+/**
+ * Builds a TypeScript `TypeOperatorNode`, such as:
+ *
+ * - `keyof T`
+ * - `readonly U`
+ * - `unique V`
+ *
+ * This DSL provides both a generic `.operator()` API and convenient
+ * shorthand methods (`.keyof()`, `.readonly()`, `.unique()`).
+ *
+ * The node will throw during render if required fields are missing.
+ */
+declare class TypeOperatorTsDsl extends Mixed$43 {
+  readonly '~dsl' = "TypeOperatorTsDsl";
+  protected _op?: Op;
+  protected _type?: Type$2;
+  analyze(ctx: AnalysisContext): void;
+  /** Shorthand: builds `keyof T`. */
+  keyof(type: Type$2): this;
+  /** Sets the operator explicitly. */
+  operator(op: Op): this;
+  /** Shorthand: builds `readonly T`. */
+  readonly(type: Type$2): this;
+  /** Sets the target type of the operator. */
+  type(type: Type$2): this;
+  /** Shorthand: builds `unique T`. */
+  unique(type: Type$2): this;
+  toAst(ctx: AstContext): ts.TypeOperatorNode;
+  /** Throws if required fields are not set. */
+  $validate(): asserts this is this & {
+    _op: Op;
+    _type: Type$2;
   };
-} & TBase;
-type DocMixin = InstanceType<ReturnType<typeof DocMixin>>;
+  private missingRequiredCalls;
+}
+//#endregion
+//#region src/ts-dsl/type/query.d.ts
+type TypeQueryExpr = string | MaybeTsDsl<TypeTsDsl | ts.Expression>;
+type TypeQueryCtor = (expr: TypeQueryExpr) => TypeQueryTsDsl;
+declare const Mixed$42: MixinCtor<abstract new () => TsDsl<ts.TypeQueryNode>, TypeExprMethods>;
+declare class TypeQueryTsDsl extends Mixed$42 {
+  readonly '~dsl' = "TypeQueryTsDsl";
+  protected _expr: TypeQueryExpr;
+  constructor(expr: TypeQueryExpr);
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): ts.TypeQueryNode;
+}
+//#endregion
+//#region src/ts-dsl/utils/factories.d.ts
+type Ctor = (...args: Array<any>) => any;
+type Factory<T extends Ctor> = {
+  (...args: Parameters<T>): ReturnType<T>;
+  /** Sets the implementation of this factory. */
+  set(fn: T): void;
+};
+declare const f: {
+  /** Factory for creating `as` type assertion expressions (e.g. `value as Type`). */
+  as: Factory<AsCtor>;
+  /** Factory for creating property access expressions (e.g. `obj.foo`). */
+  attr: Factory<AttrCtor>;
+  /** Factory for creating await expressions (e.g. `await promise`). */
+  await: Factory<AwaitCtor>;
+  /** Factory for creating function or method call expressions (e.g. `fn(arg)`). */
+  call: Factory<CallCtor>;
+  /** Factory for creating return statements. */
+  return: Factory<ReturnCtor>;
+  /** Factories for creating type nodes. */
+  type: {
+    /** Factory for creating basic type references or type expressions (e.g. Foo or Foo<T>). */
+    expr: Factory<TypeExprCtor>;
+    /** Factory for creating indexed-access types (e.g. `Foo<T>[K]`). */
+    idx: Factory<TypeIdxCtor>;
+    /** Factory for creating type operator nodes (e.g. `readonly T`, `keyof T`, `unique T`). */
+    operator: Factory<TypeOperatorCtor>;
+    /** Factory for creating type query nodes (e.g. `typeof Foo`). */
+    query: Factory<TypeQueryCtor>;
+  };
+  /** Factory for creating `typeof` expressions (e.g. `typeof value`). */
+  typeofExpr: Factory<TypeOfExprCtor>;
+};
+//#endregion
+//#region src/ts-dsl/mixins/expr.d.ts
+interface ExprMethods extends Node {
+  /** Accesses a property on the current expression (e.g. `this.foo`). */
+  attr(...args: DropFirst<Parameters<typeof f.attr>>): ReturnType<typeof f.attr>;
+  /** Awaits the current expression (e.g. `await expr`). */
+  await(): ReturnType<typeof f.await>;
+  /** Calls the current expression (e.g. `fn(arg1, arg2)`). */
+  call(...args: DropFirst<Parameters<typeof f.call>>): ReturnType<typeof f.call>;
+  /** Produces a `return` statement returning the current expression. */
+  return(): ReturnType<typeof f.return>;
+}
+//#endregion
+//#region src/ts-dsl/expr/as.d.ts
+type AsExpr = Symbol | string | MaybeTsDsl<ts.Expression>;
+type AsType = Symbol | string | TypeTsDsl;
+type AsCtor = (expr: AsExpr, type: AsType) => AsTsDsl;
+declare const Mixed$41: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.AsExpression>, ExprMethods>, AsMethods>;
+declare class AsTsDsl extends Mixed$41 {
+  readonly '~dsl' = "AsTsDsl";
+  protected expr: Ref<AsExpr>;
+  protected type: Ref<AsType>;
+  constructor(expr: AsExpr, type: AsType);
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): ts.AsExpression;
+}
+//#endregion
+//#region src/ts-dsl/mixins/value.d.ts
+type ValueExpr = string | MaybeTsDsl<ts.Expression>;
+interface ValueMethods extends Node {
+  $value(ctx: AstContext): ts.Expression | undefined;
+  /** Sets the initializer expression (e.g. `= expr`). */
+  assign(expr: ValueExpr): this;
+}
+//#endregion
+//#region src/ts-dsl/mixins/pattern.d.ts
+interface PatternMethods extends Node {
+  /** Renders the pattern into a `BindingName`. */
+  $pattern(ctx: AstContext): ts.BindingName | undefined;
+  /** Defines an array binding pattern. */
+  array(...props: ReadonlyArray<string> | [ReadonlyArray<string>]): this;
+  /** Defines an object binding pattern. */
+  object(...props: ReadonlyArray<MaybeArray$1<string> | Record<string, string>>): this;
+  /** Adds a spread element (e.g. `...args`, `...options`) to the pattern. */
+  spread(name: string): this;
+}
+//#endregion
+//#region src/ts-dsl/layout/hint.d.ts
+type HintMaybeLazy<T> = ((ctx: AstContext) => T) | T;
+type HintFn = (d: HintTsDsl) => void;
+type HintLines = HintMaybeLazy<MaybeArray$1<string>>;
+declare class HintTsDsl extends TsDsl<ts.Node> {
+  readonly '~dsl' = "HintTsDsl";
+  protected _lines: Array<HintLines>;
+  constructor(lines?: HintLines, fn?: HintFn);
+  analyze(ctx: AnalysisContext): void;
+  add(lines: HintLines): this;
+  apply<T extends ts.Node>(ctx: AstContext, node: T): T;
+  toAst(ctx: AstContext): ts.Node;
+}
+//#endregion
+//#region src/ts-dsl/mixins/hint.d.ts
+interface HintMethods extends Node {
+  $hint<T extends ts.Node>(ctx: AstContext, node: T): T;
+  hint(lines?: HintLines, fn?: HintFn): this;
+}
 //#endregion
 //#region src/ts-dsl/mixins/modifiers.d.ts
-type Target = object & {
-  _m?(kind: ts.ModifierSyntaxKind, condition?: boolean): unknown;
+type Modifiers = {
+  modifiers: Array<ts.Modifier>;
 };
-/**
- * Mixin that adds an `abstract` modifier to a node.
- */
-declare class AbstractMixin {
+interface AbstractMethods extends Modifiers {
   /**
    * Adds the `abstract` keyword modifier if the condition is true.
    *
    * @param condition - Whether to add the modifier (default: true).
    * @returns The target object for chaining.
    */
-  abstract<T extends Target>(this: T, condition?: boolean): T;
+  abstract(condition?: boolean): this;
 }
-/**
- * Mixin that adds an `async` modifier to a node.
- */
-declare class AsyncMixin {
+interface AsyncMethods extends Modifiers {
   /**
    * Adds the `async` keyword modifier if the condition is true.
    *
    * @param condition - Whether to add the modifier (default: true).
    * @returns The target object for chaining.
    */
-  async<T extends Target>(this: T, condition?: boolean): T;
+  async(condition?: boolean): this;
 }
-/**
- * Mixin that adds a `const` modifier to a node.
- */
-declare class ConstMixin {
+interface ConstMethods extends Modifiers {
   /**
    * Adds the `const` keyword modifier if the condition is true.
    *
    * @param condition - Whether to add the modifier (default: true).
    * @returns The target object for chaining.
    */
-  const<T extends Target>(this: T, condition?: boolean): T;
+  const(condition?: boolean): this;
 }
-/**
- * Mixin that adds a `default` modifier to a node.
- */
-declare class DefaultMixin {
+interface DefaultMethods extends Modifiers {
   /**
    * Adds the `default` keyword modifier if the condition is true.
    *
    * @param condition - Whether to add the modifier (default: true).
    * @returns The target object for chaining.
    */
-  default<T extends Target>(this: T, condition?: boolean): T;
+  default(condition?: boolean): this;
 }
-/**
- * Mixin that adds an `export` modifier to a node.
- */
-declare class ExportMixin {
+interface ExportMethods extends Modifiers {
   /**
    * Adds the `export` keyword modifier if the condition is true.
    *
    * @param condition - Whether to add the modifier (default: true).
    * @returns The target object for chaining.
    */
-  export<T extends Target>(this: T, condition?: boolean): T;
+  export(condition?: boolean): this;
 }
-/**
- * Mixin that adds a `private` modifier to a node.
- */
-declare class PrivateMixin {
+interface PrivateMethods extends Modifiers {
   /**
    * Adds the `private` keyword modifier if the condition is true.
    *
    * @param condition - Whether to add the modifier (default: true).
    * @returns The target object for chaining.
    */
-  private<T extends Target>(this: T, condition?: boolean): T;
+  private(condition?: boolean): this;
 }
-/**
- * Mixin that adds a `protected` modifier to a node.
- */
-declare class ProtectedMixin {
+interface ProtectedMethods extends Modifiers {
   /**
    * Adds the `protected` keyword modifier if the condition is true.
    *
    * @param condition - Whether to add the modifier (default: true).
    * @returns The target object for chaining.
    */
-  protected<T extends Target>(this: T, condition?: boolean): T;
+  protected(condition?: boolean): this;
 }
-/**
- * Mixin that adds a `public` modifier to a node.
- */
-declare class PublicMixin {
+interface PublicMethods extends Modifiers {
   /**
    * Adds the `public` keyword modifier if the condition is true.
    *
    * @param condition - Whether to add the modifier (default: true).
    * @returns The target object for chaining.
    */
-  public<T extends Target>(this: T, condition?: boolean): T;
+  public(condition?: boolean): this;
 }
-/**
- * Mixin that adds a `readonly` modifier to a node.
- */
-declare class ReadonlyMixin {
+interface ReadonlyMethods extends Modifiers {
   /**
    * Adds the `readonly` keyword modifier if the condition is true.
    *
    * @param condition - Whether to add the modifier (default: true).
    * @returns The target object for chaining.
    */
-  readonly<T extends Target>(this: T, condition?: boolean): T;
+  readonly(condition?: boolean): this;
 }
-/**
- * Mixin that adds a `static` modifier to a node.
- */
-declare class StaticMixin {
+interface StaticMethods extends Modifiers {
   /**
    * Adds the `static` keyword modifier if the condition is true.
    *
    * @param condition - Whether to add the modifier (default: true).
    * @returns The target object for chaining.
    */
-  static<T extends Target>(this: T, condition?: boolean): T;
-}
-//#endregion
-//#region src/ts-dsl/type/param.d.ts
-declare class TypeParamTsDsl extends TypeTsDsl<ts.TypeParameterDeclaration> {
-  protected name?: string | ts.Identifier;
-  protected constraint?: string | MaybeTsDsl<TypeTsDsl> | boolean;
-  protected defaultValue?: string | MaybeTsDsl<TypeTsDsl> | boolean;
-  constructor(name?: string | ts.Identifier, fn?: (name: TypeParamTsDsl) => void);
-  default(value: string | MaybeTsDsl<TypeTsDsl> | boolean): this;
-  extends(constraint: string | MaybeTsDsl<TypeTsDsl> | boolean): this;
-  $render(): ts.TypeParameterDeclaration;
+  static(condition?: boolean): this;
 }
 //#endregion
-//#region src/ts-dsl/mixins/type-params.d.ts
-declare class TypeParamsMixin extends TsDsl {
-  protected _generics?: Array<string | MaybeTsDsl<TypeParamTsDsl>>;
-  /** Adds a single type parameter (e.g. `T` in `Array<T>`). */
-  generic(...args: ConstructorParameters<typeof TypeParamTsDsl>): this;
-  /** Adds type parameters (e.g. `Map<string, T>`). */
-  generics(...args: ReadonlyArray<string | MaybeTsDsl<TypeParamTsDsl>>): this;
-  /** Returns the type parameters as an array of ts.TypeParameterDeclaration nodes. */
-  protected $generics(): ReadonlyArray<ts.TypeParameterDeclaration> | undefined;
-  $render(): ts.Node;
+//#region src/ts-dsl/layout/doc.d.ts
+type DocMaybeLazy<T> = ((ctx: AstContext) => T) | T;
+type DocFn = (d: DocTsDsl) => void;
+type DocLines = DocMaybeLazy<MaybeArray$1<string>>;
+declare class DocTsDsl extends TsDsl<ts.Node> {
+  readonly '~dsl' = "DocTsDsl";
+  protected _lines: Array<DocLines>;
+  constructor(lines?: DocLines, fn?: DocFn);
+  analyze(ctx: AnalysisContext): void;
+  add(lines: DocLines): this;
+  apply<T extends ts.Node>(ctx: AstContext, node: T): T;
+  toAst(ctx: AstContext): ts.Node;
 }
 //#endregion
-//#region src/ts-dsl/mixins/value.d.ts
-declare class ValueMixin extends TsDsl {
-  protected value?: string | MaybeTsDsl<ts.Expression>;
-  /** Sets the initializer expression (e.g. `= expr`). */
-  assign<T extends this>(this: T, expr: string | MaybeTsDsl<ts.Expression>): T;
-  protected $value(): ts.Expression | undefined;
-  $render(): ts.Node;
+//#region src/ts-dsl/mixins/doc.d.ts
+interface DocMethods extends Node {
+  $docs<T extends ts.Node>(ctx: AstContext, node: T): T;
+  doc(lines?: DocLines, fn?: DocFn): this;
 }
 //#endregion
-//#region src/ts-dsl/decl/field.d.ts
-declare class FieldTsDsl extends TsDsl<ts.PropertyDeclaration> {
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  protected name: string;
+//#region src/ts-dsl/stmt/var.d.ts
+type VarName = Symbol | string;
+declare const Mixed$40: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.VariableStatement>, ValueMethods>, PatternMethods>, HintMethods>, ExportMethods>, DocMethods>, DefaultMethods>;
+declare class VarTsDsl extends Mixed$40 {
+  readonly '~dsl' = "VarTsDsl";
+  protected kind: ts.NodeFlags;
+  protected name?: Ref<VarName>;
   protected _type?: TypeTsDsl;
-  constructor(name: string, fn?: (f: FieldTsDsl) => void);
-  /** Sets the field type. */
+  constructor(name?: VarName);
+  analyze(ctx: AnalysisContext): void;
+  const(): this;
+  let(): this;
+  /** Sets the variable type. */
   type(type: string | TypeTsDsl): this;
-  /** Builds the `PropertyDeclaration` node. */
-  $render(): ts.PropertyDeclaration;
+  var(): this;
+  toAst(ctx: AstContext): ts.VariableStatement;
 }
-interface FieldTsDsl extends DecoratorMixin, DocMixin, PrivateMixin, ProtectedMixin, PublicMixin, ReadonlyMixin, StaticMixin, ValueMixin {}
 //#endregion
-//#region src/ts-dsl/mixins/do.d.ts
-/**
- * Adds `.do()` for appending statements or expressions to a body.
- */
-declare class DoMixin extends TsDsl {
-  protected _do?: Array<MaybeTsDsl<ts.Expression | ts.Statement>>;
-  /** Adds one or more expressions/statements to the body. */
-  do(...items: ReadonlyArray<MaybeTsDsl<ts.Expression | ts.Statement>>): this;
-  /** Renders the collected `.do()` calls into an array of `Statement` nodes. */
-  protected $do(): ReadonlyArray<ts.Statement>;
-  $render(): ts.Node;
+//#region src/ts-dsl/decl/decorator.d.ts
+type DecoratorName = Symbol | string | MaybeTsDsl<ts.Expression>;
+declare const Mixed$39: MixinCtor<abstract new () => TsDsl<ts.Decorator>, ArgsMethods>;
+declare class DecoratorTsDsl extends Mixed$39 {
+  readonly '~dsl' = "DecoratorTsDsl";
+  protected name: Ref<DecoratorName>;
+  constructor(name: DecoratorName, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>);
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): ts.Decorator;
 }
 //#endregion
-//#region src/ts-dsl/mixins/optional.d.ts
-declare class OptionalMixin {
-  protected _optional?: boolean;
-  /** Marks the node as optional when the condition is true. */
-  optional<T extends this>(this: T, condition?: boolean): T;
-  /** Marks the node as required when the condition is true. */
-  required<T extends this>(this: T, condition?: boolean): T;
+//#region src/ts-dsl/decl/member.d.ts
+type Value$2 = string | number | MaybeTsDsl<ts.Expression>;
+type ValueFn$1 = Value$2 | ((m: EnumMemberTsDsl) => void);
+declare const Mixed$38: MixinCtor<abstract new () => TsDsl<ts.EnumMember>, DocMethods>;
+declare class EnumMemberTsDsl extends Mixed$38 {
+  readonly '~dsl' = "EnumMemberTsDsl";
+  private _name;
+  private _value?;
+  constructor(name: string, value?: ValueFn$1);
+  analyze(ctx: AnalysisContext): void;
+  /** Sets the enum member value. */
+  value(value?: Value$2): this;
+  toAst(ctx: AstContext): ts.EnumMember;
 }
 //#endregion
-//#region src/ts-dsl/decl/pattern.d.ts
-/**
- * Builds binding patterns (e.g. `{ foo, bar }`, `[a, b, ...rest]`).
- */
-declare class PatternTsDsl extends TsDsl<ts.BindingName> {
-  protected pattern?: {
-    kind: 'array';
-    values: ReadonlyArray<string>;
-  } | {
-    kind: 'object';
-    values: Record<string, string>;
-  };
-  protected _spread?: string;
-  /** Defines an array pattern (e.g. `[a, b, c]`). */
-  array(...props: ReadonlyArray<string> | [ReadonlyArray<string>]): this;
-  /** Defines an object pattern (e.g. `{ a, b: alias }`). */
-  object(...props: ReadonlyArray<MaybeArray$1<string> | Record<string, string>>): this;
-  /** Adds a spread element (e.g. `...rest`, `...options`, `...args`). */
-  spread(name: string): this;
-  /** Builds and returns a BindingName (ObjectBindingPattern, ArrayBindingPattern, or Identifier). */
-  $render(): ts.BindingName;
-  private createSpread;
+//#region src/ts-dsl/decl/enum.d.ts
+type EnumName = Symbol | string;
+type Value$1 = string | number | MaybeTsDsl<ts.Expression>;
+type ValueFn = Value$1 | ((m: EnumMemberTsDsl) => void);
+declare const Mixed$37: MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.EnumDeclaration>, ExportMethods>, DocMethods>, ConstMethods>;
+declare class EnumTsDsl extends Mixed$37 {
+  readonly '~dsl' = "EnumTsDsl";
+  private _members;
+  private _name;
+  constructor(name: EnumName, fn?: (e: EnumTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
+  /** Adds an enum member. */
+  member(name: string, value?: ValueFn): this;
+  /** Adds multiple enum members. */
+  members(...members: ReadonlyArray<EnumMemberTsDsl>): this;
+  toAst(ctx: AstContext): ts.EnumDeclaration;
 }
 //#endregion
-//#region src/ts-dsl/mixins/pattern.d.ts
-/**
- * Mixin providing `.array()`, `.object()`, and `.spread()` methods for defining destructuring patterns.
- */
-declare class PatternMixin extends TsDsl {
-  protected pattern?: PatternTsDsl;
-  /** Defines an array binding pattern. */
-  array(...props: ReadonlyArray<string> | [ReadonlyArray<string>]): this;
-  /** Defines an object binding pattern. */
-  object(...props: ReadonlyArray<MaybeArray$1<string> | Record<string, string>>): this;
-  /** Adds a spread element (e.g. `...args`, `...options`) to the pattern. */
-  spread(name: string): this;
-  /** Renders the pattern into a `BindingName`. */
-  protected $pattern(): ts.BindingName | undefined;
-  $render(): ts.Node;
+//#region src/ts-dsl/mixins/decorator.d.ts
+interface DecoratorMethods extends Node {
+  /** Renders the decorators into an array of `ts.Decorator`s. */
+  $decorators(ctx: AstContext): ReadonlyArray<ts.Decorator>;
+  /** Adds a decorator (e.g. `@sealed({ in: 'root' })`). */
+  decorator(name: Symbol | string | MaybeTsDsl<ts.Expression>, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>): this;
+}
+//#endregion
+//#region src/ts-dsl/decl/field.d.ts
+type FieldName = Symbol | string;
+type FieldType = TypeExprName | TypeTsDsl;
+declare const Mixed$36: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.PropertyDeclaration>, ValueMethods>, StaticMethods>, ReadonlyMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, OptionalMethods>, DocMethods>, DecoratorMethods>;
+declare class FieldTsDsl extends Mixed$36 {
+  readonly '~dsl' = "FieldTsDsl";
+  protected name: FieldName;
+  protected _type?: TypeTsDsl;
+  constructor(name: FieldName, fn?: (f: FieldTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
+  /** Sets the field type. */
+  type(type: FieldType): this;
+  toAst(ctx: AstContext): ts.PropertyDeclaration;
+}
+//#endregion
+//#region src/ts-dsl/mixins/type-returns.d.ts
+interface TypeReturnsMethods extends Node {
+  /** Returns the return type node. */
+  $returns(ctx: AstContext): ts.TypeNode | undefined;
+  /** Sets the return type. */
+  returns(type: TypeExprName | TypeTsDsl): this;
 }
 //#endregion
 //#region src/ts-dsl/decl/param.d.ts
-declare class ParamTsDsl extends TsDsl<ts.ParameterDeclaration> {
-  protected name?: string;
+type ParamName = Symbol | string;
+type ParamCtor = (name: ParamName | ((p: ParamTsDsl) => void), fn?: (p: ParamTsDsl) => void) => ParamTsDsl;
+declare const Mixed$35: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ParameterDeclaration>, ValueMethods>, PatternMethods>, OptionalMethods>, DecoratorMethods>;
+declare class ParamTsDsl extends Mixed$35 {
+  readonly '~dsl' = "ParamTsDsl";
+  protected name?: Ref<ParamName>;
   protected _type?: TypeTsDsl;
-  constructor(name: string | ((p: ParamTsDsl) => void), fn?: (p: ParamTsDsl) => void);
+  constructor(name: ParamName | ((p: ParamTsDsl) => void), fn?: (p: ParamTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
   /** Sets the parameter type. */
   type(type: string | TypeTsDsl): this;
-  $render(): ts.ParameterDeclaration;
+  toAst(ctx: AstContext): ts.ParameterDeclaration;
 }
-interface ParamTsDsl extends DecoratorMixin, OptionalMixin, PatternMixin, ValueMixin {}
 //#endregion
 //#region src/ts-dsl/mixins/param.d.ts
-declare class ParamMixin extends TsDsl {
-  protected _params?: Array<MaybeTsDsl<ts.ParameterDeclaration>>;
+interface ParamMethods extends Node {
+  /** Renders the parameters into an array of `ParameterDeclaration`s. */
+  $params(ast: AstContext): ReadonlyArray<ts.ParameterDeclaration>;
   /** Adds a parameter. */
-  param(name: string | ((p: ParamTsDsl) => void), fn?: (p: ParamTsDsl) => void): this;
+  param(...args: Parameters<ParamCtor>): this;
   /** Adds multiple parameters. */
   params(...params: ReadonlyArray<MaybeTsDsl<ts.ParameterDeclaration>>): this;
-  /** Renders the parameters into an array of `ParameterDeclaration`s. */
-  protected $params(): ReadonlyArray<ts.ParameterDeclaration>;
-  $render(): ts.Node;
-}
-//#endregion
-//#region src/ts-dsl/decl/init.d.ts
-declare class InitTsDsl extends TsDsl<ts.ConstructorDeclaration> {
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  constructor(fn?: (i: InitTsDsl) => void);
-  /** Builds the `ConstructorDeclaration` node. */
-  $render(): ts.ConstructorDeclaration;
-}
-interface InitTsDsl extends DecoratorMixin, DoMixin, DocMixin, ParamMixin, PrivateMixin, ProtectedMixin, PublicMixin {}
-//#endregion
-//#region src/ts-dsl/decl/method.d.ts
-declare class MethodTsDsl extends TsDsl<ts.MethodDeclaration> {
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  protected name: string;
-  protected _returns?: TypeTsDsl;
-  constructor(name: string, fn?: (m: MethodTsDsl) => void);
-  /** Sets the return type. */
-  returns(type: string | TypeTsDsl): this;
-  /** Builds the `MethodDeclaration` node. */
-  $render(): ts.MethodDeclaration;
-}
-interface MethodTsDsl extends AbstractMixin, AsyncMixin, DecoratorMixin, DoMixin, DocMixin, OptionalMixin, ParamMixin, PrivateMixin, ProtectedMixin, PublicMixin, StaticMixin, TypeParamsMixin {}
-//#endregion
-//#region src/ts-dsl/decl/class.d.ts
-declare class ClassTsDsl extends TsDsl<ts.ClassDeclaration> {
-  protected heritageClauses: Array<ts.HeritageClause>;
-  protected body: Array<MaybeTsDsl<ts.ClassElement | NewlineTsDsl>>;
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  protected name: string;
-  constructor(name: string);
-  /** Adds one or more class members (fields, methods, etc.). */
-  do(...items: ReadonlyArray<MaybeTsDsl<ts.ClassElement | ts.Node>>): this;
-  /** Adds a base class to extend from. */
-  extends(base?: string | ts.Expression | false | null): this;
-  /** Adds a class field. */
-  field(name: string, fn?: (f: FieldTsDsl) => void): this;
-  /** Adds a class constructor. */
-  init(fn?: (i: InitTsDsl) => void): this;
-  /** Adds a class method. */
-  method(name: string, fn?: (m: MethodTsDsl) => void): this;
-  /** Inserts an empty line between members for formatting. */
-  newline(): this;
-  /** Builds the `ClassDeclaration` node. */
-  $render(): ts.ClassDeclaration;
 }
-interface ClassTsDsl extends AbstractMixin, DecoratorMixin, DefaultMixin, DocMixin, ExportMixin, TypeParamsMixin {}
 //#endregion
-//#region src/ts-dsl/decl/member.d.ts
-type Value$1 = string | number | MaybeTsDsl<ts.Expression>;
-type ValueFn$1 = Value$1 | ((m: EnumMemberTsDsl) => void);
-declare class EnumMemberTsDsl extends TsDsl<ts.EnumMember> {
-  private _name;
-  private _value?;
-  constructor(name: string, value?: ValueFn$1);
-  /** Sets the enum member value. */
-  value(value?: Value$1): this;
-  $render(): ts.EnumMember;
+//#region src/ts-dsl/mixins/do.d.ts
+type DoExpr = MaybeTsDsl<ts.Expression | ts.Statement>;
+interface DoMethods extends Node {
+  /** Renders the collected `.do()` calls into an array of `Statement` nodes. */
+  $do(ctx: AstContext): ReadonlyArray<ts.Statement>;
+  _do: Array<DoExpr>;
+  /** Adds one or more expressions/statements to the body. */
+  do(...items: ReadonlyArray<DoExpr>): this;
 }
-interface EnumMemberTsDsl extends DocMixin {}
 //#endregion
-//#region src/ts-dsl/decl/enum.d.ts
-type Value = string | number | MaybeTsDsl<ts.Expression>;
-type ValueFn = Value | ((m: EnumMemberTsDsl) => void);
-declare class EnumTsDsl extends TsDsl<ts.EnumDeclaration> {
-  private _members;
-  private _name;
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  constructor(name: string | ts.Identifier, fn?: (e: EnumTsDsl) => void);
-  /** Adds an enum member. */
-  member(name: string, value?: ValueFn): this;
-  /** Adds multiple enum members. */
-  members(...members: ReadonlyArray<EnumMemberTsDsl>): this;
-  /** Renders the enum declaration. */
-  $render(): ts.EnumDeclaration;
+//#region src/ts-dsl/decl/getter.d.ts
+type GetterName = string | ts.PropertyName;
+declare const Mixed$34: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.GetAccessorDeclaration>, TypeReturnsMethods>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AbstractMethods>;
+declare class GetterTsDsl extends Mixed$34 {
+  readonly '~dsl' = "GetterTsDsl";
+  protected name: GetterName;
+  constructor(name: GetterName, fn?: (g: GetterTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): ts.GetAccessorDeclaration;
 }
-interface EnumTsDsl extends ConstMixin, DocMixin, ExportMixin {}
 //#endregion
-//#region src/ts-dsl/expr/binary.d.ts
-type Expr$3 = string | MaybeTsDsl<ts.Expression>;
-type Op$1 = Operator | ts.BinaryOperator;
-type Operator = '!=' | '!==' | '&&' | '*' | '+' | '-' | '/' | '<' | '<=' | '=' | '==' | '===' | '>' | '>=' | '??' | '||';
-declare class BinaryTsDsl extends TsDsl<ts.BinaryExpression> {
-  protected _base: Expr$3;
-  protected _expr?: Expr$3;
-  protected _op?: Op$1;
-  constructor(base: Expr$3, op?: Op$1, expr?: Expr$3);
-  /** Logical AND — `this && expr` */
-  and(expr: Expr$3): this;
-  /** Creates an assignment expression (e.g. `this = expr`). */
-  assign(expr: Expr$3): this;
-  /** Nullish coalescing — `this ?? expr` */
-  coalesce(expr: Expr$3): this;
-  /** Division — `this / expr` */
-  div(expr: Expr$3): this;
-  /** Strict equality — `this === expr` */
-  eq(expr: Expr$3): this;
-  /** Greater than — `this > expr` */
-  gt(expr: Expr$3): this;
-  /** Greater than or equal — `this >= expr` */
-  gte(expr: Expr$3): this;
-  /** Loose equality — `this == expr` */
-  looseEq(expr: Expr$3): this;
-  /** Loose inequality — `this != expr` */
-  looseNeq(expr: Expr$3): this;
-  /** Less than — `this < expr` */
-  lt(expr: Expr$3): this;
-  /** Less than or equal — `this <= expr` */
-  lte(expr: Expr$3): this;
-  /** Subtraction — `this - expr` */
-  minus(expr: Expr$3): this;
-  /** Strict inequality — `this !== expr` */
-  neq(expr: Expr$3): this;
-  /** Logical OR — `this || expr` */
-  or(expr: Expr$3): this;
-  /** Addition — `this + expr` */
-  plus(expr: Expr$3): this;
-  /** Multiplication — `this * expr` */
-  times(expr: Expr$3): this;
-  $render(): ts.BinaryExpression;
-  /** Sets the binary operator and right-hand operand for this expression. */
-  private opAndExpr;
-  private opToToken;
+//#region src/ts-dsl/stmt/if.d.ts
+type IfCondition = string | MaybeTsDsl<ts.Expression>;
+declare const Mixed$33: MixinCtor<abstract new () => TsDsl<ts.IfStatement>, DoMethods>;
+declare class IfTsDsl extends Mixed$33 {
+  readonly '~dsl' = "IfTsDsl";
+  protected _condition?: IfCondition;
+  protected _else?: Array<DoExpr>;
+  constructor(condition?: IfCondition);
+  analyze(ctx: AnalysisContext): void;
+  condition(condition: IfCondition): this;
+  otherwise(...items: Array<DoExpr>): this;
+  toAst(ctx: AstContext): ts.IfStatement;
+}
+//#endregion
+//#region src/ts-dsl/utils/lazy.d.ts
+type LazyThunk<T extends ts.Node> = (ctx: AstContext) => TsDsl<T>;
+declare class LazyTsDsl<T extends ts.Node = ts.Node> extends TsDsl<T> {
+  readonly '~dsl' = "LazyTsDsl";
+  private _thunk;
+  constructor(thunk: LazyThunk<T>);
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): T;
 }
-interface BinaryTsDsl extends AsMixin, ExprMixin {}
 //#endregion
-//#region src/ts-dsl/mixins/operator.d.ts
-type This = string | MaybeTsDsl<ts.Expression>;
-type Expr$2 = string | MaybeTsDsl<ts.Expression>;
-declare class OperatorMixin {
-  /** Logical AND — `this && expr` */
-  and(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Creates an assignment expression (e.g. `this = expr`). */
-  assign(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Nullish coalescing — `this ?? expr` */
-  coalesce(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Division — `this / expr` */
-  div(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Strict equality — `this === expr` */
-  eq(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Greater than — `this > expr` */
-  gt(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Greater than or equal — `this >= expr` */
-  gte(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Loose equality — `this == expr` */
-  looseEq(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Loose inequality — `this != expr` */
-  looseNeq(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Less than — `this < expr` */
-  lt(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Less than or equal — `this <= expr` */
-  lte(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Subtraction — `this - expr` */
-  minus(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Strict inequality — `this !== expr` */
-  neq(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Logical OR — `this || expr` */
-  or(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Addition — `this + expr` */
-  plus(this: This, expr: Expr$2): BinaryTsDsl;
-  /** Multiplication — `this * expr` */
-  times(this: This, expr: Expr$2): BinaryTsDsl;
+//#region src/ts-dsl/expr/new.d.ts
+type NewExpr = Symbol | string | MaybeTsDsl<ts.Expression>;
+declare const Mixed$32: MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.NewExpression>, TypeArgsMethods>, ExprMethods>, ArgsMethods>;
+declare class NewTsDsl extends Mixed$32 {
+  readonly '~dsl' = "NewTsDsl";
+  protected classExpr: Ref<NewExpr>;
+  constructor(classExpr: NewExpr, ...args: ReadonlyArray<NewExpr>);
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): ts.NewExpression;
 }
 //#endregion
-//#region src/ts-dsl/expr/attr.d.ts
-declare class AttrTsDsl extends TsDsl<ts.PropertyAccessExpression | ts.ElementAccessExpression> {
-  protected left: string | MaybeTsDsl<ts.Expression>;
-  protected right: string | ts.MemberName | number;
-  constructor(left: string | MaybeTsDsl<ts.Expression>, right: string | ts.MemberName | number);
-  $render(): ts.PropertyAccessExpression | ts.ElementAccessExpression;
+//#region src/ts-dsl/layout/note.d.ts
+type NoteMaybeLazy<T> = ((ctx: AstContext) => T) | T;
+type NoteFn = (d: NoteTsDsl) => void;
+type NoteLines = NoteMaybeLazy<MaybeArray$1<string>>;
+declare class NoteTsDsl extends TsDsl<ts.Node> {
+  readonly '~dsl' = "NoteTsDsl";
+  protected _lines: Array<NoteLines>;
+  constructor(lines?: NoteLines, fn?: NoteFn);
+  analyze(ctx: AnalysisContext): void;
+  add(lines: NoteLines): this;
+  apply<T extends ts.Node>(ctx: AstContext, node: T): T;
+  toAst(ctx: AstContext): ts.Node;
 }
-interface AttrTsDsl extends AsMixin, ExprMixin, OperatorMixin, OptionalMixin {}
 //#endregion
-//#region src/ts-dsl/expr/await.d.ts
-declare class AwaitTsDsl extends TsDsl<ts.AwaitExpression> {
-  protected _awaitExpr: string | MaybeTsDsl<ts.Expression>;
-  constructor(expr: string | MaybeTsDsl<ts.Expression>);
-  $render(): ts.AwaitExpression;
+//#region src/ts-dsl/decl/setter.d.ts
+type SetterName = string | ts.PropertyName;
+declare const Mixed$31: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.SetAccessorDeclaration>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AbstractMethods>;
+declare class SetterTsDsl extends Mixed$31 {
+  readonly '~dsl' = "SetterTsDsl";
+  protected name: SetterName;
+  constructor(name: SetterName, fn?: (s: SetterTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): ts.SetAccessorDeclaration;
 }
-interface AwaitTsDsl extends ExprMixin {}
 //#endregion
-//#region src/ts-dsl/mixins/type-args.d.ts
-declare class TypeArgsMixin extends TsDsl {
-  protected _generics?: Array<string | MaybeTsDsl<TypeTsDsl>>;
-  /** Adds a single type argument (e.g. `string` in `Foo<string>`). */
-  generic(arg: string | MaybeTsDsl<TypeTsDsl>): this;
-  /** Adds type arguments (e.g. `Map<string, number>`). */
-  generics(...args: ReadonlyArray<string | MaybeTsDsl<TypeTsDsl>>): this;
-  /** Returns the type arguments as an array of ts.TypeNode nodes. */
-  protected $generics(): ReadonlyArray<ts.TypeNode> | undefined;
-  $render(): ts.Node;
+//#region src/ts-dsl/expr/template.d.ts
+type TemplatePart = Symbol | string | MaybeTsDsl<ts.Expression>;
+declare const Mixed$30: abstract new () => TsDsl<ts.NoSubstitutionTemplateLiteral | ts.TemplateExpression>;
+declare class TemplateTsDsl extends Mixed$30 {
+  readonly '~dsl' = "TemplateTsDsl";
+  protected parts: Array<Ref<TemplatePart>>;
+  constructor(value?: TemplatePart);
+  analyze(ctx: AnalysisContext): void;
+  add(value: TemplatePart): this;
+  toAst(ctx: AstContext): ts.NoSubstitutionTemplateLiteral | ts.TemplateExpression;
 }
 //#endregion
-//#region src/ts-dsl/expr/call.d.ts
-declare class CallTsDsl extends TsDsl<ts.CallExpression> {
-  protected _callee: string | MaybeTsDsl<ts.Expression>;
-  constructor(callee: string | MaybeTsDsl<ts.Expression>, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression> | undefined>);
-  $render(): ts.CallExpression;
+//#region src/ts-dsl/type/param.d.ts
+type TypeParamName = Symbol | string;
+type TypeParamExpr = Symbol | string | boolean | MaybeTsDsl<TypeTsDsl>;
+declare const Mixed$29: abstract new () => TsDsl<ts.TypeParameterDeclaration>;
+declare class TypeParamTsDsl extends Mixed$29 {
+  readonly '~dsl' = "TypeParamTsDsl";
+  protected constraint?: Ref<TypeParamExpr>;
+  protected defaultValue?: Ref<TypeParamExpr>;
+  protected name?: Ref<TypeParamName>;
+  constructor(name?: TypeParamName, fn?: (name: TypeParamTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
+  default(value: TypeParamExpr): this;
+  extends(constraint: TypeParamExpr): this;
+  toAst(ctx: AstContext): ts.TypeParameterDeclaration;
 }
-interface CallTsDsl extends ArgsMixin, AsMixin, ExprMixin, TypeArgsMixin {}
 //#endregion
-//#region src/ts-dsl/stmt/return.d.ts
-declare class ReturnTsDsl extends TsDsl<ts.ReturnStatement> {
-  protected _returnExpr?: string | MaybeTsDsl<ts.Expression>;
-  constructor(expr?: string | MaybeTsDsl<ts.Expression>);
-  $render(): ts.ReturnStatement;
+//#region src/ts-dsl/mixins/type-params.d.ts
+interface TypeParamsMethods extends Node {
+  /** Returns the type parameters as an array of ts.TypeParameterDeclaration nodes. */
+  $generics(ast: AstContext): ReadonlyArray<ts.TypeParameterDeclaration> | undefined;
+  /** Adds a single type parameter (e.g. `T` in `Array<T>`). */
+  generic(...args: ConstructorParameters<typeof TypeParamTsDsl>): this;
+  /** Adds type parameters (e.g. `Map<string, T>`). */
+  generics(...args: ReadonlyArray<Symbol | string | MaybeTsDsl<TypeParamTsDsl>>): this;
 }
-interface ReturnTsDsl extends ExprMixin {}
 //#endregion
-//#region src/ts-dsl/mixins/expr.d.ts
-declare class ExprMixin {
-  /** Accesses a property on the current expression (e.g. `this.foo`). */
-  attr(this: string | MaybeTsDsl<ts.Expression>, name: string | ts.MemberName | number): AttrTsDsl;
-  /** Awaits the current expression (e.g. `await expr`). */
-  await(this: string | MaybeTsDsl<ts.Expression>): AwaitTsDsl;
-  /** Calls the current expression (e.g. `fn(arg1, arg2)`). */
-  call(this: string | MaybeTsDsl<ts.Expression>, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression> | undefined>): CallTsDsl;
-  /** Produces a `return` statement returning the current expression. */
-  return(this: string | MaybeTsDsl<ts.Expression>): ReturnTsDsl;
+//#region src/ts-dsl/decl/init.d.ts
+declare const Mixed$28: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ConstructorDeclaration>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>;
+declare class InitTsDsl extends Mixed$28 {
+  readonly '~dsl' = "InitTsDsl";
+  constructor(fn?: (i: InitTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): ts.ConstructorDeclaration;
 }
 //#endregion
-//#region src/ts-dsl/expr/as.d.ts
-declare class AsTsDsl extends TsDsl<ts.AsExpression> {
-  protected expr: string | MaybeTsDsl<ts.Expression>;
-  protected type: string | TypeTsDsl;
-  constructor(expr: string | MaybeTsDsl<ts.Expression>, type: string | TypeTsDsl);
-  $render(): ts.AsExpression;
+//#region src/ts-dsl/decl/method.d.ts
+declare const Mixed$27: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.MethodDeclaration>, TypeReturnsMethods>, TypeParamsMethods>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, OptionalMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AbstractMethods>;
+declare class MethodTsDsl extends Mixed$27 {
+  readonly '~dsl' = "MethodTsDsl";
+  protected name: string;
+  constructor(name: string, fn?: (m: MethodTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): ts.MethodDeclaration;
 }
-interface AsTsDsl extends AsMixin, ExprMixin {}
 //#endregion
-//#region src/ts-dsl/mixins/as.d.ts
-declare class AsMixin {
-  /** Creates an `as` type assertion expression (e.g. `value as Type`). */
-  as(this: string | MaybeTsDsl<ts.Expression>, type: string | TypeTsDsl): AsTsDsl;
+//#region src/ts-dsl/decl/class.d.ts
+type Base = Symbol | string;
+type Name$1 = Symbol | string;
+type Body = Array<MaybeTsDsl<ts.ClassElement | ts.Node>>;
+declare const Mixed$26: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ClassDeclaration>, TypeParamsMethods>, ExportMethods>, DocMethods>, DefaultMethods>, DecoratorMethods>, AbstractMethods>;
+declare class ClassTsDsl extends Mixed$26 {
+  readonly '~dsl' = "ClassTsDsl";
+  protected baseClass?: Ref<Base>;
+  protected body: Body;
+  protected name: Ref<Name$1>;
+  constructor(name: Name$1);
+  analyze(ctx: AnalysisContext): void;
+  /** Adds one or more class members (fields, methods, etc.). */
+  do(...items: Body): this;
+  /** Records a base class to extend from. */
+  extends(base?: Base): this;
+  /** Adds a class field. */
+  field(name: FieldName, fn?: (f: FieldTsDsl) => void): this;
+  /** Adds a class constructor. */
+  init(fn?: (i: InitTsDsl) => void): this;
+  /** Adds a class method. */
+  method(name: string, fn?: (m: MethodTsDsl) => void): this;
+  /** Inserts an empty line between members for formatting. */
+  newline(): this;
+  toAst(ctx: AstContext): ts.ClassDeclaration;
+  /** Builds heritage clauses (extends). */
+  private _heritage;
 }
 //#endregion
 //#region src/ts-dsl/decl/func.d.ts
 type FuncMode = 'arrow' | 'decl' | 'expr';
-declare class ImplFuncTsDsl<M extends FuncMode = 'arrow'> extends TsDsl<M extends 'decl' ? ts.FunctionDeclaration : M extends 'expr' ? ts.FunctionExpression : ts.ArrowFunction> {
-  protected mode: FuncMode;
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  protected name?: string;
-  protected _returns?: TypeTsDsl;
+type FuncName = Symbol | string;
+declare const Mixed$25: MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ArrowFunction>, TypeReturnsMethods>, TypeParamsMethods>, StaticMethods>, PublicMethods>, ProtectedMethods>, PrivateMethods>, ParamMethods>, DocMethods>, DoMethods>, DecoratorMethods>, AsyncMethods>, AsMethods>, AbstractMethods>;
+declare class ImplFuncTsDsl<M extends FuncMode = 'arrow'> extends Mixed$25 {
+  readonly '~dsl' = "FuncTsDsl";
+  protected mode?: FuncMode;
+  protected name?: Ref<FuncName>;
   constructor();
   constructor(fn: (f: ImplFuncTsDsl<'arrow'>) => void);
-  constructor(name: string);
-  constructor(name: string, fn: (f: ImplFuncTsDsl<'decl'>) => void);
+  constructor(name: FuncName);
+  constructor(name: FuncName, fn: (f: ImplFuncTsDsl<'decl'>) => void);
+  analyze(ctx: AnalysisContext): void;
   /** Switches the function to an arrow function form. */
   arrow(): FuncTsDsl<'arrow'>;
   /** Switches the function to a function declaration form. */
   decl(): FuncTsDsl<'decl'>;
   /** Switches the function to a function expression form. */
   expr(): FuncTsDsl<'expr'>;
-  /** Sets the return type. */
-  returns(type: string | TypeTsDsl): this;
-  $render(): M extends 'decl' ? ts.FunctionDeclaration : M extends 'expr' ? ts.FunctionExpression : ts.ArrowFunction;
+  toAst(ctx: AstContext): M extends 'decl' ? ts.FunctionDeclaration : M extends 'expr' ? ts.FunctionExpression : ts.ArrowFunction;
 }
-interface ImplFuncTsDsl extends AbstractMixin, AsMixin, AsyncMixin, DecoratorMixin, DoMixin, DocMixin, ParamMixin, PrivateMixin, ProtectedMixin, PublicMixin, StaticMixin, TypeParamsMixin {}
 declare const FuncTsDsl: {
   new (): FuncTsDsl<"arrow">;
   new (fn: (f: FuncTsDsl<"arrow">) => void): FuncTsDsl<"arrow">;
@@ -6988,44 +7243,48 @@ declare const FuncTsDsl: {
 } & typeof ImplFuncTsDsl;
 type FuncTsDsl<M extends FuncMode = 'arrow'> = ImplFuncTsDsl<M>;
 //#endregion
-//#region src/ts-dsl/decl/getter.d.ts
-declare class GetterTsDsl extends TsDsl<ts.GetAccessorDeclaration> {
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  protected name: string | ts.PropertyName;
-  constructor(name: string | ts.PropertyName, fn?: (g: GetterTsDsl) => void);
-  $render(): ts.GetAccessorDeclaration;
-}
-interface GetterTsDsl extends AbstractMixin, AsyncMixin, DecoratorMixin, DoMixin, DocMixin, ParamMixin, PrivateMixin, ProtectedMixin, PublicMixin, StaticMixin {}
-//#endregion
-//#region src/ts-dsl/decl/setter.d.ts
-declare class SetterTsDsl extends TsDsl<ts.SetAccessorDeclaration> {
-  protected modifiers: {
-    list: () => ts.Modifier[];
+//#region src/ts-dsl/decl/pattern.d.ts
+declare const Mixed$24: abstract new () => TsDsl<ts.BindingName>;
+/**
+ * Builds binding patterns (e.g. `{ foo, bar }`, `[a, b, ...rest]`).
+ */
+declare class PatternTsDsl extends Mixed$24 {
+  readonly '~dsl' = "PatternTsDsl";
+  protected pattern?: {
+    kind: 'array';
+    values: ReadonlyArray<string>;
+  } | {
+    kind: 'object';
+    values: Record<string, string>;
   };
-  protected name: string | ts.PropertyName;
-  constructor(name: string | ts.PropertyName, fn?: (s: SetterTsDsl) => void);
-  $render(): ts.SetAccessorDeclaration;
+  protected _spread?: string;
+  analyze(ctx: AnalysisContext): void;
+  /** Defines an array pattern (e.g. `[a, b, c]`). */
+  array(...props: ReadonlyArray<string> | [ReadonlyArray<string>]): this;
+  /** Defines an object pattern (e.g. `{ a, b: alias }`). */
+  object(...props: ReadonlyArray<MaybeArray$1<string> | Record<string, string>>): this;
+  /** Adds a spread element (e.g. `...rest`, `...options`, `...args`). */
+  spread(name: string): this;
+  toAst(ctx: AstContext): ts.ObjectBindingPattern | ts.ArrayBindingPattern;
+  private createSpread;
 }
-interface SetterTsDsl extends AbstractMixin, AsyncMixin, DecoratorMixin, DoMixin, DocMixin, ParamMixin, PrivateMixin, ProtectedMixin, PublicMixin, StaticMixin {}
 //#endregion
 //#region src/ts-dsl/mixins/layout.d.ts
-declare class LayoutMixin {
-  protected static readonly DEFAULT_THRESHOLD = 3;
-  protected layout: boolean | number | undefined;
+interface LayoutMethods extends Node {
+  /** Computes whether output should be multiline based on layout setting and element count. */
+  $multiline(count: number): boolean;
   /** Sets automatic line output with optional threshold (default: 3). */
   auto(threshold?: number): this;
   /** Sets single line output. */
   inline(): this;
   /** Sets multi line output. */
   pretty(): this;
-  /** Computes whether output should be multiline based on layout setting and element count. */
-  protected $multiline(count: number): boolean;
 }
 //#endregion
 //#region src/ts-dsl/expr/array.d.ts
-declare class ArrayTsDsl extends TsDsl<ts.ArrayLiteralExpression> {
+declare const Mixed$23: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ArrayLiteralExpression>, LayoutMethods>, AsMethods>;
+declare class ArrayTsDsl extends Mixed$23 {
+  readonly '~dsl' = "ArrayTsDsl";
   protected _elements: Array<{
     expr: MaybeTsDsl<ts.Expression>;
     kind: 'element';
@@ -7034,185 +7293,50 @@ declare class ArrayTsDsl extends TsDsl<ts.ArrayLiteralExpression> {
     kind: 'spread';
   }>;
   constructor(...exprs: Array<string | number | boolean | MaybeTsDsl<ts.Expression>>);
+  analyze(ctx: AnalysisContext): void;
   /** Adds a single array element. */
   element(expr: string | number | boolean | MaybeTsDsl<ts.Expression>): this;
   /** Adds multiple array elements. */
   elements(...exprs: ReadonlyArray<string | number | boolean | MaybeTsDsl<ts.Expression>>): this;
   /** Adds a spread element (`...expr`). */
   spread(expr: MaybeTsDsl<ts.Expression>): this;
-  $render(): ts.ArrayLiteralExpression;
-}
-interface ArrayTsDsl extends AsMixin, LayoutMixin {}
-//#endregion
-//#region src/ts-dsl/expr/typeof.d.ts
-declare class TypeOfExprTsDsl extends TsDsl<ts.TypeOfExpression> {
-  protected _expr: string | MaybeTsDsl<ts.Expression>;
-  constructor(expr: string | MaybeTsDsl<ts.Expression>);
-  $render(): ts.TypeOfExpression;
-}
-interface TypeOfExprTsDsl extends OperatorMixin {}
-//#endregion
-//#region src/ts-dsl/type/attr.d.ts
-declare class TypeAttrTsDsl extends TypeTsDsl<ts.QualifiedName> {
-  protected _base?: string | MaybeTsDsl<ts.EntityName>;
-  protected right: string | ts.Identifier;
-  constructor(base: string | MaybeTsDsl<ts.EntityName>, right: string | ts.Identifier);
-  constructor(right: string | ts.Identifier);
-  base(base?: string | MaybeTsDsl<ts.EntityName>): this;
-  $render(): ts.QualifiedName;
-}
-interface TypeAttrTsDsl extends TypeExprMixin {}
-//#endregion
-//#region src/ts-dsl/type/expr.d.ts
-declare class TypeExprTsDsl extends TypeTsDsl<ts.TypeReferenceNode> {
-  protected _exprInput?: string | ts.Identifier | TypeAttrTsDsl;
-  constructor();
-  constructor(fn: (t: TypeExprTsDsl) => void);
-  constructor(name: string);
-  constructor(name: string, fn?: (t: TypeExprTsDsl) => void);
-  /** Accesses a nested type (e.g. `Foo.Bar`). */
-  attr(right: string | ts.Identifier | TypeAttrTsDsl): this;
-  $render(): ts.TypeReferenceNode;
-}
-interface TypeExprTsDsl extends TypeArgsMixin, TypeExprMixin {}
-//#endregion
-//#region src/ts-dsl/type/idx.d.ts
-declare class TypeIdxTsDsl extends TypeTsDsl<ts.IndexedAccessTypeNode> {
-  protected _base: string | MaybeTsDsl<ts.TypeNode>;
-  protected _index: string | MaybeTsDsl<ts.TypeNode> | number;
-  constructor(base: string | MaybeTsDsl<ts.TypeNode>, index: string | MaybeTsDsl<ts.TypeNode> | number);
-  base(base: string | MaybeTsDsl<ts.TypeNode>): this;
-  index(index: string | MaybeTsDsl<ts.TypeNode> | number): this;
-  $render(): ts.IndexedAccessTypeNode;
-}
-interface TypeIdxTsDsl extends TypeExprMixin {}
-//#endregion
-//#region src/ts-dsl/type/operator.d.ts
-type Op = ts.SyntaxKind.KeyOfKeyword | ts.SyntaxKind.ReadonlyKeyword | ts.SyntaxKind.UniqueKeyword;
-type Type$1 = string | MaybeTsDsl<ts.TypeNode>;
-/**
- * Builds a TypeScript `TypeOperatorNode`, such as:
- *
- * - `keyof T`
- * - `readonly U`
- * - `unique V`
- *
- * This DSL provides both a generic `.operator()` API and convenient
- * shorthand methods (`.keyof()`, `.readonly()`, `.unique()`).
- *
- * The node will throw during render if required fields are missing.
- */
-declare class TypeOperatorTsDsl extends TypeTsDsl<ts.TypeOperatorNode> {
-  protected _op?: Op;
-  protected _type?: Type$1;
-  /** Shorthand: builds `keyof T`. */
-  keyof(type: Type$1): this;
-  /** Sets the operator explicitly. */
-  operator(op: Op): this;
-  /** Shorthand: builds `readonly T`. */
-  readonly(type: Type$1): this;
-  /** Sets the target type of the operator. */
-  type(type: Type$1): this;
-  /** Shorthand: builds `unique T`. */
-  unique(type: Type$1): this;
-  $render(): ts.TypeOperatorNode;
-  /** Throws if required fields are not set. */
-  $validate(): asserts this is this & {
-    _op: Op;
-    _type: Type$1;
-  };
-  private missingRequiredCalls;
-}
-//#endregion
-//#region src/ts-dsl/type/query.d.ts
-declare class TypeQueryTsDsl extends TypeTsDsl<ts.TypeQueryNode> {
-  protected _expr: string | MaybeTsDsl<TypeTsDsl | ts.Expression>;
-  constructor(expr: string | MaybeTsDsl<TypeTsDsl | ts.Expression>);
-  $render(): ts.TypeQueryNode;
-}
-interface TypeQueryTsDsl extends TypeExprMixin {}
-//#endregion
-//#region src/ts-dsl/mixins/type-expr.d.ts
-declare class TypeExprMixin {
-  /** Creates an indexed-access type (e.g. `Foo<T>[K]`). */
-  idx(this: MaybeTsDsl<TypeTsDsl>, index: string | number | MaybeTsDsl<ts.TypeNode>): TypeIdxTsDsl;
-  /** Shorthand: builds `keyof T`. */
-  keyof(this: MaybeTsDsl<TypeTsDsl>): TypeOperatorTsDsl;
-  /** Shorthand: builds `readonly T`. */
-  readonly(this: MaybeTsDsl<TypeTsDsl>): TypeOperatorTsDsl;
-  /** Create a TypeExpr DSL node representing ReturnType<this>. */
-  returnType(this: MaybeTsDsl<ts.Expression>): TypeExprTsDsl;
-  /** Create a TypeOfExpr DSL node representing typeof this. */
-  typeofExpr(this: MaybeTsDsl<ts.Expression>): TypeOfExprTsDsl;
-  /** Create a TypeQuery DSL node representing typeof this. */
-  typeofType(this: MaybeTsDsl<TypeTsDsl | ts.Expression>): TypeQueryTsDsl;
-  /**
-   * Create a `typeof` operator that narrows its return type based on the receiver.
-   *
-   * - If `this` is a `TsDsl<ts.Expression>` → returns TypeOfExprTsDsl
-   * - If `this` is a `TsDsl<TypeTsDsl>`     → returns TypeQueryTsDsl
-   * - If `this` is a raw ts.Expression      → returns TypeOfExprTsDsl
-   * - Otherwise                             → returns TypeQueryTsDsl
-   */
-  typeof<T extends MaybeTsDsl<TypeTsDsl | ts.Expression>>(this: T): T extends MaybeTsDsl<ts.Expression> ? TypeOfExprTsDsl : T extends MaybeTsDsl<TypeTsDsl> ? TypeQueryTsDsl : TypeQueryTsDsl | TypeOfExprTsDsl;
-  /** Shorthand: builds `unique T`. */
-  unique(this: MaybeTsDsl<TypeTsDsl>): TypeOperatorTsDsl;
+  toAst(ctx: AstContext): ts.ArrayLiteralExpression;
 }
 //#endregion
 //#region src/ts-dsl/expr/expr.d.ts
-declare class ExprTsDsl extends TsDsl<ts.Expression> {
-  protected _exprInput: string | MaybeTsDsl<ts.Expression>;
-  constructor(id: string | MaybeTsDsl<ts.Expression>);
-  $render(): ts.Expression;
+type Id = Symbol | string | MaybeTsDsl<ts.Expression>;
+declare const Mixed$22: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.Expression>, TypeExprMethods>, OperatorMethods>, ExprMethods>, AsMethods>;
+declare class ExprTsDsl extends Mixed$22 {
+  readonly '~dsl' = "ExprTsDsl";
+  protected _exprInput: Ref<Id>;
+  constructor(id: Id);
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): ts.Expression;
 }
-interface ExprTsDsl extends AsMixin, ExprMixin, OperatorMixin, TypeExprMixin {}
 //#endregion
 //#region src/ts-dsl/expr/id.d.ts
-declare class IdTsDsl extends TsDsl<ts.Identifier> {
+declare const Mixed$21: abstract new () => TsDsl<ts.Identifier>;
+declare class IdTsDsl extends Mixed$21 {
+  readonly '~dsl' = "IdTsDsl";
   protected name: string;
   constructor(name: string);
-  $render(): ts.Identifier;
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.Identifier;
 }
 //#endregion
 //#region src/ts-dsl/expr/literal.d.ts
-declare class LiteralTsDsl extends TsDsl<ts.LiteralTypeNode['literal']> {
+declare const Mixed$20: MixinCtor<abstract new () => TsDsl<ts.LiteralExpression | ts.NullLiteral | ts.BooleanLiteral | ts.PrefixUnaryExpression>, AsMethods>;
+declare class LiteralTsDsl extends Mixed$20 {
+  readonly '~dsl' = "LiteralTsDsl";
   protected value: string | number | boolean | null;
   constructor(value: string | number | boolean | null);
-  $render(): ts.LiteralTypeNode['literal'];
-}
-interface LiteralTsDsl extends AsMixin {}
-//#endregion
-//#region src/ts-dsl/expr/new.d.ts
-declare class NewTsDsl extends TsDsl<ts.NewExpression> {
-  protected classExpr: string | MaybeTsDsl<ts.Expression>;
-  constructor(classExpr: string | MaybeTsDsl<ts.Expression>, ...args: ReadonlyArray<string | MaybeTsDsl<ts.Expression>>);
-  /** Builds the `NewExpression` node. */
-  $render(): ts.NewExpression;
-}
-interface NewTsDsl extends ArgsMixin, ExprMixin, TypeArgsMixin {}
-//#endregion
-//#region src/ts-dsl/layout/hint.d.ts
-declare class HintTsDsl extends TsDsl<ts.Node> {
-  protected _lines: Array<string>;
-  constructor(lines?: MaybeArray$1<string>, fn?: (d: HintTsDsl) => void);
-  add(...lines: ReadonlyArray<string>): this;
-  apply<T extends ts.Node>(node: T): T;
-  $render(): ts.Node;
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): ts.StringLiteral | ts.NumericLiteral | ts.NullLiteral | ts.TrueLiteral | ts.FalseLiteral | ts.PrefixUnaryExpression;
 }
 //#endregion
-//#region src/ts-dsl/mixins/hint.d.ts
-declare function HintMixin<TBase extends new (...args: ReadonlyArray<any>) => ITsDsl>(Base: TBase): {
-  new (...args: ReadonlyArray<any>): {
-    _hint?: HintTsDsl;
-    hint(lines?: MaybeArray$1<string>, fn?: (h: HintTsDsl) => void): /*elided*/any;
-    $render(): any;
-  };
-} & TBase;
-type HintMixin = InstanceType<ReturnType<typeof HintMixin>>;
-//#endregion
 //#region src/ts-dsl/expr/prop.d.ts
-type Expr$1 = string | MaybeTsDsl<ts.Expression>;
-type Stmt$1 = string | MaybeTsDsl<ts.Statement>;
+type Expr$1 = Symbol | string | MaybeTsDsl<ts.Expression>;
+type Stmt$1 = Symbol | string | MaybeTsDsl<ts.Statement>;
 type Kind = 'computed' | 'getter' | 'prop' | 'setter' | 'spread';
 type Meta = {
   kind: 'computed';
@@ -7230,30 +7354,35 @@ type Meta = {
   kind: 'spread';
   name?: undefined;
 };
-declare class ObjectPropTsDsl extends TsDsl<ts.ObjectLiteralElementLike> {
-  protected _value?: Expr$1 | Stmt$1;
+declare const Mixed$19: MixinCtor<abstract new () => TsDsl<ts.ObjectLiteralElementLike>, DocMethods>;
+declare class ObjectPropTsDsl extends Mixed$19 {
+  readonly '~dsl' = "ObjectPropTsDsl";
+  protected _value?: Ref<Expr$1 | Stmt$1>;
   protected meta: Meta;
   constructor(meta: Meta);
+  analyze(ctx: AnalysisContext): void;
   /** Returns true when all required builder calls are present. */
   get isValid(): boolean;
   value(value: Expr$1 | Stmt$1 | ((p: ObjectPropTsDsl) => void)): this;
-  $render(): ts.ObjectLiteralElementLike;
+  toAst(ctx: AstContext): ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ts.PropertyAssignment | ts.ShorthandPropertyAssignment | ts.SpreadAssignment;
   $validate(): asserts this is this & {
     _value: Expr$1 | Stmt$1;
     kind: Kind;
   };
   private missingRequiredCalls;
 }
-interface ObjectPropTsDsl extends DocMixin {}
 //#endregion
 //#region src/ts-dsl/expr/object.d.ts
-type Expr = string | MaybeTsDsl<ts.Expression>;
-type Stmt = string | MaybeTsDsl<ts.Statement>;
+type Expr = Symbol | string | MaybeTsDsl<ts.Expression>;
+type Stmt = Symbol | string | MaybeTsDsl<ts.Statement>;
 type ExprFn = Expr | ((p: ObjectPropTsDsl) => void);
 type StmtFn = Stmt | ((p: ObjectPropTsDsl) => void);
-declare class ObjectTsDsl extends TsDsl<ts.ObjectLiteralExpression> {
+declare const Mixed$18: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.ObjectLiteralExpression>, LayoutMethods>, HintMethods>, ExprMethods>, AsMethods>;
+declare class ObjectTsDsl extends Mixed$18 {
+  readonly '~dsl' = "ObjectTsDsl";
   protected _props: Array<ObjectPropTsDsl>;
   constructor(...props: Array<ObjectPropTsDsl>);
+  analyze(ctx: AnalysisContext): void;
   /** Adds a computed property (e.g. `{ [expr]: value }`). */
   computed(name: string, expr: ExprFn): this;
   /** Adds a getter property (e.g. `{ get foo() { ... } }`). */
@@ -7270,16 +7399,17 @@ declare class ObjectTsDsl extends TsDsl<ts.ObjectLiteralExpression> {
   setter(name: string, stmt: StmtFn): this;
   /** Adds a spread property (e.g. `{ ...options }`). */
   spread(expr: ExprFn): this;
-  /** Builds and returns the object literal expression. */
-  $render(): ts.ObjectLiteralExpression;
+  toAst(ctx: AstContext): ts.ObjectLiteralExpression;
 }
-interface ObjectTsDsl extends AsMixin, ExprMixin, HintMixin, LayoutMixin {}
 //#endregion
 //#region src/ts-dsl/expr/prefix.d.ts
-declare class PrefixTsDsl extends TsDsl<ts.PrefixUnaryExpression> {
+declare const Mixed$17: abstract new () => TsDsl<ts.PrefixUnaryExpression>;
+declare class PrefixTsDsl extends Mixed$17 {
+  readonly '~dsl' = "PrefixTsDsl";
   protected _expr?: string | MaybeTsDsl<ts.Expression>;
   protected _op?: ts.PrefixUnaryOperator;
   constructor(expr?: string | MaybeTsDsl<ts.Expression>, op?: ts.PrefixUnaryOperator);
+  analyze(ctx: AnalysisContext): void;
   /** Sets the operand (the expression being prefixed). */
   expr(expr: string | MaybeTsDsl<ts.Expression>): this;
   /** Sets the operator to MinusToken for negation (`-`). */
@@ -7288,98 +7418,97 @@ declare class PrefixTsDsl extends TsDsl<ts.PrefixUnaryExpression> {
   not(): this;
   /** Sets the operator (e.g. `ts.SyntaxKind.ExclamationToken` for `!`). */
   op(op: ts.PrefixUnaryOperator): this;
-  /** Renders the prefix unary expression node. */
-  $render(): ts.PrefixUnaryExpression;
+  toAst(ctx: AstContext): ts.PrefixUnaryExpression;
 }
 //#endregion
 //#region src/ts-dsl/expr/regexp.d.ts
 type RegexFlag = 'g' | 'i' | 'm' | 's' | 'u' | 'y';
 type RegexFlags<Avail extends string = RegexFlag> = '' | { [K in Avail]: `${K}${RegexFlags<Exclude<Avail, K>>}` }[Avail];
-declare class RegExpTsDsl extends TsDsl<ts.RegularExpressionLiteral> {
+declare const Mixed$16: abstract new () => TsDsl<ts.RegularExpressionLiteral>;
+declare class RegExpTsDsl extends Mixed$16 {
+  readonly '~dsl' = "RegExpTsDsl";
   protected pattern: string;
   protected flags?: RegexFlags;
   constructor(pattern: string, flags?: RegexFlags);
-  /** Emits a RegularExpressionLiteral node. */
-  $render(): ts.RegularExpressionLiteral;
-}
-//#endregion
-//#region src/ts-dsl/expr/template.d.ts
-declare class TemplateTsDsl extends TsDsl<ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral> {
-  protected parts: Array<string | MaybeTsDsl<ts.Expression>>;
-  constructor(value?: string | MaybeTsDsl<ts.Expression>);
-  add(value: string | MaybeTsDsl<ts.Expression>): this;
-  $render(): ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral;
+  analyze(ctx: AnalysisContext): void;
+  toAst(): ts.RegularExpressionLiteral;
 }
 //#endregion
 //#region src/ts-dsl/expr/ternary.d.ts
-declare class TernaryTsDsl extends TsDsl<ts.ConditionalExpression> {
+declare const Mixed$15: abstract new () => TsDsl<ts.ConditionalExpression>;
+declare class TernaryTsDsl extends Mixed$15 {
+  readonly '~dsl' = "TernaryTsDsl";
   protected _condition?: string | MaybeTsDsl<ts.Expression>;
   protected _then?: string | MaybeTsDsl<ts.Expression>;
   protected _else?: string | MaybeTsDsl<ts.Expression>;
   constructor(condition?: string | MaybeTsDsl<ts.Expression>);
+  analyze(ctx: AnalysisContext): void;
   condition(condition: string | MaybeTsDsl<ts.Expression>): this;
   do(expr: string | MaybeTsDsl<ts.Expression>): this;
   otherwise(expr: string | MaybeTsDsl<ts.Expression>): this;
-  $render(): ts.ConditionalExpression;
+  toAst(ctx: AstContext): ts.ConditionalExpression;
 }
 //#endregion
-//#region src/ts-dsl/layout/note.d.ts
-declare class NoteTsDsl extends TsDsl<ts.Node> {
-  protected _lines: Array<string>;
-  constructor(lines?: MaybeArray$1<string>, fn?: (d: NoteTsDsl) => void);
-  add(...lines: ReadonlyArray<string>): this;
-  apply<T extends ts.Node>(node: T): T;
-  $render(): ts.Node;
+//#region src/ts-dsl/layout/newline.d.ts
+declare class NewlineTsDsl extends TsDsl<ts.Identifier> {
+  readonly '~dsl' = "NewlineTsDsl";
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): ts.Identifier;
 }
 //#endregion
-//#region src/ts-dsl/stmt/if.d.ts
-declare class IfTsDsl extends TsDsl<ts.IfStatement> {
-  protected _condition?: string | MaybeTsDsl<ts.Expression>;
-  protected _else?: ReadonlyArray<MaybeTsDsl<ts.Statement>>;
-  constructor(condition?: string | MaybeTsDsl<ts.Expression>);
-  condition(condition: string | MaybeTsDsl<ts.Expression>): this;
-  otherwise(...statements: ReadonlyArray<MaybeTsDsl<ts.Statement>>): this;
-  $render(): ts.IfStatement;
+//#region src/ts-dsl/stmt/block.d.ts
+declare const Mixed$14: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.Block>, LayoutMethods>, DoMethods>;
+declare class BlockTsDsl extends Mixed$14 {
+  readonly '~dsl' = "BlockTsDsl";
+  constructor(...items: Array<DoExpr>);
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): ts.Block;
 }
-interface IfTsDsl extends DoMixin {}
 //#endregion
 //#region src/ts-dsl/stmt/stmt.d.ts
-declare class StmtTsDsl extends TsDsl<ts.Statement> {
+declare const Mixed$13: abstract new () => TsDsl<ts.Statement>;
+declare class StmtTsDsl extends Mixed$13 {
+  readonly '~dsl' = "StmtTsDsl";
   protected _inner: ts.Expression | ts.Statement | TsDsl<any>;
   constructor(inner: ts.Expression | ts.Statement | TsDsl<any>);
-  $render(): ts.Statement;
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): ts.Statement;
 }
 //#endregion
 //#region src/ts-dsl/stmt/throw.d.ts
-declare class ThrowTsDsl extends TsDsl<ts.ThrowStatement> {
+declare const Mixed$12: abstract new () => TsDsl<ts.ThrowStatement>;
+declare class ThrowTsDsl extends Mixed$12 {
+  readonly '~dsl' = "ThrowTsDsl";
   protected error: string | MaybeTsDsl<ts.Expression>;
   protected msg?: string | MaybeTsDsl<ts.Expression>;
   protected useNew: boolean;
   constructor(error: string | MaybeTsDsl<ts.Expression>, useNew?: boolean);
+  analyze(ctx: AnalysisContext): void;
   message(value: string | MaybeTsDsl<ts.Expression>): this;
-  $render(): ts.ThrowStatement;
-}
-//#endregion
-//#region src/ts-dsl/stmt/var.d.ts
-declare class VarTsDsl extends TsDsl<ts.VariableStatement> {
-  protected kind: ts.NodeFlags;
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  protected name?: string;
-  protected _type?: TypeTsDsl;
-  constructor(name?: string);
-  const(): this;
-  let(): this;
-  /** Sets the variable type. */
-  type(type: string | TypeTsDsl): this;
-  var(): this;
-  $render(): ts.VariableStatement;
+  toAst(ctx: AstContext): ts.ThrowStatement;
+}
+//#endregion
+//#region src/ts-dsl/stmt/try.d.ts
+declare const Mixed$11: abstract new () => TsDsl<ts.TryStatement>;
+type CatchParam = Symbol | string;
+declare class TryTsDsl extends Mixed$11 {
+  readonly '~dsl' = "TryTsDsl";
+  protected _catch?: Array<DoExpr>;
+  protected _catchArg?: CatchParam;
+  protected _finally?: Array<DoExpr>;
+  protected _try?: Array<DoExpr>;
+  constructor(...tryBlock: Array<DoExpr>);
+  analyze(ctx: AnalysisContext): void;
+  catch(...items: Array<DoExpr>): this;
+  catchArg(arg: CatchParam): this;
+  finally(...items: Array<DoExpr>): this;
+  try(...items: Array<DoExpr>): this;
+  toAst(ctx: AstContext): ts.TryStatement;
 }
-interface VarTsDsl extends DefaultMixin, DocMixin, ExportMixin, HintMixin, PatternMixin, ValueMixin {}
 //#endregion
 //#region src/ts-dsl/token.d.ts
 declare class TokenTsDsl<K$1 extends ts.SyntaxKind = never> extends TsDsl<ts.Token<K$1>> {
+  readonly '~dsl' = "TokenTsDsl";
   protected _kind?: K$1;
   /** Sets the token kind */
   kind(kind: K$1): this;
@@ -7395,57 +7524,65 @@ declare class TokenTsDsl<K$1 extends ts.SyntaxKind = never> extends TsDsl<ts.Tok
   readonly(): TokenTsDsl<ts.SyntaxKind.ReadonlyKeyword>;
   /** Creates `...` (spread / rest) */
   spread(): TokenTsDsl<ts.SyntaxKind.DotDotDotToken>;
-  /** Renders the final token */
-  $render(): ts.Token<K$1>;
+  toAst(): ts.Token<K$1>;
 }
 //#endregion
 //#region src/ts-dsl/type/alias.d.ts
-declare class TypeAliasTsDsl extends TsDsl<ts.TypeAliasDeclaration> {
-  protected value?: MaybeTsDsl<ts.TypeNode>;
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  protected name: string;
-  constructor(name: string, fn?: (t: TypeAliasTsDsl) => void);
+type Name = Symbol | string;
+type Value = MaybeTsDsl<ts.TypeNode>;
+declare const Mixed$10: MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.TypeAliasDeclaration>, TypeParamsMethods>, ExportMethods>, DocMethods>;
+declare class TypeAliasTsDsl extends Mixed$10 {
+  readonly '~dsl' = "TypeAliasTsDsl";
+  protected name: Ref<Name>;
+  protected value?: Value;
+  constructor(name: Name, fn?: (t: TypeAliasTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
   /** Sets the type expression on the right-hand side of `= ...`. */
-  type(node: MaybeTsDsl<ts.TypeNode>): this;
-  /** Renders a `TypeAliasDeclaration` node. */
-  $render(): ts.TypeAliasDeclaration;
+  type(node: Value): this;
+  toAst(ctx: AstContext): ts.TypeAliasDeclaration;
 }
-interface TypeAliasTsDsl extends DocMixin, ExportMixin, TypeParamsMixin {}
 //#endregion
 //#region src/ts-dsl/type/and.d.ts
-declare class TypeAndTsDsl extends TypeTsDsl<ts.IntersectionTypeNode> {
-  protected _types: Array<string | ts.TypeNode | TypeTsDsl>;
-  constructor(...nodes: Array<string | ts.TypeNode | TypeTsDsl>);
-  types(...nodes: Array<string | ts.TypeNode | TypeTsDsl>): this;
-  $render(): ts.IntersectionTypeNode;
+type Type$1 = Symbol | string | ts.TypeNode | TypeTsDsl;
+declare const Mixed$9: abstract new () => TsDsl<ts.IntersectionTypeNode>;
+declare class TypeAndTsDsl extends Mixed$9 {
+  readonly '~dsl' = "TypeAndTsDsl";
+  protected _types: Array<Ref<Type$1>>;
+  constructor(...nodes: Array<Type$1>);
+  analyze(ctx: AnalysisContext): void;
+  types(...nodes: Array<Type$1>): this;
+  toAst(ctx: AstContext): ts.IntersectionTypeNode;
 }
 //#endregion
 //#region src/ts-dsl/type/func.d.ts
-declare class TypeFuncTsDsl extends TypeTsDsl<ts.FunctionTypeNode> {
-  protected _returns?: TypeTsDsl;
-  /** Sets the return type. */
-  returns(type: string | TypeTsDsl): this;
-  $render(): ts.FunctionTypeNode;
+declare const Mixed$8: MixinCtor<MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.FunctionTypeNode>, TypeReturnsMethods>, TypeParamsMethods>, ParamMethods>, DocMethods>;
+declare class TypeFuncTsDsl extends Mixed$8 {
+  readonly '~dsl' = "TypeFuncTsDsl";
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): ts.FunctionTypeNode;
 }
-interface TypeFuncTsDsl extends DocMixin, ParamMixin, TypeParamsMixin {}
 //#endregion
 //#region src/ts-dsl/type/literal.d.ts
-declare class TypeLiteralTsDsl extends TypeTsDsl<ts.LiteralTypeNode> {
+declare const Mixed$7: abstract new () => TsDsl<ts.LiteralTypeNode>;
+declare class TypeLiteralTsDsl extends Mixed$7 {
+  readonly '~dsl' = "TypeLiteralTsDsl";
   protected value: string | number | boolean | null;
   constructor(value: string | number | boolean | null);
-  $render(): ts.LiteralTypeNode;
+  analyze(ctx: AnalysisContext): void;
+  toAst(ctx: AstContext): ts.LiteralTypeNode;
 }
 //#endregion
 //#region src/ts-dsl/type/mapped.d.ts
-declare class TypeMappedTsDsl extends TypeTsDsl<ts.MappedTypeNode> {
+declare const Mixed$6: abstract new () => TsDsl<ts.MappedTypeNode>;
+declare class TypeMappedTsDsl extends Mixed$6 {
+  readonly '~dsl' = "TypeMappedTsDsl";
   protected questionToken?: TokenTsDsl<ts.SyntaxKind.QuestionToken | ts.SyntaxKind.PlusToken | ts.SyntaxKind.MinusToken>;
   protected readonlyToken?: TokenTsDsl<ts.SyntaxKind.ReadonlyKeyword | ts.SyntaxKind.MinusToken | ts.SyntaxKind.PlusToken>;
   protected _key?: string | MaybeTsDsl<ts.TypeNode>;
   protected _name?: string;
   protected _type?: string | MaybeTsDsl<ts.TypeNode>;
   constructor(name?: string);
+  analyze(ctx: AnalysisContext): void;
   /** Returns true when all required builder calls are present. */
   get isValid(): boolean;
   /** Sets the key constraint: `[K in Constraint]` */
@@ -7462,7 +7599,7 @@ declare class TypeMappedTsDsl extends TypeTsDsl<ts.MappedTypeNode> {
   required(): this;
   /** Sets the mapped value type: `[K in X]: ValueType` */
   type(type: string | MaybeTsDsl<ts.TypeNode>): this;
-  $render(): ts.MappedTypeNode;
+  toAst(ctx: AstContext): ts.MappedTypeNode;
   $validate(): asserts this is this & {
     _key: string | MaybeTsDsl<ts.TypeNode>;
     _name: string;
@@ -7472,49 +7609,52 @@ declare class TypeMappedTsDsl extends TypeTsDsl<ts.MappedTypeNode> {
 }
 //#endregion
 //#region src/ts-dsl/type/idx-sig.d.ts
-type Type = string | MaybeTsDsl<ts.TypeNode>;
-declare class TypeIdxSigTsDsl extends TypeTsDsl<ts.IndexSignatureDeclaration> {
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  protected _key?: Type;
-  protected _name: string;
-  protected _type?: Type;
-  constructor(name: string, fn?: (i: TypeIdxSigTsDsl) => void);
+type TypeIdxSigName = string;
+type TypeIdxSigType = string | MaybeTsDsl<ts.TypeNode>;
+declare const Mixed$5: MixinCtor<MixinCtor<abstract new () => TsDsl<ts.IndexSignatureDeclaration>, ReadonlyMethods>, DocMethods>;
+declare class TypeIdxSigTsDsl extends Mixed$5 {
+  readonly '~dsl' = "TypeIdxSigTsDsl";
+  protected _key?: TypeIdxSigType;
+  protected _name: TypeIdxSigName;
+  protected _type?: TypeIdxSigType;
+  constructor(name: TypeIdxSigName, fn?: (i: TypeIdxSigTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
   /** Returns true when all required builder calls are present. */
   get isValid(): boolean;
   /** Sets the key type: `[name: T]` */
-  key(type: Type): this;
+  key(type: TypeIdxSigType): this;
   /** Sets the property type. */
-  type(type: Type): this;
-  $render(): ts.IndexSignatureDeclaration;
+  type(type: TypeIdxSigType): this;
+  toAst(ctx: AstContext): ts.IndexSignatureDeclaration;
   $validate(): asserts this is this & {
-    _key: Type;
-    _name: string;
-    _type: Type;
+    _key: TypeIdxSigType;
+    _name: TypeIdxSigName;
+    _type: TypeIdxSigType;
   };
   private missingRequiredCalls;
 }
-interface TypeIdxSigTsDsl extends DocMixin, ReadonlyMixin {}
 //#endregion
 //#region src/ts-dsl/type/prop.d.ts
-declare class TypePropTsDsl extends TypeTsDsl<ts.TypeElement> {
-  protected modifiers: {
-    list: () => ts.Modifier[];
-  };
-  protected name: string;
-  protected _type?: string | MaybeTsDsl<ts.TypeNode>;
-  constructor(name: string, fn: (p: TypePropTsDsl) => void);
+type TypePropName = string;
+type TypePropType = Symbol | string | MaybeTsDsl<ts.TypeNode>;
+declare const Mixed$4: MixinCtor<MixinCtor<MixinCtor<abstract new () => TsDsl<ts.TypeElement>, ReadonlyMethods>, OptionalMethods>, DocMethods>;
+declare class TypePropTsDsl extends Mixed$4 {
+  readonly '~dsl' = "TypePropTsDsl";
+  protected name: TypePropName;
+  protected _type?: Ref<TypePropType>;
+  constructor(name: TypePropName, fn: (p: TypePropTsDsl) => void);
+  analyze(ctx: AnalysisContext): void;
   /** Sets the property type. */
-  type(type: string | MaybeTsDsl<ts.TypeNode>): this;
-  /** Builds and returns the property signature. */
-  $render(): ts.TypeElement;
+  type(type: TypePropType): this;
+  toAst(ctx: AstContext): ts.PropertySignature;
 }
-interface TypePropTsDsl extends DocMixin, OptionalMixin, ReadonlyMixin {}
 //#endregion
 //#region src/ts-dsl/type/object.d.ts
-declare class TypeObjectTsDsl extends TypeTsDsl<ts.TypeNode> {
+declare const Mixed$3: abstract new () => TsDsl<ts.TypeNode>;
+declare class TypeObjectTsDsl extends Mixed$3 {
+  readonly '~dsl' = "TypeObjectTsDsl";
   protected props: Array<TypePropTsDsl | TypeIdxSigTsDsl>;
+  analyze(ctx: AnalysisContext): void;
   /** Returns true if object has at least one property or spread. */
   hasProps(): boolean;
   /** Adds an index signature to the object type. */
@@ -7523,67 +7663,171 @@ declare class TypeObjectTsDsl extends TypeTsDsl<ts.TypeNode> {
   get isEmpty(): boolean;
   /** Adds a property signature (returns property builder). */
   prop(name: string, fn: (p: TypePropTsDsl) => void): this;
-  $render(): ts.TypeNode;
+  toAst(ctx: AstContext): ts.TypeLiteralNode;
 }
 //#endregion
 //#region src/ts-dsl/type/or.d.ts
-declare class TypeOrTsDsl extends TypeTsDsl<ts.UnionTypeNode> {
-  protected _types: Array<string | ts.TypeNode | TypeTsDsl>;
-  constructor(...nodes: Array<string | ts.TypeNode | TypeTsDsl>);
-  types(...nodes: Array<string | ts.TypeNode | TypeTsDsl>): this;
-  $render(): ts.UnionTypeNode;
+type Type = Symbol | string | ts.TypeNode | TypeTsDsl;
+declare const Mixed$2: abstract new () => TsDsl<ts.UnionTypeNode>;
+declare class TypeOrTsDsl extends Mixed$2 {
+  readonly '~dsl' = "TypeOrTsDsl";
+  protected _types: Array<Ref<Type>>;
+  constructor(...nodes: Array<Type>);
+  analyze(ctx: AnalysisContext): void;
+  types(...nodes: Array<Type>): this;
+  toAst(ctx: AstContext): ts.UnionTypeNode;
 }
 //#endregion
 //#region src/ts-dsl/type/template.d.ts
-declare class TypeTemplateTsDsl extends TypeTsDsl<ts.TemplateLiteralTypeNode> {
+declare const Mixed$1: abstract new () => TsDsl<ts.TemplateLiteralTypeNode>;
+declare class TypeTemplateTsDsl extends Mixed$1 {
+  readonly '~dsl' = "TypeTemplateTsDsl";
   protected parts: Array<string | MaybeTsDsl<ts.TypeNode>>;
   constructor(value?: string | MaybeTsDsl<ts.TypeNode>);
+  analyze(ctx: AnalysisContext): void;
   /** Adds a raw string segment or embedded type expression. */
   add(part: string | MaybeTsDsl<ts.TypeNode>): this;
-  /** Renders a TemplateLiteralTypeNode. */
-  $render(): ts.TemplateLiteralTypeNode;
+  toAst(ctx: AstContext): ts.TemplateLiteralTypeNode;
 }
 //#endregion
 //#region src/ts-dsl/type/tuple.d.ts
-declare class TypeTupleTsDsl extends TypeTsDsl<ts.TupleTypeNode> {
+declare const Mixed: abstract new () => TsDsl<ts.TupleTypeNode>;
+declare class TypeTupleTsDsl extends Mixed {
+  readonly '~dsl' = "TypeTupleTsDsl";
   protected _elements: Array<string | ts.TypeNode | TypeTsDsl>;
   constructor(...nodes: Array<string | ts.TypeNode | TypeTsDsl>);
+  analyze(ctx: AnalysisContext): void;
   elements(...types: Array<string | ts.TypeNode | TypeTsDsl>): this;
-  $render(): ts.TupleTypeNode;
+  toAst(ctx: AstContext): ts.TupleTypeNode;
+}
+//#endregion
+//#region src/ts-dsl/render/typescript.d.ts
+declare class TypeScriptRenderer implements Renderer {
+  /**
+   * Whether `export * from 'module'` should be used when possible instead of named exports.
+   *
+   * @private
+   */
+  private preferExportAll;
+  /**
+   * Controls whether imports/exports include a file extension (e.g., '.ts' or '.js').
+   *
+   * @private
+   */
+  private preferFileExtension;
+  /**
+   * Optional function to transform module specifiers.
+   *
+   * @private
+   */
+  private resolveModuleName?;
+  constructor(args?: {
+    preferExportAll?: boolean;
+    preferFileExtension?: string;
+    resolveModuleName?: (moduleName: string) => string | undefined;
+  });
+  render(ctx: RenderContext): string;
+  supports(ctx: RenderContext): boolean;
+  private getExports;
+  private getImports;
+  private renderExport;
+  private renderImport;
+}
+//#endregion
+//#region src/ts-dsl/utils/keywords.d.ts
+declare const keywords: {
+  browserGlobals: string[];
+  javaScriptGlobals: string[];
+  javaScriptKeywords: string[];
+  nodeGlobals: string[];
+  typeScriptKeywords: string[];
+};
+//#endregion
+//#region src/ts-dsl/utils/regexp.d.ts
+declare const regexp: {
+  /**
+   * Matches characters from the start as long as they're not allowed.
+   */
+  illegalStartCharacters: RegExp;
+  /**
+   * Matches string if it contains only digits and optionally decimal point or
+   * leading minus sign.
+   */
+  number: RegExp;
+  /**
+   * Javascript identifier regexp pattern retrieved from
+   * {@link} https://developer.mozilla.org/docs/Web/JavaScript/Reference/Lexical_grammar#identifiers
+   */
+  typeScriptIdentifier: RegExp;
+};
+//#endregion
+//#region src/ts-dsl/utils/reserved.d.ts
+type List = ReadonlyArray<string>;
+declare class ReservedList {
+  private _array;
+  private _set;
+  constructor(values: List);
+  get '~values'(): Set<string>;
+  /**
+   * Updates the reserved list with new values.
+   *
+   * @param values New reserved values or a function that receives the previous
+   * reserved values and returns the new ones.
+   */
+  set(values: List | ((prev: List) => List)): void;
 }
+/**
+ * Reserved names for identifiers. These names will not be used
+ * for variables, functions, classes, or other identifiers in generated code.
+ */
+declare const reserved: {
+  /**
+   * Reserved names for runtime identifiers. These names will not be used
+   * for variables, functions, classes, or other runtime identifiers in
+   * generated code.
+   */
+  runtime: ReservedList;
+  /**
+   * Reserved names for type identifiers. These names will not be used
+   * for type or interface identifiers in generated code.
+   */
+  type: ReservedList;
+};
 //#endregion
 //#region src/ts-dsl/index.d.ts
-declare const $: ((id: string | typescript0.Expression | TsDsl<typescript0.Expression>) => ExprTsDsl) & {
+declare const $: ((id: string | _hey_api_codegen_core0.Symbol | ts.Expression | TsDsl<ts.Expression>) => ExprTsDsl) & {
   /** Creates an array literal expression (e.g. `[1, 2, 3]`). */
   array: (...args: ConstructorParameters<typeof ArrayTsDsl>) => ArrayTsDsl;
   /** Creates an `as` type assertion expression (e.g. `value as Type`). */
-  as: (expr: string | typescript0.Expression | TsDsl<typescript0.Expression>, type: string | TypeTsDsl<typescript0.TypeNode>) => AsTsDsl;
+  as: (expr: AsExpr, type: AsType) => AsTsDsl;
   /** Creates a property access expression (e.g. `obj.foo`). */
-  attr: (left: string | typescript0.Expression | TsDsl<typescript0.Expression>, right: string | number | typescript0.MemberName) => AttrTsDsl;
+  attr: (left: AttrLeft, right: AttrRight) => AttrTsDsl;
   /** Creates an await expression (e.g. `await promise`). */
-  await: (expr: string | typescript0.Expression | TsDsl<typescript0.Expression>) => AwaitTsDsl;
+  await: (expr: AwaitExpr) => AwaitTsDsl;
   /** Creates a binary expression (e.g. `a + b`). */
-  binary: (base: string | typescript0.Expression | TsDsl<typescript0.Expression>, op?: (("!=" | "!==" | "&&" | "*" | "+" | "-" | "/" | "<" | "<=" | "=" | "==" | "===" | ">" | ">=" | "??" | "||") | typescript0.BinaryOperator) | undefined, expr?: (string | typescript0.Expression | TsDsl<typescript0.Expression>) | undefined) => BinaryTsDsl;
+  binary: (base: string | _hey_api_codegen_core0.Symbol | ts.Expression | TsDsl<ts.Expression>, op?: (("!=" | "!==" | "&&" | "*" | "+" | "-" | "/" | "<" | "<=" | "=" | "==" | "===" | ">" | ">=" | "??" | "??=" | "||") | ts.BinaryOperator) | undefined, expr?: (string | _hey_api_codegen_core0.Symbol | ts.Expression | TsDsl<ts.Expression>) | undefined) => BinaryTsDsl;
+  /** Creates a statement block (`{ ... }`). */
+  block: (...args: ConstructorParameters<typeof BlockTsDsl>) => BlockTsDsl;
   /** Creates a function or method call expression (e.g. `fn(arg)`). */
-  call: (callee: string | typescript0.Expression | TsDsl<typescript0.Expression>, ...args: (string | typescript0.Expression | TsDsl<typescript0.Expression> | undefined)[]) => CallTsDsl;
+  call: (callee: CallCallee, ...args: (CallArg | undefined)[]) => CallTsDsl;
   /** Creates a class declaration or expression. */
-  class: (name: string) => ClassTsDsl;
+  class: (name: string | _hey_api_codegen_core0.Symbol) => ClassTsDsl;
   /** Creates a constant variable declaration (`const`). */
-  const: (name?: string | undefined) => VarTsDsl;
+  const: (name?: VarName | undefined) => VarTsDsl;
   /** Creates a decorator expression (e.g. `@decorator`). */
-  decorator: (name: string | typescript0.Expression, ...args: (string | typescript0.Expression | TsDsl<typescript0.Expression>)[]) => DecoratorTsDsl;
+  decorator: (name: DecoratorName, ...args: (string | ts.Expression | TsDsl<ts.Expression>)[]) => DecoratorTsDsl;
   /** Creates a JSDoc documentation block. */
-  doc: (lines?: MaybeArray$1<string> | undefined, fn?: ((d: DocTsDsl) => void) | undefined) => DocTsDsl;
+  doc: (lines?: DocLines | undefined, fn?: DocFn | undefined) => DocTsDsl;
   /** Creates an enum declaration. */
-  enum: (name: string | typescript0.Identifier, fn?: ((e: EnumTsDsl) => void) | undefined) => EnumTsDsl;
+  enum: (name: EnumName, fn?: ((e: EnumTsDsl) => void) | undefined) => EnumTsDsl;
   /** Creates a general expression node. */
-  expr: (id: string | typescript0.Expression | TsDsl<typescript0.Expression>) => ExprTsDsl;
+  expr: (id: string | _hey_api_codegen_core0.Symbol | ts.Expression | TsDsl<ts.Expression>) => ExprTsDsl;
   /** Creates a field declaration in a class or object. */
-  field: (name: string, fn?: ((f: FieldTsDsl) => void) | undefined) => FieldTsDsl;
+  field: (name: FieldName, fn?: ((f: FieldTsDsl) => void) | undefined) => FieldTsDsl;
   /** Converts a runtime value into a corresponding expression node. */
   fromValue: (input: unknown, options?: {
     layout?: "pretty";
-  } | undefined) => TsDsl<typescript0.Expression>;
+  } | undefined) => TsDsl<ts.Expression>;
   /** Creates a function expression or declaration. */
   func: {
     (): FuncTsDsl<"arrow">;
@@ -7593,41 +7837,43 @@ declare const $: ((id: string | typescript0.Expression | TsDsl<typescript0.Expre
     (name?: string, fn?: (f: FuncTsDsl<"decl">) => void): FuncTsDsl<"arrow"> | FuncTsDsl<"decl">;
   };
   /** Creates a getter method declaration. */
-  getter: (name: string | typescript0.PropertyName, fn?: ((g: GetterTsDsl) => void) | undefined) => GetterTsDsl;
+  getter: (name: GetterName, fn?: ((g: GetterTsDsl) => void) | undefined) => GetterTsDsl;
   /** Creates a single-line comment (//). */
-  hint: (lines?: MaybeArray$1<string> | undefined, fn?: ((d: HintTsDsl) => void) | undefined) => HintTsDsl;
+  hint: (lines?: HintLines | undefined, fn?: HintFn | undefined) => HintTsDsl;
   /** Creates an identifier (e.g. `foo`). */
   id: (name: string) => IdTsDsl;
   /** Creates an if statement. */
-  if: (condition?: string | typescript0.Expression | TsDsl<typescript0.Expression> | undefined) => IfTsDsl;
+  if: (condition?: IfCondition | undefined) => IfTsDsl;
   /** Creates an initialization block or statement. */
   init: (fn?: ((i: InitTsDsl) => void) | undefined) => InitTsDsl;
+  /** Creates a lazy, context-aware node with deferred evaluation. */
+  lazy: <T extends ts.Node>(thunk: LazyThunk<T>) => LazyTsDsl<T>;
   /** Creates a let variable declaration (`let`). */
-  let: (name?: string | undefined) => VarTsDsl;
+  let: (name?: VarName | undefined) => VarTsDsl;
   /** Creates a literal value (e.g. string, number, boolean). */
   literal: (value: string | number | boolean | null) => LiteralTsDsl;
   /** Creates an enum member declaration. */
-  member: (name: string, value?: ((string | number | typescript0.Expression | TsDsl<typescript0.Expression>) | ((m: EnumMemberTsDsl) => void)) | undefined) => EnumMemberTsDsl;
+  member: (name: string, value?: ((string | number | ts.Expression | TsDsl<ts.Expression>) | ((m: EnumMemberTsDsl) => void)) | undefined) => EnumMemberTsDsl;
   /** Creates a method declaration inside a class or object. */
   method: (name: string, fn?: ((m: MethodTsDsl) => void) | undefined) => MethodTsDsl;
   /** Creates a negation expression (`-x`). */
-  neg: (expr?: string | typescript0.Expression | TsDsl<typescript0.Expression> | undefined, op?: typescript0.PrefixUnaryOperator | undefined) => PrefixTsDsl;
+  neg: (expr?: string | ts.Expression | TsDsl<ts.Expression> | undefined, op?: ts.PrefixUnaryOperator | undefined) => PrefixTsDsl;
   /** Creates a new expression (e.g. `new ClassName()`). */
-  new: (classExpr: string | typescript0.Expression | TsDsl<typescript0.Expression>, ...args: (string | typescript0.Expression | TsDsl<typescript0.Expression>)[]) => NewTsDsl;
+  new: (classExpr: NewExpr, ...args: NewExpr[]) => NewTsDsl;
   /** Creates a newline (for formatting purposes). */
   newline: () => NewlineTsDsl;
   /** Creates a logical NOT expression (`!x`). */
-  not: (expr?: string | typescript0.Expression | TsDsl<typescript0.Expression> | undefined, op?: typescript0.PrefixUnaryOperator | undefined) => PrefixTsDsl;
+  not: (expr?: string | ts.Expression | TsDsl<ts.Expression> | undefined, op?: ts.PrefixUnaryOperator | undefined) => PrefixTsDsl;
   /** Creates a block comment (/* ... *\/). */
-  note: (lines?: MaybeArray$1<string> | undefined, fn?: ((d: NoteTsDsl) => void) | undefined) => NoteTsDsl;
+  note: (lines?: NoteLines | undefined, fn?: NoteFn | undefined) => NoteTsDsl;
   /** Creates an object literal expression. */
   object: (...args: ConstructorParameters<typeof ObjectTsDsl>) => ObjectTsDsl;
   /** Creates a parameter declaration for functions or methods. */
-  param: (name: string | ((p: ParamTsDsl) => void), fn?: ((p: ParamTsDsl) => void) | undefined) => ParamTsDsl;
+  param: (name: ParamName | ((p: ParamTsDsl) => void), fn?: ((p: ParamTsDsl) => void) | undefined) => ParamTsDsl;
   /** Creates a pattern for destructuring or matching. */
   pattern: () => PatternTsDsl;
   /** Creates a prefix unary expression (e.g. `-x`, `!x`, `~x`). */
-  prefix: (expr?: string | typescript0.Expression | TsDsl<typescript0.Expression> | undefined, op?: typescript0.PrefixUnaryOperator | undefined) => PrefixTsDsl;
+  prefix: (expr?: string | ts.Expression | TsDsl<ts.Expression> | undefined, op?: ts.PrefixUnaryOperator | undefined) => PrefixTsDsl;
   /** Creates an object literal property (e.g. `{ foo: bar }`). */
   prop: (meta: {
     kind: "computed";
@@ -7648,35 +7894,37 @@ declare const $: ((id: string | typescript0.Expression | TsDsl<typescript0.Expre
   /** Creates a regular expression literal (e.g. `/foo/gi`). */
   regexp: (pattern: string, flags?: ("" | "g" | "i" | "m" | "s" | "u" | "y" | "uy" | "yu" | "su" | "sy" | "suy" | "syu" | "ys" | "us" | "usy" | "uys" | "ysu" | "yus" | "ms" | "mu" | "my" | "muy" | "myu" | "msu" | "msy" | "msuy" | "msyu" | "mys" | "mus" | "musy" | "muys" | "mysu" | "myus" | "ym" | "um" | "umy" | "uym" | "ymu" | "yum" | "sm" | "smu" | "smy" | "smuy" | "smyu" | "sym" | "sum" | "sumy" | "suym" | "symu" | "syum" | "yms" | "ysm" | "ums" | "umsy" | "umys" | "usm" | "usmy" | "usym" | "uyms" | "uysm" | "ymsu" | "ymus" | "ysmu" | "ysum" | "yums" | "yusm" | "im" | "is" | "iu" | "iy" | "iuy" | "iyu" | "isu" | "isy" | "isuy" | "isyu" | "iys" | "ius" | "iusy" | "iuys" | "iysu" | "iyus" | "ims" | "imu" | "imy" | "imuy" | "imyu" | "imsu" | "imsy" | "imsuy" | "imsyu" | "imys" | "imus" | "imusy" | "imuys" | "imysu" | "imyus" | "iym" | "ium" | "iumy" | "iuym" | "iymu" | "iyum" | "ism" | "ismu" | "ismy" | "ismuy" | "ismyu" | "isym" | "isum" | "isumy" | "isuym" | "isymu" | "isyum" | "iyms" | "iysm" | "iums" | "iumsy" | "iumys" | "iusm" | "iusmy" | "iusym" | "iuyms" | "iuysm" | "iymsu" | "iymus" | "iysmu" | "iysum" | "iyums" | "iyusm" | "yi" | "ui" | "uiy" | "uyi" | "yiu" | "yui" | "si" | "siu" | "siy" | "siuy" | "siyu" | "syi" | "sui" | "suiy" | "suyi" | "syiu" | "syui" | "yis" | "ysi" | "uis" | "uisy" | "uiys" | "usi" | "usiy" | "usyi" | "uyis" | "uysi" | "yisu" | "yius" | "ysiu" | "ysui" | "yuis" | "yusi" | "mi" | "mis" | "miu" | "miy" | "miuy" | "miyu" | "misu" | "misy" | "misuy" | "misyu" | "miys" | "mius" | "miusy" | "miuys" | "miysu" | "miyus" | "myi" | "mui" | "muiy" | "muyi" | "myiu" | "myui" | "msi" | "msiu" | "msiy" | "msiuy" | "msiyu" | "msyi" | "msui" | "msuiy" | "msuyi" | "msyiu" | "msyui" | "myis" | "mysi" | "muis" | "muisy" | "muiys" | "musi" | "musiy" | "musyi" | "muyis" | "muysi" | "myisu" | "myius" | "mysiu" | "mysui" | "myuis" | "myusi" | "yim" | "ymi" | "uim" | "uimy" | "uiym" | "umi" | "umiy" | "umyi" | "uyim" | "uymi" | "yimu" | "yium" | "ymiu" | "ymui" | "yuim" | "yumi" | "sim" | "simu" | "simy" | "simuy" | "simyu" | "siym" | "sium" | "siumy" | "siuym" | "siymu" | "siyum" | "smi" | "smiu" | "smiy" | "smiuy" | "smiyu" | "smyi" | "smui" | "smuiy" | "smuyi" | "smyiu" | "smyui" | "syim" | "symi" | "suim" | "suimy" | "suiym" | "sumi" | "sumiy" | "sumyi" | "suyim" | "suymi" | "syimu" | "syium" | "symiu" | "symui" | "syuim" | "syumi" | "yims" | "yism" | "ymis" | "ymsi" | "ysim" | "ysmi" | "uims" | "uimsy" | "uimys" | "uism" | "uismy" | "uisym" | "uiyms" | "uiysm" | "umis" | "umisy" | "umiys" | "umsi" | "umsiy" | "umsyi" | "umyis" | "umysi" | "usim" | "usimy" | "usiym" | "usmi" | "usmiy" | "usmyi" | "usyim" | "usymi" | "uyims" | "uyism" | "uymis" | "uymsi" | "uysim" | "uysmi" | "yimsu" | "yimus" | "yismu" | "yisum" | "yiums" | "yiusm" | "ymisu" | "ymius" | "ymsiu" | "ymsui" | "ymuis" | "ymusi" | "ysimu" | "ysium" | "ysmiu" | "ysmui" | "ysuim" | "ysumi" | "yuims" | "yuism" | "yumis" | "yumsi" | "yusim" | "yusmi" | "gi" | "gm" | "gs" | "gu" | "gy" | "guy" | "gyu" | "gsu" | "gsy" | "gsuy" | "gsyu" | "gys" | "gus" | "gusy" | "guys" | "gysu" | "gyus" | "gms" | "gmu" | "gmy" | "gmuy" | "gmyu" | "gmsu" | "gmsy" | "gmsuy" | "gmsyu" | "gmys" | "gmus" | "gmusy" | "gmuys" | "gmysu" | "gmyus" | "gym" | "gum" | "gumy" | "guym" | "gymu" | "gyum" | "gsm" | "gsmu" | "gsmy" | "gsmuy" | "gsmyu" | "gsym" | "gsum" | "gsumy" | "gsuym" | "gsymu" | "gsyum" | "gyms" | "gysm" | "gums" | "gumsy" | "gumys" | "gusm" | "gusmy" | "gusym" | "guyms" | "guysm" | "gymsu" | "gymus" | "gysmu" | "gysum" | "gyums" | "gyusm" | "gim" | "gis" | "giu" | "giy" | "giuy" | "giyu" | "gisu" | "gisy" | "gisuy" | "gisyu" | "giys" | "gius" | "giusy" | "giuys" | "giysu" | "giyus" | "gims" | "gimu" | "gimy" | "gimuy" | "gimyu" | "gimsu" | "gimsy" | "gimsuy" | "gimsyu" | "gimys" | "gimus" | "gimusy" | "gimuys" | "gimysu" | "gimyus" | "giym" | "gium" | "giumy" | "giuym" | "giymu" | "giyum" | "gism" | "gismu" | "gismy" | "gismuy" | "gismyu" | "gisym" | "gisum" | "gisumy" | "gisuym" | "gisymu" | "gisyum" | "giyms" | "giysm" | "giums" | "giumsy" | "giumys" | "giusm" | "giusmy" | "giusym" | "giuyms" | "giuysm" | "giymsu" | "giymus" | "giysmu" | "giysum" | "giyums" | "giyusm" | "gyi" | "gui" | "guiy" | "guyi" | "gyiu" | "gyui" | "gsi" | "gsiu" | "gsiy" | "gsiuy" | "gsiyu" | "gsyi" | "gsui" | "gsuiy" | "gsuyi" | "gsyiu" | "gsyui" | "gyis" | "gysi" | "guis" | "guisy" | "guiys" | "gusi" | "gusiy" | "gusyi" | "guyis" | "guysi" | "gyisu" | "gyius" | "gysiu" | "gysui" | "gyuis" | "gyusi" | "gmi" | "gmis" | "gmiu" | "gmiy" | "gmiuy" | "gmiyu" | "gmisu" | "gmisy" | "gmisuy" | "gmisyu" | "gmiys" | "gmius" | "gmiusy" | "gmiuys" | "gmiysu" | "gmiyus" | "gmyi" | "gmui" | "gmuiy" | "gmuyi" | "gmyiu" | "gmyui" | "gmsi" | "gmsiu" | "gmsiy" | "gmsiuy" | "gmsiyu" | "gmsyi" | "gmsui" | "gmsuiy" | "gmsuyi" | "gmsyiu" | "gmsyui" | "gmyis" | "gmysi" | "gmuis" | "gmuisy" | "gmuiys" | "gmusi" | "gmusiy" | "gmusyi" | "gmuyis" | "gmuysi" | "gmyisu" | "gmyius" | "gmysiu" | "gmysui" | "gmyuis" | "gmyusi" | "gyim" | "gymi" | "guim" | "guimy" | "guiym" | "gumi" | "gumiy" | "gumyi" | "guyim" | "guymi" | "gyimu" | "gyium" | "gymiu" | "gymui" | "gyuim" | "gyumi" | "gsim" | "gsimu" | "gsimy" | "gsimuy" | "gsimyu" | "gsiym" | "gsium" | "gsiumy" | "gsiuym" | "gsiymu" | "gsiyum" | "gsmi" | "gsmiu" | "gsmiy" | "gsmiuy" | "gsmiyu" | "gsmyi" | "gsmui" | "gsmuiy" | "gsmuyi" | "gsmyiu" | "gsmyui" | "gsyim" | "gsymi" | "gsuim" | "gsuimy" | "gsuiym" | "gsumi" | "gsumiy" | "gsumyi" | "gsuyim" | "gsuymi" | "gsyimu" | "gsyium" | "gsymiu" | "gsymui" | "gsyuim" | "gsyumi" | "gyims" | "gyism" | "gymis" | "gymsi" | "gysim" | "gysmi" | "guims" | "guimsy" | "guimys" | "guism" | "guismy" | "guisym" | "guiyms" | "guiysm" | "gumis" | "gumisy" | "gumiys" | "gumsi" | "gumsiy" | "gumsyi" | "gumyis" | "gumysi" | "gusim" | "gusimy" | "gusiym" | "gusmi" | "gusmiy" | "gusmyi" | "gusyim" | "gusymi" | "guyims" | "guyism" | "guymis" | "guymsi" | "guysim" | "guysmi" | "gyimsu" | "gyimus" | "gyismu" | "gyisum" | "gyiums" | "gyiusm" | "gymisu" | "gymius" | "gymsiu" | "gymsui" | "gymuis" | "gymusi" | "gysimu" | "gysium" | "gysmiu" | "gysmui" | "gysuim" | "gysumi" | "gyuims" | "gyuism" | "gyumis" | "gyumsi" | "gyusim" | "gyusmi" | "yg" | "ug" | "ugy" | "uyg" | "ygu" | "yug" | "sg" | "sgu" | "sgy" | "sguy" | "sgyu" | "syg" | "sug" | "sugy" | "suyg" | "sygu" | "syug" | "ygs" | "ysg" | "ugs" | "ugsy" | "ugys" | "usg" | "usgy" | "usyg" | "uygs" | "uysg" | "ygsu" | "ygus" | "ysgu" | "ysug" | "yugs" | "yusg" | "mg" | "mgs" | "mgu" | "mgy" | "mguy" | "mgyu" | "mgsu" | "mgsy" | "mgsuy" | "mgsyu" | "mgys" | "mgus" | "mgusy" | "mguys" | "mgysu" | "mgyus" | "myg" | "mug" | "mugy" | "muyg" | "mygu" | "myug" | "msg" | "msgu" | "msgy" | "msguy" | "msgyu" | "msyg" | "msug" | "msugy" | "msuyg" | "msygu" | "msyug" | "mygs" | "mysg" | "mugs" | "mugsy" | "mugys" | "musg" | "musgy" | "musyg" | "muygs" | "muysg" | "mygsu" | "mygus" | "mysgu" | "mysug" | "myugs" | "myusg" | "ygm" | "ymg" | "ugm" | "ugmy" | "ugym" | "umg" | "umgy" | "umyg" | "uygm" | "uymg" | "ygmu" | "ygum" | "ymgu" | "ymug" | "yugm" | "yumg" | "sgm" | "sgmu" | "sgmy" | "sgmuy" | "sgmyu" | "sgym" | "sgum" | "sgumy" | "sguym" | "sgymu" | "sgyum" | "smg" | "smgu" | "smgy" | "smguy" | "smgyu" | "smyg" | "smug" | "smugy" | "smuyg" | "smygu" | "smyug" | "sygm" | "symg" | "sugm" | "sugmy" | "sugym" | "sumg" | "sumgy" | "sumyg" | "suygm" | "suymg" | "sygmu" | "sygum" | "symgu" | "symug" | "syugm" | "syumg" | "ygms" | "ygsm" | "ymgs" | "ymsg" | "ysgm" | "ysmg" | "ugms" | "ugmsy" | "ugmys" | "ugsm" | "ugsmy" | "ugsym" | "ugyms" | "ugysm" | "umgs" | "umgsy" | "umgys" | "umsg" | "umsgy" | "umsyg" | "umygs" | "umysg" | "usgm" | "usgmy" | "usgym" | "usmg" | "usmgy" | "usmyg" | "usygm" | "usymg" | "uygms" | "uygsm" | "uymgs" | "uymsg" | "uysgm" | "uysmg" | "ygmsu" | "ygmus" | "ygsmu" | "ygsum" | "ygums" | "ygusm" | "ymgsu" | "ymgus" | "ymsgu" | "ymsug" | "ymugs" | "ymusg" | "ysgmu" | "ysgum" | "ysmgu" | "ysmug" | "ysugm" | "ysumg" | "yugms" | "yugsm" | "yumgs" | "yumsg" | "yusgm" | "yusmg" | "ig" | "igm" | "igs" | "igu" | "igy" | "iguy" | "igyu" | "igsu" | "igsy" | "igsuy" | "igsyu" | "igys" | "igus" | "igusy" | "iguys" | "igysu" | "igyus" | "igms" | "igmu" | "igmy" | "igmuy" | "igmyu" | "igmsu" | "igmsy" | "igmsuy" | "igmsyu" | "igmys" | "igmus" | "igmusy" | "igmuys" | "igmysu" | "igmyus" | "igym" | "igum" | "igumy" | "iguym" | "igymu" | "igyum" | "igsm" | "igsmu" | "igsmy" | "igsmuy" | "igsmyu" | "igsym" | "igsum" | "igsumy" | "igsuym" | "igsymu" | "igsyum" | "igyms" | "igysm" | "igums" | "igumsy" | "igumys" | "igusm" | "igusmy" | "igusym" | "iguyms" | "iguysm" | "igymsu" | "igymus" | "igysmu" | "igysum" | "igyums" | "igyusm" | "iyg" | "iug" | "iugy" | "iuyg" | "iygu" | "iyug" | "isg" | "isgu" | "isgy" | "isguy" | "isgyu" | "isyg" | "isug" | "isugy" | "isuyg" | "isygu" | "isyug" | "iygs" | "iysg" | "iugs" | "iugsy" | "iugys" | "iusg" | "iusgy" | "iusyg" | "iuygs" | "iuysg" | "iygsu" | "iygus" | "iysgu" | "iysug" | "iyugs" | "iyusg" | "img" | "imgs" | "imgu" | "imgy" | "imguy" | "imgyu" | "imgsu" | "imgsy" | "imgsuy" | "imgsyu" | "imgys" | "imgus" | "imgusy" | "imguys" | "imgysu" | "imgyus" | "imyg" | "imug" | "imugy" | "imuyg" | "imygu" | "imyug" | "imsg" | "imsgu" | "imsgy" | "imsguy" | "imsgyu" | "imsyg" | "imsug" | "imsugy" | "imsuyg" | "imsygu" | "imsyug" | "imygs" | "imysg" | "imugs" | "imugsy" | "imugys" | "imusg" | "imusgy" | "imusyg" | "imuygs" | "imuysg" | "imygsu" | "imygus" | "imysgu" | "imysug" | "imyugs" | "imyusg" | "iygm" | "iymg" | "iugm" | "iugmy" | "iugym" | "iumg" | "iumgy" | "iumyg" | "iuygm" | "iuymg" | "iygmu" | "iygum" | "iymgu" | "iymug" | "iyugm" | "iyumg" | "isgm" | "isgmu" | "isgmy" | "isgmuy" | "isgmyu" | "isgym" | "isgum" | "isgumy" | "isguym" | "isgymu" | "isgyum" | "ismg" | "ismgu" | "ismgy" | "ismguy" | "ismgyu" | "ismyg" | "ismug" | "ismugy" | "ismuyg" | "ismygu" | "ismyug" | "isygm" | "isymg" | "isugm" | "isugmy" | "isugym" | "isumg" | "isumgy" | "isumyg" | "isuygm" | "isuymg" | "isygmu" | "isygum" | "isymgu" | "isymug" | "isyugm" | "isyumg" | "iygms" | "iygsm" | "iymgs" | "iymsg" | "iysgm" | "iysmg" | "iugms" | "iugmsy" | "iugmys" | "iugsm" | "iugsmy" | "iugsym" | "iugyms" | "iugysm" | "iumgs" | "iumgsy" | "iumgys" | "iumsg" | "iumsgy" | "iumsyg" | "iumygs" | "iumysg" | "iusgm" | "iusgmy" | "iusgym" | "iusmg" | "iusmgy" | "iusmyg" | "iusygm" | "iusymg" | "iuygms" | "iuygsm" | "iuymgs" | "iuymsg" | "iuysgm" | "iuysmg" | "iygmsu" | "iygmus" | "iygsmu" | "iygsum" | "iygums" | "iygusm" | "iymgsu" | "iymgus" | "iymsgu" | "iymsug" | "iymugs" | "iymusg" | "iysgmu" | "iysgum" | "iysmgu" | "iysmug" | "iysugm" | "iysumg" | "iyugms" | "iyugsm" | "iyumgs" | "iyumsg" | "iyusgm" | "iyusmg" | "ygi" | "yig" | "ugi" | "ugiy" | "ugyi" | "uig" | "uigy" | "uiyg" | "uygi" | "uyig" | "ygiu" | "ygui" | "yigu" | "yiug" | "yugi" | "yuig" | "sgi" | "sgiu" | "sgiy" | "sgiuy" | "sgiyu" | "sgyi" | "sgui" | "sguiy" | "sguyi" | "sgyiu" | "sgyui" | "sig" | "sigu" | "sigy" | "siguy" | "sigyu" | "siyg" | "siug" | "siugy" | "siuyg" | "siygu" | "siyug" | "sygi" | "syig" | "sugi" | "sugiy" | "sugyi" | "suig" | "suigy" | "suiyg" | "suygi" | "suyig" | "sygiu" | "sygui" | "syigu" | "syiug" | "syugi" | "syuig" | "ygis" | "ygsi" | "yigs" | "yisg" | "ysgi" | "ysig" | "ugis" | "ugisy" | "ugiys" | "ugsi" | "ugsiy" | "ugsyi" | "ugyis" | "ugysi" | "uigs" | "uigsy" | "uigys" | "uisg" | "uisgy" | "uisyg" | "uiygs" | "uiysg" | "usgi" | "usgiy" | "usgyi" | "usig" | "usigy" | "usiyg" | "usygi" | "usyig" | "uygis" | "uygsi" | "uyigs" | "uyisg" | "uysgi" | "uysig" | "ygisu" | "ygius" | "ygsiu" | "ygsui" | "yguis" | "ygusi" | "yigsu" | "yigus" | "yisgu" | "yisug" | "yiugs" | "yiusg" | "ysgiu" | "ysgui" | "ysigu" | "ysiug" | "ysugi" | "ysuig" | "yugis" | "yugsi" | "yuigs" | "yuisg" | "yusgi" | "yusig" | "mgi" | "mgis" | "mgiu" | "mgiy" | "mgiuy" | "mgiyu" | "mgisu" | "mgisy" | "mgisuy" | "mgisyu" | "mgiys" | "mgius" | "mgiusy" | "mgiuys" | "mgiysu" | "mgiyus" | "mgyi" | "mgui" | "mguiy" | "mguyi" | "mgyiu" | "mgyui" | "mgsi" | "mgsiu" | "mgsiy" | "mgsiuy" | "mgsiyu" | "mgsyi" | "mgsui" | "mgsuiy" | "mgsuyi" | "mgsyiu" | "mgsyui" | "mgyis" | "mgysi" | "mguis" | "mguisy" | "mguiys" | "mgusi" | "mgusiy" | "mgusyi" | "mguyis" | "mguysi" | "mgyisu" | "mgyius" | "mgysiu" | "mgysui" | "mgyuis" | "mgyusi" | "mig" | "migs" | "migu" | "migy" | "miguy" | "migyu" | "migsu" | "migsy" | "migsuy" | "migsyu" | "migys" | "migus" | "migusy" | "miguys" | "migysu" | "migyus" | "miyg" | "miug" | "miugy" | "miuyg" | "miygu" | "miyug" | "misg" | "misgu" | "misgy" | "misguy" | "misgyu" | "misyg" | "misug" | "misugy" | "misuyg" | "misygu" | "misyug" | "miygs" | "miysg" | "miugs" | "miugsy" | "miugys" | "miusg" | "miusgy" | "miusyg" | "miuygs" | "miuysg" | "miygsu" | "miygus" | "miysgu" | "miysug" | "miyugs" | "miyusg" | "mygi" | "myig" | "mugi" | "mugiy" | "mugyi" | "muig" | "muigy" | "muiyg" | "muygi" | "muyig" | "mygiu" | "mygui" | "myigu" | "myiug" | "myugi" | "myuig" | "msgi" | "msgiu" | "msgiy" | "msgiuy" | "msgiyu" | "msgyi" | "msgui" | "msguiy" | "msguyi" | "msgyiu" | "msgyui" | "msig" | "msigu" | "msigy" | "msiguy" | "msigyu" | "msiyg" | "msiug" | "msiugy" | "msiuyg" | "msiygu" | "msiyug" | "msygi" | "msyig" | "msugi" | "msugiy" | "msugyi" | "msuig" | "msuigy" | "msuiyg" | "msuygi" | "msuyig" | "msygiu" | "msygui" | "msyigu" | "msyiug" | "msyugi" | "msyuig" | "mygis" | "mygsi" | "myigs" | "myisg" | "mysgi" | "mysig" | "mugis" | "mugisy" | "mugiys" | "mugsi" | "mugsiy" | "mugsyi" | "mugyis" | "mugysi" | "muigs" | "muigsy" | "muigys" | "muisg" | "muisgy" | "muisyg" | "muiygs" | "muiysg" | "musgi" | "musgiy" | "musgyi" | "musig" | "musigy" | "musiyg" | "musygi" | "musyig" | "muygis" | "muygsi" | "muyigs" | "muyisg" | "muysgi" | "muysig" | "mygisu" | "mygius" | "mygsiu" | "mygsui" | "myguis" | "mygusi" | "myigsu" | "myigus" | "myisgu" | "myisug" | "myiugs" | "myiusg" | "mysgiu" | "mysgui" | "mysigu" | "mysiug" | "mysugi" | "mysuig" | "myugis" | "myugsi" | "myuigs" | "myuisg" | "myusgi" | "myusig" | "ygim" | "ygmi" | "yigm" | "yimg" | "ymgi" | "ymig" | "ugim" | "ugimy" | "ugiym" | "ugmi" | "ugmiy" | "ugmyi" | "ugyim" | "ugymi" | "uigm" | "uigmy" | "uigym" | "uimg" | "uimgy" | "uimyg" | "uiygm" | "uiymg" | "umgi" | "umgiy" | "umgyi" | "umig" | "umigy" | "umiyg" | "umygi" | "umyig" | "uygim" | "uygmi" | "uyigm" | "uyimg" | "uymgi" | "uymig" | "ygimu" | "ygium" | "ygmiu" | "ygmui" | "yguim" | "ygumi" | "yigmu" | "yigum" | "yimgu" | "yimug" | "yiugm" | "yiumg" | "ymgiu" | "ymgui" | "ymigu" | "ymiug" | "ymugi" | "ymuig" | "yugim" | "yugmi" | "yuigm" | "yuimg" | "yumgi" | "yumig" | "sgim" | "sgimu" | "sgimy" | "sgimuy" | "sgimyu" | "sgiym" | "sgium" | "sgiumy" | "sgiuym" | "sgiymu" | "sgiyum" | "sgmi" | "sgmiu" | "sgmiy" | "sgmiuy" | "sgmiyu" | "sgmyi" | "sgmui" | "sgmuiy" | "sgmuyi" | "sgmyiu" | "sgmyui" | "sgyim" | "sgymi" | "sguim" | "sguimy" | "sguiym" | "sgumi" | "sgumiy" | "sgumyi" | "sguyim" | "sguymi" | "sgyimu" | "sgyium" | "sgymiu" | "sgymui" | "sgyuim" | "sgyumi" | "sigm" | "sigmu" | "sigmy" | "sigmuy" | "sigmyu" | "sigym" | "sigum" | "sigumy" | "siguym" | "sigymu" | "sigyum" | "simg" | "simgu" | "simgy" | "simguy" | "simgyu" | "simyg" | "simug" | "simugy" | "simuyg" | "simygu" | "simyug" | "siygm" | "siymg" | "siugm" | "siugmy" | "siugym" | "siumg" | "siumgy" | "siumyg" | "siuygm" | "siuymg" | "siygmu" | "siygum" | "siymgu" | "siymug" | "siyugm" | "siyumg" | "smgi" | "smgiu" | "smgiy" | "smgiuy" | "smgiyu" | "smgyi" | "smgui" | "smguiy" | "smguyi" | "smgyiu" | "smgyui" | "smig" | "smigu" | "smigy" | "smiguy" | "smigyu" | "smiyg" | "smiug" | "smiugy" | "smiuyg" | "smiygu" | "smiyug" | "smygi" | "smyig" | "smugi" | "smugiy" | "smugyi" | "smuig" | "smuigy" | "smuiyg" | "smuygi" | "smuyig" | "smygiu" | "smygui" | "smyigu" | "smyiug" | "smyugi" | "smyuig" | "sygim" | "sygmi" | "syigm" | "syimg" | "symgi" | "symig" | "sugim" | "sugimy" | "sugiym" | "sugmi" | "sugmiy" | "sugmyi" | "sugyim" | "sugymi" | "suigm" | "suigmy" | "suigym" | "suimg" | "suimgy" | "suimyg" | "suiygm" | "suiymg" | "sumgi" | "sumgiy" | "sumgyi" | "sumig" | "sumigy" | "sumiyg" | "sumygi" | "sumyig" | "suygim" | "suygmi" | "suyigm" | "suyimg" | "suymgi" | "suymig" | "sygimu" | "sygium" | "sygmiu" | "sygmui" | "syguim" | "sygumi" | "syigmu" | "syigum" | "syimgu" | "syimug" | "syiugm" | "syiumg" | "symgiu" | "symgui" | "symigu" | "symiug" | "symugi" | "symuig" | "syugim" | "syugmi" | "syuigm" | "syuimg" | "syumgi" | "syumig" | "ygims" | "ygism" | "ygmis" | "ygmsi" | "ygsim" | "ygsmi" | "yigms" | "yigsm" | "yimgs" | "yimsg" | "yisgm" | "yismg" | "ymgis" | "ymgsi" | "ymigs" | "ymisg" | "ymsgi" | "ymsig" | "ysgim" | "ysgmi" | "ysigm" | "ysimg" | "ysmgi" | "ysmig" | "ugims" | "ugimsy" | "ugimys" | "ugism" | "ugismy" | "ugisym" | "ugiyms" | "ugiysm" | "ugmis" | "ugmisy" | "ugmiys" | "ugmsi" | "ugmsiy" | "ugmsyi" | "ugmyis" | "ugmysi" | "ugsim" | "ugsimy" | "ugsiym" | "ugsmi" | "ugsmiy" | "ugsmyi" | "ugsyim" | "ugsymi" | "ugyims" | "ugyism" | "ugymis" | "ugymsi" | "ugysim" | "ugysmi" | "uigms" | "uigmsy" | "uigmys" | "uigsm" | "uigsmy" | "uigsym" | "uigyms" | "uigysm" | "uimgs" | "uimgsy" | "uimgys" | "uimsg" | "uimsgy" | "uimsyg" | "uimygs" | "uimysg" | "uisgm" | "uisgmy" | "uisgym" | "uismg" | "uismgy" | "uismyg" | "uisygm" | "uisymg" | "uiygms" | "uiygsm" | "uiymgs" | "uiymsg" | "uiysgm" | "uiysmg" | "umgis" | "umgisy" | "umgiys" | "umgsi" | "umgsiy" | "umgsyi" | "umgyis" | "umgysi" | "umigs" | "umigsy" | "umigys" | "umisg" | "umisgy" | "umisyg" | "umiygs" | "umiysg" | "umsgi" | "umsgiy" | "umsgyi" | "umsig" | "umsigy" | "umsiyg" | "umsygi" | "umsyig" | "umygis" | "umygsi" | "umyigs" | "umyisg" | "umysgi" | "umysig" | "usgim" | "usgimy" | "usgiym" | "usgmi" | "usgmiy" | "usgmyi" | "usgyim" | "usgymi" | "usigm" | "usigmy" | "usigym" | "usimg" | "usimgy" | "usimyg" | "usiygm" | "usiymg" | "usmgi" | "usmgiy" | "usmgyi" | "usmig" | "usmigy" | "usmiyg" | "usmygi" | "usmyig" | "usygim" | "usygmi" | "usyigm" | "usyimg" | "usymgi" | "usymig" | "uygims" | "uygism" | "uygmis" | "uygmsi" | "uygsim" | "uygsmi" | "uyigms" | "uyigsm" | "uyimgs" | "uyimsg" | "uyisgm" | "uyismg" | "uymgis" | "uymgsi" | "uymigs" | "uymisg" | "uymsgi" | "uymsig" | "uysgim" | "uysgmi" | "uysigm" | "uysimg" | "uysmgi" | "uysmig" | "ygimsu" | "ygimus" | "ygismu" | "ygisum" | "ygiums" | "ygiusm" | "ygmisu" | "ygmius" | "ygmsiu" | "ygmsui" | "ygmuis" | "ygmusi" | "ygsimu" | "ygsium" | "ygsmiu" | "ygsmui" | "ygsuim" | "ygsumi" | "yguims" | "yguism" | "ygumis" | "ygumsi" | "ygusim" | "ygusmi" | "yigmsu" | "yigmus" | "yigsmu" | "yigsum" | "yigums" | "yigusm" | "yimgsu" | "yimgus" | "yimsgu" | "yimsug" | "yimugs" | "yimusg" | "yisgmu" | "yisgum" | "yismgu" | "yismug" | "yisugm" | "yisumg" | "yiugms" | "yiugsm" | "yiumgs" | "yiumsg" | "yiusgm" | "yiusmg" | "ymgisu" | "ymgius" | "ymgsiu" | "ymgsui" | "ymguis" | "ymgusi" | "ymigsu" | "ymigus" | "ymisgu" | "ymisug" | "ymiugs" | "ymiusg" | "ymsgiu" | "ymsgui" | "ymsigu" | "ymsiug" | "ymsugi" | "ymsuig" | "ymugis" | "ymugsi" | "ymuigs" | "ymuisg" | "ymusgi" | "ymusig" | "ysgimu" | "ysgium" | "ysgmiu" | "ysgmui" | "ysguim" | "ysgumi" | "ysigmu" | "ysigum" | "ysimgu" | "ysimug" | "ysiugm" | "ysiumg" | "ysmgiu" | "ysmgui" | "ysmigu" | "ysmiug" | "ysmugi" | "ysmuig" | "ysugim" | "ysugmi" | "ysuigm" | "ysuimg" | "ysumgi" | "ysumig" | "yugims" | "yugism" | "yugmis" | "yugmsi" | "yugsim" | "yugsmi" | "yuigms" | "yuigsm" | "yuimgs" | "yuimsg" | "yuisgm" | "yuismg" | "yumgis" | "yumgsi" | "yumigs" | "yumisg" | "yumsgi" | "yumsig" | "yusgim" | "yusgmi" | "yusigm" | "yusimg" | "yusmgi" | "yusmig") | undefined) => RegExpTsDsl;
   /** Creates a return statement. */
-  return: (expr?: string | typescript0.Expression | TsDsl<typescript0.Expression> | undefined) => ReturnTsDsl;
+  return: (expr?: ReturnExpr | undefined) => ReturnTsDsl;
   /** Creates a setter method declaration. */
-  setter: (name: string | typescript0.PropertyName, fn?: ((s: SetterTsDsl) => void) | undefined) => SetterTsDsl;
+  setter: (name: SetterName, fn?: ((s: SetterTsDsl) => void) | undefined) => SetterTsDsl;
   /** Wraps an expression or statement-like value into a `StmtTsDsl`. */
-  stmt: (inner: typescript0.Expression | typescript0.Statement | TsDsl<any>) => StmtTsDsl;
+  stmt: (inner: ts.Expression | ts.Statement | TsDsl<any>) => StmtTsDsl;
   /** Creates a template literal expression. */
-  template: (value?: string | typescript0.Expression | TsDsl<typescript0.Expression> | undefined) => TemplateTsDsl;
+  template: (value?: TemplatePart | undefined) => TemplateTsDsl;
   /** Creates a ternary conditional expression (if ? then : else). */
-  ternary: (condition?: string | typescript0.Expression | TsDsl<typescript0.Expression> | undefined) => TernaryTsDsl;
+  ternary: (condition?: string | ts.Expression | TsDsl<ts.Expression> | undefined) => TernaryTsDsl;
   /** Creates a throw statement. */
-  throw: (error: string | typescript0.Expression | TsDsl<typescript0.Expression>, useNew?: boolean | undefined) => ThrowTsDsl;
+  throw: (error: string | ts.Expression | TsDsl<ts.Expression>, useNew?: boolean | undefined) => ThrowTsDsl;
   /** Creates a syntax token (e.g. `?`, `readonly`, `+`, `-`). */
   token: () => TokenTsDsl<never>;
+  /** Creates a try/catch/finally statement. */
+  try: (...args: ConstructorParameters<typeof TryTsDsl>) => TryTsDsl;
   /** Creates a basic type reference or type expression (e.g. Foo or Foo<T>). */
-  type: ((name: string, fn?: ((t: TypeExprTsDsl) => void) | undefined) => TypeExprTsDsl) & {
+  type: ((name: TypeExprName, fn?: TypeExprFn | undefined) => TypeExprTsDsl) & {
     /** Creates a type alias declaration (e.g. `type Foo = Bar`). */
-    alias: (name: string, fn?: ((t: TypeAliasTsDsl) => void) | undefined) => TypeAliasTsDsl;
+    alias: (name: string | _hey_api_codegen_core0.Symbol, fn?: ((t: TypeAliasTsDsl) => void) | undefined) => TypeAliasTsDsl;
     /** Creates an intersection type (e.g. `A & B`). */
     and: (...args: ConstructorParameters<typeof TypeAndTsDsl>) => TypeAndTsDsl;
     /** Creates a qualified type reference (e.g. Foo.Bar). */
-    attr: (right: string | typescript0.Identifier) => TypeAttrTsDsl;
+    attr: (right: string | _hey_api_codegen_core0.Symbol | ts.Identifier) => TypeAttrTsDsl;
     /** Creates a basic type reference or type expression (e.g. Foo or Foo<T>). */
-    expr: (name: string, fn?: ((t: TypeExprTsDsl) => void) | undefined) => TypeExprTsDsl;
+    expr: (name: TypeExprName, fn?: TypeExprFn | undefined) => TypeExprTsDsl;
     /** Converts a runtime value into a corresponding type expression node. */
-    fromValue: (input: unknown) => TsDsl<typescript0.TypeNode>;
+    fromValue: (input: unknown) => TsDsl<ts.TypeNode>;
     /** Creates a function type node (e.g. `(a: string) => number`). */
-    func: () => TypeFuncTsDsl;
+    func: (...args: ConstructorParameters<typeof TypeFuncTsDsl>) => TypeFuncTsDsl;
     /** Creates an indexed-access type (e.g. `Foo<T>[K]`). */
-    idx: (base: string | typescript0.TypeNode | TsDsl<typescript0.TypeNode>, index: string | number | typescript0.TypeNode | TsDsl<typescript0.TypeNode>) => TypeIdxTsDsl;
+    idx: (base: string | ts.TypeNode | TsDsl<ts.TypeNode>, index: string | number | ts.TypeNode | TsDsl<ts.TypeNode>) => TypeIdxTsDsl;
     /** Creates a literal type node (e.g. 'foo', 42, or true). */
     literal: (value: string | number | boolean | null) => TypeLiteralTsDsl;
     /** Creates a mapped type (e.g. `{ [K in keyof T]: U }`). */
@@ -7688,18 +7936,18 @@ declare const $: ((id: string | typescript0.Expression | TsDsl<typescript0.Expre
     /** Represents a union type (e.g. `A | B | C`). */
     or: (...args: ConstructorParameters<typeof TypeOrTsDsl>) => TypeOrTsDsl;
     /** Creates a type parameter (e.g. `<T>`). */
-    param: (name?: string | typescript0.Identifier | undefined, fn?: ((name: TypeParamTsDsl) => void) | undefined) => TypeParamTsDsl;
+    param: (name?: TypeParamName | undefined, fn?: ((name: TypeParamTsDsl) => void) | undefined) => TypeParamTsDsl;
     /** Creates a type query node (e.g. `typeof Foo`). */
-    query: (expr: string | MaybeTsDsl<typescript0.Expression | TypeTsDsl<typescript0.TypeNode>>) => TypeQueryTsDsl;
+    query: (expr: TypeQueryExpr) => TypeQueryTsDsl;
     /** Builds a TypeScript template literal *type* (e.g. `${Foo}-${Bar}` as a type). */
-    template: (value?: string | typescript0.TypeNode | TsDsl<typescript0.TypeNode> | undefined) => TypeTemplateTsDsl;
+    template: (value?: string | ts.TypeNode | TsDsl<ts.TypeNode> | undefined) => TypeTemplateTsDsl;
     /** Creates a tuple type (e.g. [A, B, C]). */
     tuple: (...args: ConstructorParameters<typeof TypeTupleTsDsl>) => TypeTupleTsDsl;
   };
-  /** Creates a runtime `typeof` expression (e.g. typeof x). */
-  typeofExpr: (expr: string | typescript0.Expression | TsDsl<typescript0.Expression>) => TypeOfExprTsDsl;
-  /** Creates a variable declaration (var). */
-  var: (name?: string | undefined) => VarTsDsl;
+  /** Creates a `typeof` expression (e.g. `typeof value`). */
+  typeofExpr: (expr: TypeOfExpr) => TypeOfExprTsDsl;
+  /** Creates a variable declaration (`var`). */
+  var: (name?: VarName | undefined) => VarTsDsl;
 };
 type DollarTsDsl = {
   /**
@@ -7716,7 +7964,7 @@ type DollarTsDsl = {
    *
    * Returns:
    * - A new `ExprTsDsl` instance when called directly.
-   * - The `base` factory object for constructing more specific nodes.
+   * - The `tsDsl` object for constructing more specific nodes.
    */
   $: typeof $;
 };
@@ -7805,7 +8053,7 @@ type HeyApiTransformersPlugin = DefinePlugin<UserConfig$13, Config$12>;
 //#region src/plugins/@hey-api/typescript/shared/types.d.ts
 type IrSchemaToAstOptions = {
   plugin: HeyApiTypeScriptPlugin['Instance'];
-  state: ToRefs<PluginState>;
+  state: Refs<PluginState>;
 };
 type PluginState = Pick<Required<SymbolMeta>, 'path'> & Pick<Partial<SymbolMeta>, 'tags'>;
 //#endregion
@@ -14032,14 +14280,25 @@ declare class PluginInstance<T extends Plugin.Types = Plugin.Types> {
     };
   };
   isSymbolRegistered(identifier: SymbolIdentifier): boolean;
+  /**
+   * Sets or adds a node to the project graph.
+   *
+   * @param node The node to be added or updated in the project graph.
+   * @param index The index at which to update the node. If undefined, the node will be added.
+   * @returns The index of the added node or void if updated.
+   */
+  node<T extends number | undefined = undefined>(node: Node | null, index?: T): T extends number ? void : number;
   querySymbol(filter: SymbolMeta): Symbol | undefined;
   referenceSymbol(meta: SymbolMeta): Symbol;
+  /**
+   * @deprecated use `plugin.symbol()` instead
+   */
   registerSymbol(symbol: SymbolIn): Symbol;
   /**
    * Executes plugin's handler function.
    */
   run(): Promise<void>;
-  setSymbolValue(symbol: Symbol, value: unknown): void;
+  symbol(name: SymbolIn['name'], symbol?: Omit<SymbolIn, 'name'>): Symbol;
   private buildEventHooks;
   private forEachError;
   private getSymbolFilePath;
@@ -14052,6 +14311,34 @@ type Hooks = {
    * Event hooks.
    */
   events?: {
+    /**
+     * Triggered after adding or updating a node.
+     *
+     * You can use this to perform actions after a node is added or updated.
+     *
+     * @param args Arguments object.
+     * @returns void
+     */
+    'node:set:after'?: (args: {
+      /** The node added or updated. */
+      node: Node | null;
+      /** Plugin that added or updated the node. */
+      plugin: PluginInstance;
+    }) => void;
+    /**
+     * Triggered before adding or updating a node.
+     *
+     * You can use this to modify the node before it's added or updated.
+     *
+     * @param args Arguments object.
+     * @returns void
+     */
+    'node:set:before'?: (args: {
+      /** The node to be added or updated. */
+      node: Node | null;
+      /** Plugin adding or updating the node. */
+      plugin: PluginInstance;
+    }) => void;
     /**
      * Triggered after executing a plugin handler.
      *
@@ -14100,38 +14387,6 @@ type Hooks = {
       /** Symbol to register. */
       symbol: SymbolIn;
     }) => void;
-    /**
-     * Triggered after setting a symbol value.
-     *
-     * You can use this to perform actions after a symbol's value is set.
-     *
-     * @param args Arguments object.
-     * @returns void
-     */
-    'symbol:setValue:after'?: (args: {
-      /** Plugin that set the symbol value. */
-      plugin: PluginInstance;
-      /** The symbol. */
-      symbol: Symbol;
-      /** The value that was set. */
-      value: unknown;
-    }) => void;
-    /**
-     * Triggered before setting a symbol value.
-     *
-     *  You can use this to modify the value before it's set.
-     *
-     * @param args Arguments object.
-     * @returns void
-     */
-    'symbol:setValue:before'?: (args: {
-      /** Plugin setting the symbol value. */
-      plugin: PluginInstance;
-      /** The symbol. */
-      symbol: Symbol;
-      /** The value to set. */
-      value: unknown;
-    }) => void;
   };
   /**
    * Hooks specifically for overriding operations behavior.
@@ -14293,8 +14548,8 @@ declare namespace Plugin {
    * Generic wrapper for plugin hooks.
    */
   export type Hooks = Pick<BaseConfig, '~hooks'>;
-  export interface Name<Name extends PluginNames> {
-    name: Name;
+  export interface Name<Name$2 extends PluginNames> {
+    name: Name$2;
   }
 
   /**
@@ -14611,8 +14866,8 @@ type UserOutput = {
   /**
    * If specified, this will be the file extension used when importing
    * other modules. By default, we don't add a file extension and let the
-   * runtime resolve it. If you're using moduleResolution `nodenext`, we
-   * default to `.js`.
+   * runtime resolve it. If you're using moduleResolution `nodenext` or
+   * `node16`, we default to `.js`.
    *
    * @default undefined
    */
@@ -14631,10 +14886,28 @@ type UserOutput = {
    * @default null
    */
   lint?: Linters | null;
+  /**
+   * Optional name conflict resolver to customize how naming conflicts
+   * are handled.
+   */
+  nameConflictResolver?: NameConflictResolver;
   /**
    * The absolute path to the output folder.
    */
   path: string;
+  /**
+   * Whether `export * from 'module'` should be used when possible
+   * instead of named exports.
+   *
+   * @default false
+   */
+  preferExportAll?: boolean;
+  /**
+   * Optional function to transform module specifiers.
+   *
+   * @default undefined
+   */
+  resolveModuleName?: (moduleName: string) => string | undefined;
   /**
    * Relative or absolute path to the tsconfig file we should use to
    * generate the output. If a path to tsconfig file is not provided, we
@@ -14649,17 +14922,13 @@ type Output = {
   /**
    * Defines casing of the output fields. By default, we preserve `input`
    * values as data transforms incur a performance penalty at runtime.
-   *
-   * @default undefined
    */
-  case?: StringCase;
+  case: StringCase | undefined;
   /**
    * Clean the `output` folder on every run? If disabled, this folder may
    * be used to store additional files. The default option is `true` to
    * reduce the risk of keeping outdated files around when configuration,
    * input, or package version changes.
-   *
-   * @default true
    */
   clean: boolean;
   /**
@@ -14671,21 +14940,16 @@ type Output = {
   fileName: {
     /**
      * The casing convention to use for generated file names.
-     *
-     * @default 'preserve'
      */
     case: StringCase;
     /**
      * Custom naming pattern for generated file names.
-     *
-     * @default '{{name}}'
      */
     name: StringName;
     /**
      * Suffix to append to file names (before the extension). For example,
      * with a suffix of `.gen`, `example.ts` becomes `example.gen.ts`.
      *
-     * @default '.gen'
      * @example
      * // Given a suffix of `.gen`
      * 'index.ts' -> 'index.ts' (index files are not renamed)
@@ -14696,37 +14960,43 @@ type Output = {
   };
   /**
    * Which formatter to use to process output folder?
-   *
-   * @default null
    */
   format: Formatters | null;
   /**
    * If specified, this will be the file extension used when importing
    * other modules. By default, we don't add a file extension and let the
-   * runtime resolve it. If you're using moduleResolution `nodenext`, we
-   * default to `.js`.
-   *
-   * @default undefined
+   * runtime resolve it. If you're using moduleResolution `nodenext` or
+   * `node16`, we default to `.js`.
    */
   importFileExtension: ImportFileExtensions | (string & {}) | null | undefined;
   /**
    * Should the exports from plugin files be re-exported in the index
    * barrel file? By default, this is enabled and only default plugins
    * are re-exported.
-   *
-   * @default true
    */
   indexFile: boolean;
   /**
    * Which linter to use to process output folder?
-   *
-   * @default null
    */
   lint: Linters | null;
+  /**
+   * Optional name conflict resolver to customize how naming conflicts
+   * are handled.
+   */
+  nameConflictResolver: NameConflictResolver | undefined;
   /**
    * The absolute path to the output folder.
    */
   path: string;
+  /**
+   * Whether `export * from 'module'` should be used when possible
+   * instead of named exports.
+   */
+  preferExportAll: boolean;
+  /**
+   * Optional function to transform module specifiers.
+   */
+  resolveModuleName: ((moduleName: string) => string | undefined) | undefined;
   /**
    * The parsed TypeScript configuration used to generate the output.
    * If no `tsconfig` file path was provided or found, this will be `null`.
@@ -14737,8 +15007,6 @@ type Output = {
    * generate the output. If a path to tsconfig file is not provided, we
    * attempt to find one starting from the location of the
    * `@hey-api/openapi-ts` configuration file and traversing up.
-   *
-   * @default undefined
    */
   tsConfigPath: (string & {}) | null | undefined;
 };
@@ -15384,5 +15652,5 @@ type Config = Omit<Required<UserConfig>, 'input' | 'logs' | 'output' | 'parser'
   plugins: { [K in PluginNames]?: Plugin.Config<PluginConfigMap[K]> };
 };
 //#endregion
-export { PluginHandler as C, MaybeArray as D, LazyOrAsync as E, Client as S, IR$1 as T, $ as _, Plugin as a, TsDsl as b, OpenApiOperationObject as c, OpenApiResponseObject as d, OpenApiSchemaObject as f, ExpressionTransformer as g, TypeTransformer as h, DefinePlugin as i, OpenApiParameterObject as l, Logger as m, UserConfig as n, OpenApi as o, Context as p, Input as r, OpenApiMetaObject as s, Config as t, OpenApiRequestBodyObject as u, DollarTsDsl as v, StringCase as w, TypeTsDsl as x, MaybeTsDsl as y };
-//# sourceMappingURL=config-C5xWXzTz.d.cts.map
+export { LazyOrAsync as A, MaybeTsDsl as C, PluginHandler as D, Client as E, StringCase as O, TypeScriptRenderer as S, TypeTsDsl as T, $ as _, Plugin as a, regexp as b, OpenApiOperationObject as c, OpenApiResponseObject as d, OpenApiSchemaObject as f, ExpressionTransformer as g, TypeTransformer as h, DefinePlugin as i, MaybeArray as j, IR$1 as k, OpenApiParameterObject as l, Logger as m, UserConfig as n, OpenApi as o, Context as p, Input as r, OpenApiMetaObject as s, Config as t, OpenApiRequestBodyObject as u, DollarTsDsl as v, TsDsl as w, keywords as x, reserved as y };
+//# sourceMappingURL=config-Duuay7XM.d.cts.map