@goast/typescript 0.9.0-beta.2 → 0.9.1

package/dist/src/assets.d.ts

@@ -1,2 +1,20 @@
+/**
+ * Gets the text content of an asset file that is shipped with the TypeScript generator package. The files are read
+ * from the `assets` directory of the package.
+ * @param relativePath The path of the asset file, relative to the `assets` directory, such as `client/angular/...`.
+ * @returns The text content of the asset file.
+ */
 export declare const getAssetFileContent: (relativePath: string) => Promise<string>;
+/**
+ * Copies an asset file that is shipped with the TypeScript generator package into a directory. The file keeps its
+ * base name and replaces any existing file with that name.
+ * @param relativePath The path of the asset file, relative to the `assets` directory.
+ * @param destDir The directory to copy the file into.
+ * @param logName The name to show in the log message. Nothing is logged if omitted, and an empty string logs the path.
+ * @returns A promise that resolves when the file has been copied.
+ * @example
+ * ```ts
+ * await copyAssetFile('client/angular/request-builder.ts', targetDir, 'Request Builder');
+ * ```
+ */
 export declare const copyAssetFile: (relativePath: string, destDir: string, logName?: string) => Promise<void>;

package/dist/src/assets.js

@@ -1,5 +1,23 @@
 import { AssetManager } from '@goast/core';
 import { URL } from 'node:url';
 const manager = new AssetManager(new URL('../assets/', import.meta.url));
+/**
+ * Gets the text content of an asset file that is shipped with the TypeScript generator package. The files are read
+ * from the `assets` directory of the package.
+ * @param relativePath The path of the asset file, relative to the `assets` directory, such as `client/angular/...`.
+ * @returns The text content of the asset file.
+ */
 export const getAssetFileContent = manager.getAssetFileContent.bind(manager);
+/**
+ * Copies an asset file that is shipped with the TypeScript generator package into a directory. The file keeps its
+ * base name and replaces any existing file with that name.
+ * @param relativePath The path of the asset file, relative to the `assets` directory.
+ * @param destDir The directory to copy the file into.
+ * @param logName The name to show in the log message. Nothing is logged if omitted, and an empty string logs the path.
+ * @returns A promise that resolves when the file has been copied.
+ * @example
+ * ```ts
+ * await copyAssetFile('client/angular/request-builder.ts', targetDir, 'Request Builder');
+ * ```
+ */
 export const copyAssetFile = manager.copyAssetFile.bind(manager);

package/dist/src/ast/common.d.ts

@@ -1 +1,7 @@
+/**
+ * The access modifier of a class member, written before the member as `public`, `protected` or `private`.
+ * Members without an access modifier are written without a keyword.
+ * @see TsMethod
+ * @see TsProperty
+ */
 export type TsAccessModifier = 'public' | 'protected' | 'private';

package/dist/src/ast/node.d.ts

@@ -1,4 +1,19 @@
 import { AstNode, type AstNodeOptions, type SourceBuilder } from '@goast/core';
+/**
+ * Base class of the TypeScript AST nodes. It adds no output of its own: each subclass renders its code in `onWrite`,
+ * and the `write` method of `AstNode` wraps that output in the `before` and `after` injections.
+ *
+ * Besides `before` and `after`, a node accepts the injection points that its subclass declares through `TInjects`,
+ * such as `beforeName` or `afterBody`.
+ *
+ * @template TBuilder The type of the source builder the node is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see AstNode
+ */
 export declare abstract class TsNode<TBuilder extends SourceBuilder, TInjects extends string = never> extends AstNode<TBuilder, TInjects> {
+    /**
+     * Initializes a new instance of the TsNode class.
+     * @param options The options to use for this instance. They are passed on to the `AstNode` base class.
+     */
     constructor(options: AstNodeOptions<typeof AstNode<TBuilder, TInjects>>);
 }

package/dist/src/ast/node.js

@@ -1,5 +1,20 @@
 import { AstNode } from '@goast/core';
+/**
+ * Base class of the TypeScript AST nodes. It adds no output of its own: each subclass renders its code in `onWrite`,
+ * and the `write` method of `AstNode` wraps that output in the `before` and `after` injections.
+ *
+ * Besides `before` and `after`, a node accepts the injection points that its subclass declares through `TInjects`,
+ * such as `beforeName` or `afterBody`.
+ *
+ * @template TBuilder The type of the source builder the node is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see AstNode
+ */
 export class TsNode extends AstNode {
+    /**
+     * Initializes a new instance of the TsNode class.
+     * @param options The options to use for this instance. They are passed on to the `AstNode` base class.
+     */
     constructor(options) {
         super(options);
     }

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

@@ -6,12 +6,43 @@ type Injects = never;
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
     value: TsValue<TBuilder>;
 }>;
+/**
+ * Represents a single argument of a call or a decorator. The node itself writes only the value.
+ *
+ * The parentheses around the arguments and the separators between them are written by the `write` function. It writes
+ * the parentheses even when there are no arguments, and puts one argument per line when there are more than two.
+ *
+ * @template TBuilder The type of the source builder the argument is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsArgument
+ */
 export declare class TsArgument<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * The value written as the argument, such as `42` or an expression. Nodes are written with their own output, and
+     * other values are appended as they are.
+     */
     value: TsValue<TBuilder>;
+    /**
+     * Initializes a new instance of the TsArgument class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createArgument: <TBuilder extends SourceBuilder>(value: Options<TBuilder>['value'], options?: Prettify<Omit<Options<TBuilder>, 'value'>>) => TsArgument<TBuilder>;
+/**
+ * Factory for creating argument nodes. The `write` function writes one or more arguments to a builder, enclosed in
+ * parentheses.
+ *
+ * @param value The value of the argument.
+ * @param options The settings of the argument. See `TsArgument` for the available properties.
+ * @example
+ * ```ts
+ * tsArgument('42');
+ * // Emits:
+ * // 42
+ * ```
+ */
 export declare const tsArgument: typeof createArgument & {
     write: typeof writeTsParameters;
 };

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

@@ -1,8 +1,26 @@
 import { TsNode } from '../node.js';
 import { writeTsNode } from '../utils/write-ts-nodes.js';
 import { writeTsParameters } from '../utils/write-ts-parameters.js';
+/**
+ * Represents a single argument of a call or a decorator. The node itself writes only the value.
+ *
+ * The parentheses around the arguments and the separators between them are written by the `write` function. It writes
+ * the parentheses even when there are no arguments, and puts one argument per line when there are more than two.
+ *
+ * @template TBuilder The type of the source builder the argument is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsArgument
+ */
 export class TsArgument extends TsNode {
+    /**
+     * The value written as the argument, such as `42` or an expression. Nodes are written with their own output, and
+     * other values are appended as they are.
+     */
     value;
+    /**
+     * Initializes a new instance of the TsArgument class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.value = options.value;
@@ -12,6 +30,19 @@ export class TsArgument extends TsNode {
     }
 }
 const createArgument = (value, options) => new TsArgument({ ...options, value });
+/**
+ * Factory for creating argument nodes. The `write` function writes one or more arguments to a builder, enclosed in
+ * parentheses.
+ *
+ * @param value The value of the argument.
+ * @param options The settings of the argument. See `TsArgument` for the available properties.
+ * @example
+ * ```ts
+ * tsArgument('42');
+ * // Emits:
+ * // 42
+ * ```
+ */
 export const tsArgument = Object.assign(createArgument, {
     write: writeTsParameters,
 });

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

@@ -7,13 +7,45 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     readonly?: Nullable<boolean>;
     type: TsType<TBuilder>;
 }>;
+/**
+ * Represents an array type, such as `readonly (number)[]`. The element type is always wrapped in parentheses.
+ *
+ * Written in this order: the `readonly` keyword when set, the element type in parentheses, then `[]`.
+ *
+ * @template TBuilder The type of the source builder the array type is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsArrayType
+ */
 export declare class TsArrayType<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * Whether the array is written with the `readonly` keyword in front of it.
+     * @default false
+     */
     readonly: boolean;
+    /**
+     * The element type of the array. It is always wrapped in parentheses, so `number` is written as `(number)[]`.
+     */
     type: TsType<TBuilder>;
+    /**
+     * Initializes a new instance of the TsArrayType class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createArrayType: <TBuilder extends SourceBuilder>(type: Options<TBuilder>['type'], options?: Prettify<Omit<Options<TBuilder>, 'type'>>) => TsArrayType<TBuilder>;
+/**
+ * Factory for creating array type nodes. The `write` function writes one or more array types to a builder.
+ *
+ * @param type The element type of the array.
+ * @param options The settings of the array type. See `TsArrayType` for the available properties.
+ * @example
+ * ```ts
+ * tsArrayType('number', { readonly: true });
+ * // Emits:
+ * // readonly (number)[]
+ * ```
+ */
 export declare const tsArrayType: typeof createArrayType & {
     write: typeof writeTsNodes;
 };

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

@@ -1,8 +1,28 @@
 import { TsNode } from '../node.js';
 import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
+/**
+ * Represents an array type, such as `readonly (number)[]`. The element type is always wrapped in parentheses.
+ *
+ * Written in this order: the `readonly` keyword when set, the element type in parentheses, then `[]`.
+ *
+ * @template TBuilder The type of the source builder the array type is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsArrayType
+ */
 export class TsArrayType extends TsNode {
+    /**
+     * Whether the array is written with the `readonly` keyword in front of it.
+     * @default false
+     */
     readonly;
+    /**
+     * The element type of the array. It is always wrapped in parentheses, so `number` is written as `(number)[]`.
+     */
     type;
+    /**
+     * Initializes a new instance of the TsArrayType class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.readonly = options.readonly ?? false;
@@ -19,6 +39,18 @@ export class TsArrayType extends TsNode {
     }
 }
 const createArrayType = (type, options) => new TsArrayType({ ...options, type });
+/**
+ * Factory for creating array type nodes. The `write` function writes one or more array types to a builder.
+ *
+ * @param type The element type of the array.
+ * @param options The settings of the array type. See `TsArrayType` for the available properties.
+ * @example
+ * ```ts
+ * tsArrayType('number', { readonly: true });
+ * // Emits:
+ * // readonly (number)[]
+ * ```
+ */
 export const tsArrayType = Object.assign(createArrayType, {
     write: writeTsNodes,
 });

package/dist/src/ast/nodes/arrow-function.d.ts

@@ -13,17 +13,73 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     singleExpression?: Nullable<boolean>;
     body?: Nullable<AppendValue<TBuilder>>;
 }>;
+/**
+ * Represents an arrow function, such as `(x, y): number => { ... }`.
+ *
+ * Written in this order: the `async` keyword when set, the generics, the parameters, the return type, ` => `, then the
+ * body. The function has no doc comment and no decorators.
+ *
+ * @template TBuilder The type of the source builder the arrow function is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsArrowFunction
+ */
 export declare class TsArrowFunction<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * Whether the function is written with the `async` keyword in front of it.
+     * @default false
+     */
     async: boolean;
+    /**
+     * The type parameters written in angle brackets before the parameters, such as `<T, U>`. Nothing is written when
+     * there are none.
+     */
     generics: (TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    /**
+     * The parameters written in parentheses, such as `(x, y)`. The parentheses are always written, and more than two
+     * parameters are written one per line.
+     */
     parameters: (TsParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    /**
+     * The return type written after the parameters as `: Type`, or `null` to omit it.
+     */
     returnType: TsType<TBuilder> | null;
+    /**
+     * Whether the body is written directly after ` => ` without braces, such as `(x) => x * 2`. Without a body, empty
+     * braces are written instead.
+     * @default false
+     */
     singleExpression: boolean;
+    /**
+     * The body of the function, or `null` to write empty braces `{}`. A block body is written in braces on its own
+     * indented lines. With `singleExpression` the body is written without braces.
+     */
     body: AppendValue<TBuilder> | null;
+    /**
+     * Initializes a new instance of the TsArrowFunction class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createArrowFunction: <TBuilder extends SourceBuilder>(options?: Options<TBuilder>) => TsArrowFunction<TBuilder>;
+/**
+ * Factory for creating arrow function nodes. The `write` function writes one or more arrow functions to a builder.
+ *
+ * @param options The settings of the arrow function. See `TsArrowFunction` for the available properties.
+ * @example
+ * ```ts
+ * tsArrowFunction({
+ *   generics: ['T', 'U'],
+ *   parameters: ['x', 'y'],
+ *   returnType: 'number',
+ *   body: 'return 42;',
+ * });
+ * // Emits:
+ * // <T, U>(x, y): number => {
+ * //   return 42;
+ * // }
+ * ```
+ */
 export declare const tsArrowFunction: typeof createArrowFunction & {
     write: typeof writeTsNodes;
 };

package/dist/src/ast/nodes/arrow-function.js

@@ -3,13 +3,51 @@ import { TsNode } from '../node.js';
 import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
 import { tsGenericParameter } from './generic-parameter.js';
 import { tsParameter } from './parameter.js';
+/**
+ * Represents an arrow function, such as `(x, y): number => { ... }`.
+ *
+ * Written in this order: the `async` keyword when set, the generics, the parameters, the return type, ` => `, then the
+ * body. The function has no doc comment and no decorators.
+ *
+ * @template TBuilder The type of the source builder the arrow function is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsArrowFunction
+ */
 export class TsArrowFunction extends TsNode {
+    /**
+     * Whether the function is written with the `async` keyword in front of it.
+     * @default false
+     */
     async;
+    /**
+     * The type parameters written in angle brackets before the parameters, such as `<T, U>`. Nothing is written when
+     * there are none.
+     */
     generics;
+    /**
+     * The parameters written in parentheses, such as `(x, y)`. The parentheses are always written, and more than two
+     * parameters are written one per line.
+     */
     parameters;
+    /**
+     * The return type written after the parameters as `: Type`, or `null` to omit it.
+     */
     returnType;
+    /**
+     * Whether the body is written directly after ` => ` without braces, such as `(x) => x * 2`. Without a body, empty
+     * braces are written instead.
+     * @default false
+     */
     singleExpression;
+    /**
+     * The body of the function, or `null` to write empty braces `{}`. A block body is written in braces on its own
+     * indented lines. With `singleExpression` the body is written without braces.
+     */
     body;
+    /**
+     * Initializes a new instance of the TsArrowFunction class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.async = options.async ?? false;
@@ -47,6 +85,24 @@ export class TsArrowFunction extends TsNode {
     }
 }
 const createArrowFunction = (options) => new TsArrowFunction(options ?? {});
+/**
+ * Factory for creating arrow function nodes. The `write` function writes one or more arrow functions to a builder.
+ *
+ * @param options The settings of the arrow function. See `TsArrowFunction` for the available properties.
+ * @example
+ * ```ts
+ * tsArrowFunction({
+ *   generics: ['T', 'U'],
+ *   parameters: ['x', 'y'],
+ *   returnType: 'number',
+ *   body: 'return 42;',
+ * });
+ * // Emits:
+ * // <T, U>(x, y): number => {
+ * //   return 42;
+ * // }
+ * ```
+ */
 export const tsArrowFunction = Object.assign(createArrowFunction, {
     write: writeTsNodes,
 });

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

@@ -8,13 +8,47 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     path: Nullable<TsType<TBuilder> | TsValue<TBuilder>>[];
     arguments?: Nullable<Nullable<TsArgument<TBuilder> | TsValue<TBuilder>>[]>;
 }>;
+/**
+ * Represents a call, such as `console.log('x', 42)`.
+ *
+ * Written in this order: the path, with its segments joined by dots, then the arguments in parentheses when they are
+ * set.
+ *
+ * @template TBuilder The type of the source builder the call is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsCall
+ */
 export declare class TsCall<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * The segments of the called expression, joined with dots, such as `a.b.c`. Nullish segments are left out.
+     */
     path: (TsType<TBuilder> | TsValue<TBuilder>)[];
+    /**
+     * The arguments written in parentheses after the path, or `null` to write no parentheses at all. An empty array
+     * writes `()`.
+     */
     arguments: (TsArgument<TBuilder> | TsValue<TBuilder>)[] | null;
+    /**
+     * Initializes a new instance of the TsCall class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createCall: <TBuilder extends SourceBuilder>(path: Options<TBuilder>['path'] | ArrayItem<Options<TBuilder>['path']>, args?: Options<TBuilder>['arguments'], options?: Prettify<Omit<Options<TBuilder>, 'path' | 'arguments'>>) => TsCall<TBuilder>;
+/**
+ * Factory for creating call nodes. The `write` function writes one or more calls to a builder.
+ *
+ * @param path The segments of the called expression. A single segment can be passed without an array.
+ * @param args The arguments of the call. Omit them to write no parentheses.
+ * @param options The settings of the call. See `TsCall` for the available properties.
+ * @example
+ * ```ts
+ * tsCall(['console', 'log'], ["'Hello'", '42']);
+ * // Emits:
+ * // console.log('Hello', 42)
+ * ```
+ */
 export declare const tsCall: typeof createCall & {
     write: typeof writeTsNodes;
 };

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

@@ -2,9 +2,30 @@ import { notNullish, } from '@goast/core';
 import { TsNode } from '../node.js';
 import { writeTsNodes } from '../utils/write-ts-nodes.js';
 import { tsArgument } from './argument.js';
+/**
+ * Represents a call, such as `console.log('x', 42)`.
+ *
+ * Written in this order: the path, with its segments joined by dots, then the arguments in parentheses when they are
+ * set.
+ *
+ * @template TBuilder The type of the source builder the call is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsCall
+ */
 export class TsCall extends TsNode {
+    /**
+     * The segments of the called expression, joined with dots, such as `a.b.c`. Nullish segments are left out.
+     */
     path;
+    /**
+     * The arguments written in parentheses after the path, or `null` to write no parentheses at all. An empty array
+     * writes `()`.
+     */
     arguments;
+    /**
+     * Initializes a new instance of the TsCall class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.path = options.path.filter(notNullish);
@@ -18,6 +39,19 @@ export class TsCall extends TsNode {
     }
 }
 const createCall = (path, args, options) => new TsCall({ ...options, path: Array.isArray(path) ? path : [path], arguments: args });
+/**
+ * Factory for creating call nodes. The `write` function writes one or more calls to a builder.
+ *
+ * @param path The segments of the called expression. A single segment can be passed without an array.
+ * @param args The arguments of the call. Omit them to write no parentheses.
+ * @param options The settings of the call. See `TsCall` for the available properties.
+ * @example
+ * ```ts
+ * tsCall(['console', 'log'], ["'Hello'", '42']);
+ * // Emits:
+ * // console.log('Hello', 42)
+ * ```
+ */
 export const tsCall = Object.assign(createCall, {
     write: writeTsNodes,
 });

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

@@ -22,20 +22,93 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     members?: Nullable<Nullable<Member<TBuilder>>[]>;
 }>;
 type Member<TBuilder extends SourceBuilder> = TsProperty<TBuilder> | TsMethod<TBuilder> | TsIndexer<TBuilder> | TsConstructor<TBuilder> | BasicAppendValue<TBuilder>;
+/**
+ * Represents a TypeScript class declaration.
+ *
+ * Written in this order: doc comment, decorators, modifiers, name, generics, heritage clauses, then the body.
+ *
+ * @template TBuilder The type of the source builder the class is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see tsClass
+ */
 export declare class TsClass<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    /**
+     * The doc comment written above the class, or `null` to omit it.
+     * Descriptions of generic parameters are merged into it as `@template` tags.
+     */
     doc: TsDoc<TBuilder> | null;
+    /**
+     * The decorators written above the class declaration, each on its own line.
+     */
     decorators: TsDecorator<TBuilder>[];
+    /**
+     * Whether the class is written with the `export` keyword.
+     * @default false
+     */
     export: boolean;
+    /**
+     * Whether the class is written with the `abstract` modifier, placed after `export` when both are set.
+     * @default false
+     */
     abstract: boolean;
+    /**
+     * The class name, written verbatim after the `class` keyword.
+     */
     name: string;
+    /**
+     * The type parameters written in angle brackets after the name, such as `<T, U>`.
+     * Plain strings are written as-is; described parameters also add a `@template` tag to the doc comment.
+     */
     generics: (TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    /**
+     * The base class written after `extends`, or `null` to omit the clause.
+     */
     extends: TsReference<TBuilder> | BasicAppendValue<TBuilder> | null;
+    /**
+     * The interfaces written after `implements` as a comma-separated list. The clause is omitted when empty.
+     */
     implements: (TsReference<TBuilder> | BasicAppendValue<TBuilder>)[];
+    /**
+     * The members written in the class body, in the given order.
+     * Properties and bodyless methods without a doc comment or decorators are written without blank lines,
+     * other members are set off by blank lines.
+     */
     members: Member<TBuilder>[];
+    /**
+     * Initializes a new instance of the TsClass class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createClass: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsClass<TBuilder>;
+/**
+ * Factory for creating class nodes. The `write` function writes one or more class nodes to a builder.
+ *
+ * @param name The name of the class.
+ * @param options The settings of the class. See `TsClass` for the available properties.
+ * @example
+ * ```ts
+ * tsClass('X', {
+ *   decorators: [tsDecorator('decorator')],
+ *   export: true,
+ *   abstract: true,
+ *   generics: ['T', 'U'],
+ *   extends: tsReference('Y'),
+ *   implements: [tsReference('Z')],
+ *   members: [tsProperty('x'), tsConstructor(), tsMethod('y')],
+ * });
+ * // Emits:
+ * // @decorator
+ * // export abstract class X<T, U> extends Y implements Z {
+ * //   x;
+ * //
+ * //   constructor() {}
+ * //
+ * //   y();
+ * // }
+ * ```
+ */
 export declare const tsClass: typeof createClass & {
     write: typeof writeTsNodes;
 };