@goast/typescript 0.9.0 → 0.9.1

package/dist/src/ast/nodes/types.d.ts

@@ -14,5 +14,17 @@ import type { TsString } from './string.ts';
 import type { TsTuple } from './tuple.ts';
 import type { TsTypeof } from './typeof.ts';
 import type { TsUnionType } from './union-type.ts';
+/**
+ * A type that can be written in a type position, such as a type annotation, a generic argument or a union member.
+ * Plain strings and other append values are written as they are.
+ *
+ * @template TBuilder The type of the source builder the type is written to.
+ */
 export type TsType<TBuilder extends SourceBuilder> = BasicAppendValue<TBuilder> | TsIntersectionType<TBuilder> | TsUnionType<TBuilder> | TsArrayType<TBuilder> | TsTuple<TBuilder> | TsFunctionType<TBuilder> | TsObjectType<TBuilder> | TsString<TBuilder> | TsLookupType<TBuilder> | TsTypeof<TBuilder> | TsReference<TBuilder>;
+/**
+ * A value that can be written in an expression position, such as the initial value of a variable or the default value
+ * of a parameter. Plain strings and other append values are written as they are.
+ *
+ * @template TBuilder The type of the source builder the value is written to.
+ */
 export type TsValue<TBuilder extends SourceBuilder> = BasicAppendValue<TBuilder> | TsObject<TBuilder> | TsTuple<TBuilder> | TsString<TBuilder> | TsArrowFunction<TBuilder> | TsFunction<TBuilder> | TsClass<TBuilder> | TsCall<TBuilder> | TsReference<TBuilder>;

package/dist/src/ast/nodes/union-type.d.ts

@@ -6,12 +6,43 @@ type Injects = never;
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
     types: Nullable<TsType<TBuilder>>[];
 }>;
+/**
+ * Represents a union type, which combines alternative types with `|`, such as `(string) | (number)`.
+ *
+ * Each type is wrapped in parentheses. Nested union types are flattened into the same list. A union without types is
+ * written as `never`, and one with a single type is written as that type without parentheses. Unions of more than three
+ * types are written with one type per line, and each line starts with `|`.
+ *
+ * @template TBuilder The type of the source builder the union type is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsUnionType
+ */
 export declare class TsUnionType<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * The alternative types, in the given order. Null entries are skipped. Nested union types are flattened into this
+     * list when the node is written, so they add no nested parentheses.
+     */
     types: TsType<TBuilder>[];
+    /**
+     * Initializes a new instance of the TsUnionType class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createUnionType: <TBuilder extends SourceBuilder>(types: Options<TBuilder>['types'], options?: Prettify<Omit<Options<TBuilder>, 'types'>>) => TsUnionType<TBuilder>;
+/**
+ * Factory for creating union type nodes. The `write` function writes one or more union type nodes to a builder.
+ *
+ * @param types The alternative types. See `TsUnionType.types` for how they are written.
+ * @param options The settings of the union type. See `TsUnionType` for the available properties.
+ * @example
+ * ```ts
+ * tsUnionType(['string', 'number']);
+ * // Emits:
+ * // (string) | (number)
+ * ```
+ */
 export declare const tsUnionType: typeof createUnionType & {
     write: typeof writeTsNodes;
 };

package/dist/src/ast/nodes/union-type.js

@@ -1,8 +1,27 @@
 import { notNullish } from '@goast/core';
 import { TsNode } from '../node.js';
 import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
+/**
+ * Represents a union type, which combines alternative types with `|`, such as `(string) | (number)`.
+ *
+ * Each type is wrapped in parentheses. Nested union types are flattened into the same list. A union without types is
+ * written as `never`, and one with a single type is written as that type without parentheses. Unions of more than three
+ * types are written with one type per line, and each line starts with `|`.
+ *
+ * @template TBuilder The type of the source builder the union type is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsUnionType
+ */
 export class TsUnionType extends TsNode {
+    /**
+     * The alternative types, in the given order. Null entries are skipped. Nested union types are flattened into this
+     * list when the node is written, so they add no nested parentheses.
+     */
     types;
+    /**
+     * Initializes a new instance of the TsUnionType class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.types = options.types.filter(notNullish);
@@ -24,6 +43,18 @@ export class TsUnionType extends TsNode {
     }
 }
 const createUnionType = (types, options) => new TsUnionType({ ...options, types });
+/**
+ * Factory for creating union type nodes. The `write` function writes one or more union type nodes to a builder.
+ *
+ * @param types The alternative types. See `TsUnionType.types` for how they are written.
+ * @param options The settings of the union type. See `TsUnionType` for the available properties.
+ * @example
+ * ```ts
+ * tsUnionType(['string', 'number']);
+ * // Emits:
+ * // (string) | (number)
+ * ```
+ */
 export const tsUnionType = Object.assign(createUnionType, {
     write: writeTsNodes,
 });

package/dist/src/ast/nodes/variable.d.ts

@@ -12,17 +12,63 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     export?: Nullable<boolean>;
     readonly?: Nullable<boolean>;
 }>;
+/**
+ * Represents a variable declaration, such as `export const x: number = 42;`.
+ *
+ * Written in this order: doc comment, `export` keyword, `const` or `let`, name, type annotation, initial value, and a
+ * semicolon. A variable is declared with `let` unless `readonly` is set, which declares it with `const`.
+ *
+ * @template TBuilder The type of the source builder the variable is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsVariable
+ */
 export declare class TsVariable<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * The name of the variable, written verbatim after `let` or `const`.
+     */
     name: string;
+    /**
+     * The doc comment written above the declaration, or `null` to omit it. It is written as given.
+     */
     doc: TsDoc<TBuilder> | null;
+    /**
+     * The type annotation written after the name, such as `: number`, or `null` to omit it.
+     */
     type: TsType<TBuilder> | null;
+    /**
+     * The initial value written after ` = `, such as ` = 42`, or `null` to omit it. Falsy values are not written.
+     */
     value: TsValue<TBuilder> | null;
+    /**
+     * Whether the declaration is written with the `export` keyword.
+     * @default false
+     */
     export: boolean;
+    /**
+     * Whether the variable is declared with `const` instead of `let`.
+     * @default false
+     */
     readonly: boolean;
+    /**
+     * Initializes a new instance of the TsVariable class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createVariable: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsVariable<TBuilder>;
+/**
+ * Factory for creating variable nodes. The `write` function writes one or more variable nodes to a builder.
+ *
+ * @param name The name of the variable. See `TsVariable.name`.
+ * @param options The settings of the variable. See `TsVariable` for the available properties.
+ * @example
+ * ```ts
+ * tsVariable('x', { type: 'number', value: 42, readonly: true, export: true });
+ * // Emits:
+ * // export const x: number = 42;
+ * ```
+ */
 export declare const tsVariable: typeof createVariable & {
     write: typeof writeTsNodes;
 };

package/dist/src/ast/nodes/variable.js

@@ -1,12 +1,46 @@
 import { TsNode } from '../node.js';
 import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
+/**
+ * Represents a variable declaration, such as `export const x: number = 42;`.
+ *
+ * Written in this order: doc comment, `export` keyword, `const` or `let`, name, type annotation, initial value, and a
+ * semicolon. A variable is declared with `let` unless `readonly` is set, which declares it with `const`.
+ *
+ * @template TBuilder The type of the source builder the variable is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsVariable
+ */
 export class TsVariable extends TsNode {
+    /**
+     * The name of the variable, written verbatim after `let` or `const`.
+     */
     name;
+    /**
+     * The doc comment written above the declaration, or `null` to omit it. It is written as given.
+     */
     doc;
+    /**
+     * The type annotation written after the name, such as `: number`, or `null` to omit it.
+     */
     type;
+    /**
+     * The initial value written after ` = `, such as ` = 42`, or `null` to omit it. Falsy values are not written.
+     */
     value;
+    /**
+     * Whether the declaration is written with the `export` keyword.
+     * @default false
+     */
     export;
+    /**
+     * Whether the variable is declared with `const` instead of `let`.
+     * @default false
+     */
     readonly;
+    /**
+     * Initializes a new instance of the TsVariable class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.name = options.name;
@@ -36,6 +70,18 @@ export class TsVariable extends TsNode {
     }
 }
 const createVariable = (name, options) => new TsVariable({ ...options, name });
+/**
+ * Factory for creating variable nodes. The `write` function writes one or more variable nodes to a builder.
+ *
+ * @param name The name of the variable. See `TsVariable.name`.
+ * @param options The settings of the variable. See `TsVariable` for the available properties.
+ * @example
+ * ```ts
+ * tsVariable('x', { type: 'number', value: 42, readonly: true, export: true });
+ * // Emits:
+ * // export const x: number = 42;
+ * ```
+ */
 export const tsVariable = Object.assign(createVariable, {
     write: writeTsNodes,
 });

package/dist/src/ast/references/angular.d.ts

@@ -1,8 +1,15 @@
 import { type TsGenericModuleReferenceFactory, type TsModuleReferenceFactory } from '../nodes/reference.ts';
+/** Reference to `inject` from the `@angular/core` module. */
 export declare const inject: TsModuleReferenceFactory;
+/** Reference to `Injectable` from the `@angular/core` module. */
 export declare const injectable: TsModuleReferenceFactory;
+/** Reference to `Provider` from the `@angular/core` module, imported as a type. */
 export declare const provider: TsModuleReferenceFactory;
+/** Reference to `HttpClient` from the `@angular/common/http` module. */
 export declare const httpClient: TsModuleReferenceFactory;
+/** Reference to `HttpContext` from the `@angular/common/http` module. */
 export declare const httpContext: TsModuleReferenceFactory;
+/** Reference to `HttpResponse` from the `@angular/common/http` module. Takes one type argument. */
 export declare const httpResponse: TsGenericModuleReferenceFactory<1>;
+/** Reference to `HttpErrorResponse` from the `@angular/common/http` module. */
 export declare const httpErrorResponse: TsModuleReferenceFactory;

package/dist/src/ast/references/angular.js

@@ -1,12 +1,19 @@
 import { tsReference, } from '../nodes/reference.js';
 // @angular/core
+/** Reference to `inject` from the `@angular/core` module. */
 export const inject = tsReference.factory('inject', '@angular/core');
+/** Reference to `Injectable` from the `@angular/core` module. */
 export const injectable = tsReference.factory('Injectable', '@angular/core');
+/** Reference to `Provider` from the `@angular/core` module, imported as a type. */
 export const provider = tsReference.factory('Provider', '@angular/core', {
     importType: 'type-import',
 });
 // @angular/common/http
+/** Reference to `HttpClient` from the `@angular/common/http` module. */
 export const httpClient = tsReference.factory('HttpClient', '@angular/common/http');
+/** Reference to `HttpContext` from the `@angular/common/http` module. */
 export const httpContext = tsReference.factory('HttpContext', '@angular/common/http');
+/** Reference to `HttpResponse` from the `@angular/common/http` module. Takes one type argument. */
 export const httpResponse = tsReference.genericFactory('HttpResponse', '@angular/common/http');
+/** Reference to `HttpErrorResponse` from the `@angular/common/http` module. */
 export const httpErrorResponse = tsReference.factory('HttpErrorResponse', '@angular/common/http');

package/dist/src/ast/references/easy-network-stub.d.ts

@@ -1,5 +1,9 @@
 import { type TsGenericModuleReferenceFactory, type TsModuleReferenceFactory } from '../nodes/reference.ts';
+/** Reference to `EasyNetworkStub` from the `easy-network-stub` module. */
 export declare const easyNetworkStub: TsModuleReferenceFactory;
+/** Reference to `HttpMethod` from the `easy-network-stub` module, imported as a type. */
 export declare const httpMethod: TsModuleReferenceFactory;
+/** Type-only reference to `RouteResponseCallback` from the `easy-network-stub` module. Takes two type arguments. */
 export declare const routeResponseCallback: TsGenericModuleReferenceFactory<2>;
+/** Reference to `ErrorResponse` from the `easy-network-stub` module. Takes one type argument. */
 export declare const errorResponse: TsGenericModuleReferenceFactory<1>;

package/dist/src/ast/references/easy-network-stub.js

@@ -1,9 +1,13 @@
 import { tsReference, } from '../nodes/reference.js';
+/** Reference to `EasyNetworkStub` from the `easy-network-stub` module. */
 export const easyNetworkStub = tsReference.factory('EasyNetworkStub', 'easy-network-stub');
+/** Reference to `HttpMethod` from the `easy-network-stub` module, imported as a type. */
 export const httpMethod = tsReference.factory('HttpMethod', 'easy-network-stub', {
     importType: 'type-import',
 });
+/** Type-only reference to `RouteResponseCallback` from the `easy-network-stub` module. Takes two type arguments. */
 export const routeResponseCallback = tsReference.genericFactory('RouteResponseCallback', 'easy-network-stub', {
     importType: 'type-import',
 });
+/** Reference to `ErrorResponse` from the `easy-network-stub` module. Takes one type argument. */
 export const errorResponse = tsReference.genericFactory('ErrorResponse', 'easy-network-stub');

package/dist/src/ast/references/k6.d.ts

@@ -1,4 +1,7 @@
 import { type TsModuleReferenceFactory } from '../nodes/reference.ts';
+/** Reference to `JSONValue` from the `k6` module. */
 export declare const jsonValue: TsModuleReferenceFactory;
+/** Reference to `Response` from the `k6/http` module. */
 export declare const response: TsModuleReferenceFactory;
+/** Reference to `Params` from the `k6/http` module. */
 export declare const params: TsModuleReferenceFactory;

package/dist/src/ast/references/k6.js

@@ -1,6 +1,9 @@
 import { tsReference } from '../nodes/reference.js';
 // k6
+/** Reference to `JSONValue` from the `k6` module. */
 export const jsonValue = tsReference.factory('JSONValue', 'k6');
 // h6/http
+/** Reference to `Response` from the `k6/http` module. */
 export const response = tsReference.factory('Response', 'k6/http');
+/** Reference to `Params` from the `k6/http` module. */
 export const params = tsReference.factory('Params', 'k6/http');

package/dist/src/ast/references/rxjs.d.ts

@@ -1,6 +1,11 @@
 import { type TsModuleReferenceFactory } from '../nodes/reference.ts';
+/** Reference to `Observable` from the `rxjs` module. */
 export declare const observable: TsModuleReferenceFactory;
+/** Reference to the `firstValueFrom` function from the `rxjs` module. */
 export declare const firstValueFrom: TsModuleReferenceFactory;
+/** Reference to the `filter` operator from the `rxjs` module. */
 export declare const filter: TsModuleReferenceFactory;
+/** Reference to the `map` operator from the `rxjs` module. */
 export declare const map: TsModuleReferenceFactory;
+/** Reference to the `take` operator from the `rxjs` module. */
 export declare const take: TsModuleReferenceFactory;

package/dist/src/ast/references/rxjs.js

@@ -1,6 +1,11 @@
 import { tsReference } from '../nodes/reference.js';
+/** Reference to `Observable` from the `rxjs` module. */
 export const observable = tsReference.factory('Observable', 'rxjs');
+/** Reference to the `firstValueFrom` function from the `rxjs` module. */
 export const firstValueFrom = tsReference.factory('firstValueFrom', 'rxjs');
+/** Reference to the `filter` operator from the `rxjs` module. */
 export const filter = tsReference.factory('filter', 'rxjs');
+/** Reference to the `map` operator from the `rxjs` module. */
 export const map = tsReference.factory('map', 'rxjs');
+/** Reference to the `take` operator from the `rxjs` module. */
 export const take = tsReference.factory('take', 'rxjs');

package/dist/src/ast/references/typescript.d.ts

@@ -1,31 +1,61 @@
 import { type TsGenericReferenceFactory, type TsReferenceFactory } from '../nodes/reference.ts';
+/** Reference to the global `any` type. No import is emitted. */
 export declare const any: TsReferenceFactory;
+/** Reference to the global `unknown` type. No import is emitted. */
 export declare const unknown: TsReferenceFactory;
+/** Reference to the global `void` type. The `_` suffix is needed because `void` is a reserved word. */
 export declare const void_: TsReferenceFactory;
+/** Reference to the global `never` type. No import is emitted. */
 export declare const never: TsReferenceFactory;
+/** Reference to the global `number` type. No import is emitted. */
 export declare const number: TsReferenceFactory;
+/** Reference to the global `string` type. No import is emitted. */
 export declare const string: TsReferenceFactory;
+/** Reference to the global `boolean` type. No import is emitted. */
 export declare const boolean: TsReferenceFactory;
+/** Reference to the global `bigint` type. No import is emitted. */
 export declare const bigint: TsReferenceFactory;
+/** Reference to the global `symbol` type. No import is emitted. */
 export declare const symbol: TsReferenceFactory;
+/** Reference to the global `object` type. No import is emitted. */
 export declare const object: TsReferenceFactory;
+/** Reference to the global `undefined` type. The `_` suffix keeps the name apart from the `undefined` value. */
 export declare const undefined_: TsReferenceFactory;
+/** Reference to the global `null` type. The `_` suffix is needed because `null` is a reserved word. */
 export declare const null_: TsReferenceFactory;
+/** Reference to the global `Array` type. Takes one type argument and emits no import. */
 export declare const array: TsGenericReferenceFactory<1>;
+/** Reference to the global `Record` type. Takes two type arguments and emits no import. */
 export declare const record: TsGenericReferenceFactory<2>;
+/** Reference to the global `Map` type. Takes two type arguments and emits no import. */
 export declare const map: TsGenericReferenceFactory<2>;
+/** Reference to the global `Set` type. Takes one type argument and emits no import. */
 export declare const set: TsGenericReferenceFactory<1>;
+/** Reference to the global `Promise` type. Takes one type argument and emits no import. */
 export declare const promise: TsGenericReferenceFactory<1>;
+/** Reference to the global `ReadonlyArray` type. Takes one type argument and emits no import. */
 export declare const readonlyArray: TsGenericReferenceFactory<1>;
+/** Reference to the global `Readonly` utility type. Takes one type argument and emits no import. */
 export declare const readonly: TsGenericReferenceFactory<1>;
+/** Reference to the global `Partial` utility type. Takes one type argument and emits no import. */
 export declare const partial: TsGenericReferenceFactory<1>;
+/** Reference to the global `Required` utility type. Takes one type argument and emits no import. */
 export declare const required: TsGenericReferenceFactory<1>;
+/** Reference to the global `Pick` utility type. Takes two type arguments and emits no import. */
 export declare const pick: TsGenericReferenceFactory<2>;
+/** Reference to the global `Omit` utility type. Takes two type arguments and emits no import. */
 export declare const omit: TsGenericReferenceFactory<2>;
+/** Reference to the global `Exclude` utility type. Takes two type arguments and emits no import. */
 export declare const exclude: TsGenericReferenceFactory<2>;
+/** Reference to the global `Extract` utility type. Takes two type arguments and emits no import. */
 export declare const extract: TsGenericReferenceFactory<2>;
+/** Reference to the global `NonNullable` utility type. Takes one type argument and emits no import. */
 export declare const nonNullable: TsGenericReferenceFactory<1>;
+/** Reference to the global `Parameters` utility type. Takes one type argument and emits no import. */
 export declare const parameters: TsGenericReferenceFactory<1>;
+/** Reference to the global `ReturnType` utility type. Takes one type argument and emits no import. */
 export declare const returnType: TsGenericReferenceFactory<1>;
+/** Reference to the global `InstanceType` utility type. Takes one type argument and emits no import. */
 export declare const instanceType: TsGenericReferenceFactory<1>;
+/** Reference to the global `Blob` type. No import is emitted. */
 export declare const blob: TsReferenceFactory;

package/dist/src/ast/references/typescript.js

@@ -1,31 +1,61 @@
 import { tsReference } from '../nodes/reference.js';
+/** Reference to the global `any` type. No import is emitted. */
 export const any = tsReference.factory('any');
+/** Reference to the global `unknown` type. No import is emitted. */
 export const unknown = tsReference.factory('unknown');
+/** Reference to the global `void` type. The `_` suffix is needed because `void` is a reserved word. */
 export const void_ = tsReference.factory('void');
+/** Reference to the global `never` type. No import is emitted. */
 export const never = tsReference.factory('never');
+/** Reference to the global `number` type. No import is emitted. */
 export const number = tsReference.factory('number');
+/** Reference to the global `string` type. No import is emitted. */
 export const string = tsReference.factory('string');
+/** Reference to the global `boolean` type. No import is emitted. */
 export const boolean = tsReference.factory('boolean');
+/** Reference to the global `bigint` type. No import is emitted. */
 export const bigint = tsReference.factory('bigint');
+/** Reference to the global `symbol` type. No import is emitted. */
 export const symbol = tsReference.factory('symbol');
+/** Reference to the global `object` type. No import is emitted. */
 export const object = tsReference.factory('object');
+/** Reference to the global `undefined` type. The `_` suffix keeps the name apart from the `undefined` value. */
 export const undefined_ = tsReference.factory('undefined');
+/** Reference to the global `null` type. The `_` suffix is needed because `null` is a reserved word. */
 export const null_ = tsReference.factory('null');
+/** Reference to the global `Array` type. Takes one type argument and emits no import. */
 export const array = tsReference.genericFactory('Array');
+/** Reference to the global `Record` type. Takes two type arguments and emits no import. */
 export const record = tsReference.genericFactory('Record');
+/** Reference to the global `Map` type. Takes two type arguments and emits no import. */
 export const map = tsReference.genericFactory('Map');
+/** Reference to the global `Set` type. Takes one type argument and emits no import. */
 export const set = tsReference.genericFactory('Set');
+/** Reference to the global `Promise` type. Takes one type argument and emits no import. */
 export const promise = tsReference.genericFactory('Promise');
+/** Reference to the global `ReadonlyArray` type. Takes one type argument and emits no import. */
 export const readonlyArray = tsReference.genericFactory('ReadonlyArray');
+/** Reference to the global `Readonly` utility type. Takes one type argument and emits no import. */
 export const readonly = tsReference.genericFactory('Readonly');
+/** Reference to the global `Partial` utility type. Takes one type argument and emits no import. */
 export const partial = tsReference.genericFactory('Partial');
+/** Reference to the global `Required` utility type. Takes one type argument and emits no import. */
 export const required = tsReference.genericFactory('Required');
+/** Reference to the global `Pick` utility type. Takes two type arguments and emits no import. */
 export const pick = tsReference.genericFactory('Pick');
+/** Reference to the global `Omit` utility type. Takes two type arguments and emits no import. */
 export const omit = tsReference.genericFactory('Omit');
+/** Reference to the global `Exclude` utility type. Takes two type arguments and emits no import. */
 export const exclude = tsReference.genericFactory('Exclude');
+/** Reference to the global `Extract` utility type. Takes two type arguments and emits no import. */
 export const extract = tsReference.genericFactory('Extract');
+/** Reference to the global `NonNullable` utility type. Takes one type argument and emits no import. */
 export const nonNullable = tsReference.genericFactory('NonNullable');
+/** Reference to the global `Parameters` utility type. Takes one type argument and emits no import. */
 export const parameters = tsReference.genericFactory('Parameters');
+/** Reference to the global `ReturnType` utility type. Takes one type argument and emits no import. */
 export const returnType = tsReference.genericFactory('ReturnType');
+/** Reference to the global `InstanceType` utility type. Takes one type argument and emits no import. */
 export const instanceType = tsReference.genericFactory('InstanceType');
+/** Reference to the global `Blob` type. No import is emitted. */
 export const blob = tsReference.factory('Blob');

package/dist/src/ast/utils/get-type-script-builder-options.d.ts

@@ -1,3 +1,11 @@
 import { type StringBuilder } from '@goast/core';
 import { type TypeScriptGeneratorConfig } from '../../config.ts';
+/**
+ * Gets the TypeScript generator options that apply to a builder.
+ * A `TypeScriptFileBuilder` returns its own options. For any other builder, the options are merged from the OpenAPI
+ * defaults, the TypeScript defaults and the builder's own options, in that order, so later sources take precedence.
+ * The merged result is also stored on the builder under a private symbol.
+ * @param builder The builder to get the options for.
+ * @returns The TypeScript generator options for the builder.
+ */
 export declare function getTypeScriptBuilderOptions(builder: StringBuilder): TypeScriptGeneratorConfig;

package/dist/src/ast/utils/get-type-script-builder-options.js

@@ -2,6 +2,14 @@ import { defaultOpenApiGeneratorConfig } from '@goast/core';
 import { defaultTypeScriptGeneratorConfig } from '../../config.js';
 import { TypeScriptFileBuilder } from '../../file-builder.js';
 const tsConfigSymbol = Symbol();
+/**
+ * Gets the TypeScript generator options that apply to a builder.
+ * A `TypeScriptFileBuilder` returns its own options. For any other builder, the options are merged from the OpenAPI
+ * defaults, the TypeScript defaults and the builder's own options, in that order, so later sources take precedence.
+ * The merged result is also stored on the builder under a private symbol.
+ * @param builder The builder to get the options for.
+ * @returns The TypeScript generator options for the builder.
+ */
 export function getTypeScriptBuilderOptions(builder) {
     if (builder instanceof TypeScriptFileBuilder) {
         return builder.options;

package/dist/src/ast/utils/to-ts-node.d.ts

@@ -2,7 +2,35 @@ import type { BasicAppendValue, SourceBuilder } from '@goast/core';
 import { type TsObject } from '../nodes/object.ts';
 import { type TsString } from '../nodes/string.ts';
 import { type TsTuple } from '../nodes/tuple.ts';
+/**
+ * Converts a plain object to a TypeScript object literal node.
+ * Each entry becomes a property named after its key, and each value is converted with this function.
+ * @template TBuilder The type of the source builder the node is written to.
+ * @param object The object to convert.
+ * @returns An object node with one property per entry of `object`.
+ */
 export declare function toTsNode<TBuilder extends SourceBuilder>(object: Record<string, unknown>): TsObject<TBuilder>;
+/**
+ * Converts an array to a TypeScript tuple node.
+ * Each item is converted with this function, in order.
+ * @template TBuilder The type of the source builder the node is written to.
+ * @param tuple The array to convert.
+ * @returns A tuple node with one element per item of `tuple`.
+ */
 export declare function toTsNode<TBuilder extends SourceBuilder>(tuple: unknown[]): TsTuple<TBuilder>;
+/**
+ * Converts a string to a TypeScript string literal node.
+ * @template TBuilder The type of the source builder the node is written to.
+ * @param string The string to convert.
+ * @returns A string literal node with the value of `string`.
+ */
 export declare function toTsNode<TBuilder extends SourceBuilder>(string: string): TsString<TBuilder>;
+/**
+ * Converts a value of unknown type to a node. Arrays and objects are converted as in the overloads above.
+ * `null`, `undefined`, booleans and numbers are written as plain text, and any other value is written as a
+ * string literal of its `String()` form.
+ * @template TBuilder The type of the source builder the node is written to.
+ * @param value The value to convert.
+ * @returns The converted node.
+ */
 export declare function toTsNode<TBuilder extends SourceBuilder>(value: unknown): BasicAppendValue<TBuilder>;

package/dist/src/ast/utils/write-ts-generic-parameters.d.ts

@@ -1,3 +1,12 @@
 import { type AppendValue, type Nullable, type SingleOrMultiple, type SourceBuilder } from '@goast/core';
 import type { TsNode } from '../node.ts';
+/**
+ * Writes a type parameter or type argument list in angle brackets, such as `<T, U>`.
+ * Nothing is written when there are no entries. The entries are written on one line, separated by `, `, unless there
+ * are more than two of them. Otherwise each entry is written on its own line, separated by `,` and a line break, and
+ * the closing `>` is written on its own line. Nullish entries are skipped.
+ * @template TBuilder The type of the source builder the entries are written to.
+ * @param builder The builder to write to.
+ * @param nodes The type parameters or arguments to write. A single entry is also accepted.
+ */
 export declare function writeTsGenericParameters<TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<TsNode<TBuilder> | AppendValue<TBuilder>>>): void;

package/dist/src/ast/utils/write-ts-generic-parameters.js

@@ -1,5 +1,14 @@
 import { notNullish, toArray, } from '@goast/core';
 import { writeTsNodes } from './write-ts-nodes.js';
+/**
+ * Writes a type parameter or type argument list in angle brackets, such as `<T, U>`.
+ * Nothing is written when there are no entries. The entries are written on one line, separated by `, `, unless there
+ * are more than two of them. Otherwise each entry is written on its own line, separated by `,` and a line break, and
+ * the closing `>` is written on its own line. Nullish entries are skipped.
+ * @template TBuilder The type of the source builder the entries are written to.
+ * @param builder The builder to write to.
+ * @param nodes The type parameters or arguments to write. A single entry is also accepted.
+ */
 export function writeTsGenericParameters(builder, nodes) {
     const filteredNodes = toArray(nodes).filter(notNullish);
     const multiline = filteredNodes.length > 2;

package/dist/src/ast/utils/write-ts-members.d.ts

@@ -1,5 +1,17 @@
 import { type AppendValue, type Nullable, type SourceBuilder } from '@goast/core';
 import type { TsNode } from '../node.ts';
+/**
+ * Writes class or interface members to a builder, separating them with blank lines where needed.
+ * A compact member is a property or a bodyless method without a doc comment or decorators, or a plain appended value.
+ * Any other member gets a blank line before it, unless it is the first member and `alreadyHasMembers` is not set,
+ * and a blank line after it, unless it is the last member. Compact members get no blank lines of their own, but a
+ * line break is ensured after each one, so consecutive compact members are written on consecutive lines.
+ * @template TBuilder The type of the source builder the members are written to.
+ * @param builder The builder to write to.
+ * @param members The members to write. Nullish entries are skipped.
+ * @param options Options for writing the members. Set `alreadyHasMembers` when the members follow other content
+ *   in the same body, so that the first member also gets a blank line before it.
+ */
 export declare function writeTsMembers<TBuilder extends SourceBuilder>(builder: TBuilder, members: Nullable<AppendValue<TBuilder> | TsNode<TBuilder>>[], options?: {
     alreadyHasMembers?: boolean;
 }): void;

package/dist/src/ast/utils/write-ts-members.js

@@ -3,6 +3,18 @@ import { tsDoc } from '../nodes/doc.js';
 import { TsMethod } from '../nodes/method.js';
 import { TsProperty } from '../nodes/property.js';
 import { writeTsNode } from './write-ts-nodes.js';
+/**
+ * Writes class or interface members to a builder, separating them with blank lines where needed.
+ * A compact member is a property or a bodyless method without a doc comment or decorators, or a plain appended value.
+ * Any other member gets a blank line before it, unless it is the first member and `alreadyHasMembers` is not set,
+ * and a blank line after it, unless it is the last member. Compact members get no blank lines of their own, but a
+ * line break is ensured after each one, so consecutive compact members are written on consecutive lines.
+ * @template TBuilder The type of the source builder the members are written to.
+ * @param builder The builder to write to.
+ * @param members The members to write. Nullish entries are skipped.
+ * @param options Options for writing the members. Set `alreadyHasMembers` when the members follow other content
+ *   in the same body, so that the first member also gets a blank line before it.
+ */
 export function writeTsMembers(builder, members, options) {
     const filteredMembers = members.filter(notNullish);
     builder.forEach(filteredMembers, (b, m, i) => b.if(() => !(m instanceof TsProperty && tsDoc.isEmpty(m.doc) && m.decorators.length === 0) &&

package/dist/src/ast/utils/write-ts-nodes.d.ts

@@ -1,6 +1,22 @@
 import { type AppendValue, type Nullable, type Separator, type SingleOrMultiple, type SourceBuilder } from '@goast/core';
 import { TsNode } from '../node.ts';
+/**
+ * Writes a single node or value to a builder.
+ * A `TsNode` writes itself. Any other value is passed to the builder's `append` method.
+ * @template TBuilder The type of the source builder the node is written to.
+ * @param builder The builder to write to.
+ * @param node The node or value to write.
+ */
 export declare function writeTsNode<TBuilder extends SourceBuilder>(builder: TBuilder, node: Nullable<AppendValue<TBuilder> | TsNode<TBuilder>>): void;
+/**
+ * Writes one or more nodes or values to a builder, one after another.
+ * Nullish entries are skipped, and nothing is written when no entries remain. Without a separator, the entries are
+ * written back to back, so any line break has to come from the nodes themselves.
+ * @template TBuilder The type of the source builder the nodes are written to.
+ * @param builder The builder to write to.
+ * @param nodes The nodes or values to write. A single entry is also accepted.
+ * @param options Options for writing. `separator` is written between each pair of written entries.
+ */
 export declare function writeTsNodes<TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<AppendValue<TBuilder> | TsNode<TBuilder>>>, options?: {
     separator?: Separator<TBuilder, AppendValue<TBuilder> | TsNode<TBuilder>>;
 }): void;