@goast/kotlin 0.7.0 → 0.7.1

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

@@ -25,21 +25,88 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     members?: Nullable<Nullable<KtEnumMember<TBuilder>>[]>;
     companionObject?: Nullable<KtObject<TBuilder>>;
 }>;
+/**
+ * The nodes that can be written in the body of an enum class, after the entries. Other append values are written as-is.
+ */
 export type KtEnumMember<TBuilder extends SourceBuilder> = KtConstructor<TBuilder> | KtEnum<TBuilder> | KtInitBlock<TBuilder> | KtInterface<TBuilder> | KtProperty<TBuilder> | KtFunction<TBuilder> | KtClass<TBuilder> | AppendValue<TBuilder>;
+/**
+ * Represents a Kotlin enum class, such as `enum class Color(val rgb: Int) { RED(0xFF0000) }`.
+ *
+ * Written in this order: the doc comment, annotations, the access modifier, `enum class`, the name, the primary
+ * constructor, the implemented interfaces, then the body. The body holds the entries, which are followed by a semicolon
+ * when members or a companion object are written after them.
+ *
+ * @template TBuilder The type of the source builder the enum is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktEnum
+ */
 export declare class KtEnum<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    /**
+     * The name of the enum class, written verbatim after `enum class`.
+     */
     name: string;
+    /**
+     * The KDoc comment written above the enum, or `null` to omit it. Descriptions of primary constructor parameters are
+     * merged into it as `@param` tags.
+     */
     doc: KtDoc<TBuilder> | null;
+    /**
+     * The annotations written above the enum, each on its own line.
+     */
     annotations: KtAnnotation<TBuilder>[];
+    /**
+     * The visibility modifier written before `enum class`, or `null` to omit it. Kotlin declarations are public by
+     * default, so `null` writes a public enum.
+     */
     accessModifier: KtAccessModifier | null;
+    /**
+     * The primary constructor written in parentheses after the name, or `null` to omit it. Its body is written as an
+     * `init` block among the members.
+     */
     primaryConstructor: KtConstructor<TBuilder> | null;
+    /**
+     * The interfaces written after `:`, separated by commas. The clause is omitted when the list is empty.
+     */
     implements: KtType<TBuilder>[];
+    /**
+     * The entries written at the start of the body, separated by commas, in the given order. The body is omitted when
+     * there are neither entries nor members.
+     */
     values: KtEnumValue<TBuilder>[];
+    /**
+     * The members written in the body after the entries, in the given order. Like class members, they are set off by
+     * blank lines.
+     */
     members: KtEnumMember<TBuilder>[];
+    /**
+     * The companion object written first among the members, or `null` to omit it.
+     */
     companionObject: KtObject<TBuilder> | null;
+    /**
+     * Initializes a new instance of the KtEnum class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createEnum: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], values?: Options<TBuilder>['values'], options?: Prettify<Omit<Options<TBuilder>, 'name' | 'values'>>) => KtEnum<TBuilder>;
+/**
+ * Factory for creating enum class nodes. The `write` function writes one or more enum nodes to a builder.
+ *
+ * @param name The name of the enum class.
+ * @param values The entries of the enum. See `KtEnum.values`.
+ * @param options The settings of the enum. See `KtEnum` for the available properties.
+ * @example
+ * ```ts
+ * ktEnum('Color', [ktEnumValue('RED', { arguments: ['0xFF0000'] })], {
+ *   primaryConstructor: ktConstructor([ktParameter('rgb', 'Int')]),
+ * });
+ * // Emits:
+ * // enum class Color(rgb: Int) {
+ * //     RED(0xFF0000)
+ * // }
+ * ```
+ */
 export declare const ktEnum: typeof createEnum & {
     write: typeof writeKtNodes;
 };

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

@@ -6,16 +6,63 @@ import { ktAnnotation } from './annotation.js';
 import { ktDoc } from './doc.js';
 import { ktEnumValue } from './enum-value.js';
 import { ktInitBlock } from './init-block.js';
+/**
+ * Represents a Kotlin enum class, such as `enum class Color(val rgb: Int) { RED(0xFF0000) }`.
+ *
+ * Written in this order: the doc comment, annotations, the access modifier, `enum class`, the name, the primary
+ * constructor, the implemented interfaces, then the body. The body holds the entries, which are followed by a semicolon
+ * when members or a companion object are written after them.
+ *
+ * @template TBuilder The type of the source builder the enum is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktEnum
+ */
 export class KtEnum extends KtNode {
+    /**
+     * The name of the enum class, written verbatim after `enum class`.
+     */
     name;
+    /**
+     * The KDoc comment written above the enum, or `null` to omit it. Descriptions of primary constructor parameters are
+     * merged into it as `@param` tags.
+     */
     doc;
+    /**
+     * The annotations written above the enum, each on its own line.
+     */
     annotations;
+    /**
+     * The visibility modifier written before `enum class`, or `null` to omit it. Kotlin declarations are public by
+     * default, so `null` writes a public enum.
+     */
     accessModifier;
+    /**
+     * The primary constructor written in parentheses after the name, or `null` to omit it. Its body is written as an
+     * `init` block among the members.
+     */
     primaryConstructor;
+    /**
+     * The interfaces written after `:`, separated by commas. The clause is omitted when the list is empty.
+     */
     implements;
+    /**
+     * The entries written at the start of the body, separated by commas, in the given order. The body is omitted when
+     * there are neither entries nor members.
+     */
     values;
+    /**
+     * The members written in the body after the entries, in the given order. Like class members, they are set off by
+     * blank lines.
+     */
     members;
+    /**
+     * The companion object written first among the members, or `null` to omit it.
+     */
     companionObject;
+    /**
+     * Initializes a new instance of the KtEnum class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.name = options.name;
@@ -81,6 +128,23 @@ export class KtEnum extends KtNode {
     }
 }
 const createEnum = (name, values, options) => new KtEnum({ ...options, name, values: values ?? undefined });
+/**
+ * Factory for creating enum class nodes. The `write` function writes one or more enum nodes to a builder.
+ *
+ * @param name The name of the enum class.
+ * @param values The entries of the enum. See `KtEnum.values`.
+ * @param options The settings of the enum. See `KtEnum` for the available properties.
+ * @example
+ * ```ts
+ * ktEnum('Color', [ktEnumValue('RED', { arguments: ['0xFF0000'] })], {
+ *   primaryConstructor: ktConstructor([ktParameter('rgb', 'Int')]),
+ * });
+ * // Emits:
+ * // enum class Color(rgb: Int) {
+ * //     RED(0xFF0000)
+ * // }
+ * ```
+ */
 export const ktEnum = Object.assign(createEnum, {
     write: writeKtNodes,
 });

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

@@ -29,30 +29,135 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     override?: Nullable<boolean>;
     abstract?: Nullable<boolean>;
 }>;
+/**
+ * Represents a Kotlin function declaration, such as `fun String.greet(name: String): String = "Hello, $name"`.
+ *
+ * Written in this order: the doc comment, annotations, the modifiers, `fun`, the generics, the receiver type followed
+ * by a dot, the name, the parameters, the return type, then the body. The modifiers are written in the order access
+ * modifier, `inline`, `infix`, `tailrec`, `suspend`, `open`, `override`, `abstract`, `operator`. A body is omitted for
+ * abstract functions and for functions in an interface that have no body.
+ *
+ * @template TBuilder The type of the source builder the function is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktFunction
+ */
 export declare class KtFunction<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    /**
+     * The name of the function, written verbatim after the receiver type, if there is one.
+     */
     name: string;
+    /**
+     * The type parameters written in angle brackets after `fun`, such as `<T>`. Plain strings are written as-is, while
+     * described parameters also add a `@param` tag to the doc comment.
+     */
     generics: (KtGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    /**
+     * The parameters written in parentheses after the name. Parameters with a description add a `@param` tag to the doc
+     * comment.
+     */
     parameters: (KtParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    /**
+     * The KDoc comment written above the function, or `null` to omit it. Descriptions of generic parameters and function
+     * parameters are merged into it as `@param` tags.
+     */
     doc: KtDoc<TBuilder> | null;
+    /**
+     * The return type written after `:`, or `null` to omit it.
+     */
     returnType: KtType<TBuilder> | null;
+    /**
+     * The statements written inside the braces, or the expression written after `=` when `singleExpression` is set.
+     * `null` writes empty braces. Nothing is written for abstract functions and for interface functions without a body.
+     */
     body: AppendValue<TBuilder> | null;
+    /**
+     * The visibility modifier written before `fun`, or `null` to omit it.
+     */
     accessModifier: KtAccessModifier | null;
+    /**
+     * The annotations written above the function, each on its own line.
+     */
     annotations: KtAnnotation<TBuilder>[];
+    /**
+     * The receiver type written before the name, followed by a dot, such as `String` for `String.greet`. `null` omits it.
+     */
     receiverType: KtType<TBuilder> | null;
+    /**
+     * The annotations written on the same line directly before the receiver type, such as `@Fancy` in
+     * `fun @Fancy String.foo()`. Only written when `receiverType` is set.
+     */
     receiverAnnotations: KtAnnotation<TBuilder>[];
+    /**
+     * Whether the body is written as a single expression after `=` instead of a block in braces. Only applies when a body
+     * is set.
+     * @default false
+     */
     singleExpression: boolean;
+    /**
+     * Whether the function is written with the `open` modifier, which allows subclasses to override it.
+     * @default false
+     */
     open: boolean;
+    /**
+     * Whether the function is written with the `inline` modifier.
+     * @default false
+     */
     inline: boolean;
+    /**
+     * Whether the function is written with the `infix` modifier, which allows calls in infix form.
+     * @default false
+     */
     infix: boolean;
+    /**
+     * Whether the function is written with the `tailrec` modifier, which turns recursive calls into loops.
+     * @default false
+     */
     tailrec: boolean;
+    /**
+     * Whether the function is written with the `suspend` modifier, which makes it a coroutine function.
+     * @default false
+     */
     suspend: boolean;
+    /**
+     * Whether the function is written with the `operator` modifier, which allows calls through operator conventions.
+     * @default false
+     */
     operator: boolean;
+    /**
+     * Whether the function is written with the `override` modifier, which overrides a member of a supertype.
+     * @default false
+     */
     override: boolean;
+    /**
+     * Whether the function is written with the `abstract` modifier. Abstract functions are written without a body.
+     * @default false
+     */
     abstract: boolean;
+    /**
+     * Initializes a new instance of the KtFunction class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createFunction: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => KtFunction<TBuilder>;
+/**
+ * Factory for creating function nodes. The `write` function writes one or more function nodes to a builder.
+ *
+ * @param name The name of the function.
+ * @param options The settings of the function. See `KtFunction` for the available properties.
+ * @example
+ * ```ts
+ * ktFunction('greet', {
+ *   parameters: [ktParameter('name', 'String')],
+ *   returnType: 'String',
+ *   body: '"Hello, $name"',
+ *   singleExpression: true,
+ * });
+ * // Emits:
+ * // fun greet(name: String): String = "Hello, $name"
+ * ```
+ */
 export declare const ktFunction: typeof createFunction & {
     write: typeof writeKtNodes;
 };

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

@@ -6,26 +6,114 @@ import { ktDoc } from './doc.js';
 import { ktGenericParameter } from './generic-parameter.js';
 import { KtInterface } from './interface.js';
 import { ktParameter } from './parameter.js';
+/**
+ * Represents a Kotlin function declaration, such as `fun String.greet(name: String): String = "Hello, $name"`.
+ *
+ * Written in this order: the doc comment, annotations, the modifiers, `fun`, the generics, the receiver type followed
+ * by a dot, the name, the parameters, the return type, then the body. The modifiers are written in the order access
+ * modifier, `inline`, `infix`, `tailrec`, `suspend`, `open`, `override`, `abstract`, `operator`. A body is omitted for
+ * abstract functions and for functions in an interface that have no body.
+ *
+ * @template TBuilder The type of the source builder the function is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktFunction
+ */
 export class KtFunction extends KtNode {
+    /**
+     * The name of the function, written verbatim after the receiver type, if there is one.
+     */
     name;
+    /**
+     * The type parameters written in angle brackets after `fun`, such as `<T>`. Plain strings are written as-is, while
+     * described parameters also add a `@param` tag to the doc comment.
+     */
     generics;
+    /**
+     * The parameters written in parentheses after the name. Parameters with a description add a `@param` tag to the doc
+     * comment.
+     */
     parameters;
+    /**
+     * The KDoc comment written above the function, or `null` to omit it. Descriptions of generic parameters and function
+     * parameters are merged into it as `@param` tags.
+     */
     doc;
+    /**
+     * The return type written after `:`, or `null` to omit it.
+     */
     returnType;
+    /**
+     * The statements written inside the braces, or the expression written after `=` when `singleExpression` is set.
+     * `null` writes empty braces. Nothing is written for abstract functions and for interface functions without a body.
+     */
     body;
+    /**
+     * The visibility modifier written before `fun`, or `null` to omit it.
+     */
     accessModifier;
+    /**
+     * The annotations written above the function, each on its own line.
+     */
     annotations;
+    /**
+     * The receiver type written before the name, followed by a dot, such as `String` for `String.greet`. `null` omits it.
+     */
     receiverType;
+    /**
+     * The annotations written on the same line directly before the receiver type, such as `@Fancy` in
+     * `fun @Fancy String.foo()`. Only written when `receiverType` is set.
+     */
     receiverAnnotations;
+    /**
+     * Whether the body is written as a single expression after `=` instead of a block in braces. Only applies when a body
+     * is set.
+     * @default false
+     */
     singleExpression;
+    /**
+     * Whether the function is written with the `open` modifier, which allows subclasses to override it.
+     * @default false
+     */
     open;
+    /**
+     * Whether the function is written with the `inline` modifier.
+     * @default false
+     */
     inline;
+    /**
+     * Whether the function is written with the `infix` modifier, which allows calls in infix form.
+     * @default false
+     */
     infix;
+    /**
+     * Whether the function is written with the `tailrec` modifier, which turns recursive calls into loops.
+     * @default false
+     */
     tailrec;
+    /**
+     * Whether the function is written with the `suspend` modifier, which makes it a coroutine function.
+     * @default false
+     */
     suspend;
+    /**
+     * Whether the function is written with the `operator` modifier, which allows calls through operator conventions.
+     * @default false
+     */
     operator;
+    /**
+     * Whether the function is written with the `override` modifier, which overrides a member of a supertype.
+     * @default false
+     */
     override;
+    /**
+     * Whether the function is written with the `abstract` modifier. Abstract functions are written without a body.
+     * @default false
+     */
     abstract;
+    /**
+     * Initializes a new instance of the KtFunction class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.name = options.name;
@@ -115,6 +203,23 @@ export class KtFunction extends KtNode {
     }
 }
 const createFunction = (name, options) => new KtFunction({ ...options, name });
+/**
+ * Factory for creating function nodes. The `write` function writes one or more function nodes to a builder.
+ *
+ * @param name The name of the function.
+ * @param options The settings of the function. See `KtFunction` for the available properties.
+ * @example
+ * ```ts
+ * ktFunction('greet', {
+ *   parameters: [ktParameter('name', 'String')],
+ *   returnType: 'String',
+ *   body: '"Hello, $name"',
+ *   singleExpression: true,
+ * });
+ * // Emits:
+ * // fun greet(name: String): String = "Hello, $name"
+ * ```
+ */
 export const ktFunction = Object.assign(createFunction, {
     write: writeKtNodes,
 });

package/dist/src/ast/nodes/generic-parameter.d.ts

@@ -8,14 +8,51 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     description?: Nullable<BasicAppendValue<TBuilder>>;
     constraint?: Nullable<KtType<TBuilder>>;
 }>;
+/**
+ * Represents a type parameter of a Kotlin class or function, such as `T : Number` in `class Box<T : Number>`.
+ *
+ * Written in this order: the name, then ` : ` and the constraint when one is set. The description is not written
+ * next to the parameter, but becomes a `@param` tag in the doc comment of the owning class or function.
+ *
+ * @template TBuilder The type of the source builder the type parameter is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktGenericParameter
+ */
 export declare class KtGenericParameter<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    /**
+     * The name of the type parameter, written verbatim.
+     */
     name: string;
+    /**
+     * The description of the type parameter. It becomes a `@param` tag in the doc comment of the owning class or
+     * function, and `null` adds no tag.
+     */
     description: BasicAppendValue<TBuilder> | null;
+    /**
+     * The upper bound written after ` : `, such as `Number` for `T : Number`, or `null` for an unconstrained parameter.
+     */
     constraint: KtType<TBuilder> | null;
+    /**
+     * Initializes a new instance of the KtGenericParameter class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createGenericParameter: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => KtGenericParameter<TBuilder>;
+/**
+ * Factory for creating generic parameter nodes. The `write` function writes a list of type parameters in angle
+ * brackets, or nothing when the list is empty.
+ *
+ * @param name The name of the type parameter.
+ * @param options The settings of the type parameter. See `KtGenericParameter` for the available properties.
+ * @example
+ * ```ts
+ * ktGenericParameter('T', { constraint: 'Number' });
+ * // Emits:
+ * // T : Number
+ * ```
+ */
 export declare const ktGenericParameter: typeof createGenericParameter & {
     write: typeof writeKtGenericParameters;
 };

package/dist/src/ast/nodes/generic-parameter.js

@@ -1,10 +1,34 @@
 import { KtNode } from '../node.js';
 import { writeKtGenericParameters } from '../utils/write-kt-generic-parameters.js';
 import { writeKtNode } from '../utils/write-kt-node.js';
+/**
+ * Represents a type parameter of a Kotlin class or function, such as `T : Number` in `class Box<T : Number>`.
+ *
+ * Written in this order: the name, then ` : ` and the constraint when one is set. The description is not written
+ * next to the parameter, but becomes a `@param` tag in the doc comment of the owning class or function.
+ *
+ * @template TBuilder The type of the source builder the type parameter is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktGenericParameter
+ */
 export class KtGenericParameter extends KtNode {
+    /**
+     * The name of the type parameter, written verbatim.
+     */
     name;
+    /**
+     * The description of the type parameter. It becomes a `@param` tag in the doc comment of the owning class or
+     * function, and `null` adds no tag.
+     */
     description;
+    /**
+     * The upper bound written after ` : `, such as `Number` for `T : Number`, or `null` for an unconstrained parameter.
+     */
     constraint;
+    /**
+     * Initializes a new instance of the KtGenericParameter class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.name = options.name;
@@ -22,6 +46,19 @@ export class KtGenericParameter extends KtNode {
     }
 }
 const createGenericParameter = (name, options) => new KtGenericParameter({ ...options, name });
+/**
+ * Factory for creating generic parameter nodes. The `write` function writes a list of type parameters in angle
+ * brackets, or nothing when the list is empty.
+ *
+ * @param name The name of the type parameter.
+ * @param options The settings of the type parameter. See `KtGenericParameter` for the available properties.
+ * @example
+ * ```ts
+ * ktGenericParameter('T', { constraint: 'Number' });
+ * // Emits:
+ * // T : Number
+ * ```
+ */
 export const ktGenericParameter = Object.assign(createGenericParameter, {
     write: writeKtGenericParameters,
 });

package/dist/src/ast/nodes/init-block.d.ts

@@ -5,12 +5,44 @@ type Injects = never;
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     body: AppendValue<TBuilder>;
 }>;
+/**
+ * Represents a Kotlin `init` block, whose statements run when the enclosing class is instantiated.
+ *
+ * Written in this order: the `init` keyword, then the body in braces. A body other than an empty string is written on
+ * indented lines of its own, while an empty string writes `init {}` on one line.
+ *
+ * @template TBuilder The type of the source builder the init block is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktInitBlock
+ */
 export declare class KtInitBlock<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    /**
+     * The statements written inside the braces. An empty string writes `init {}` on one line. Any other value is written
+     * on indented lines of its own.
+     */
     body: AppendValue<TBuilder>;
+    /**
+     * Initializes a new instance of the KtInitBlock class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createInitBlock: <TBuilder extends SourceBuilder>(body: Options<TBuilder>['body'], options?: Prettify<Omit<Options<TBuilder>, 'body'>>) => KtInitBlock<TBuilder>;
+/**
+ * Factory for creating init block nodes. The `write` function writes one or more init block nodes to a builder.
+ *
+ * @param body The statements written inside the braces of the init block. See `KtInitBlock.body`.
+ * @param options The settings of the init block. See `KtInitBlock` for the available properties.
+ * @example
+ * ```ts
+ * ktInitBlock('println("Hello")');
+ * // Emits:
+ * // init {
+ * //     println("Hello")
+ * // }
+ * ```
+ */
 export declare const ktInitBlock: typeof createInitBlock & {
     write: typeof writeKtNodes;
 };

package/dist/src/ast/nodes/init-block.js

@@ -1,7 +1,25 @@
 import { KtNode } from '../node.js';
 import { writeKtNodes } from '../utils/write-kt-node.js';
+/**
+ * Represents a Kotlin `init` block, whose statements run when the enclosing class is instantiated.
+ *
+ * Written in this order: the `init` keyword, then the body in braces. A body other than an empty string is written on
+ * indented lines of its own, while an empty string writes `init {}` on one line.
+ *
+ * @template TBuilder The type of the source builder the init block is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktInitBlock
+ */
 export class KtInitBlock extends KtNode {
+    /**
+     * The statements written inside the braces. An empty string writes `init {}` on one line. Any other value is written
+     * on indented lines of its own.
+     */
     body;
+    /**
+     * Initializes a new instance of the KtInitBlock class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.body = options.body;
@@ -11,6 +29,20 @@ export class KtInitBlock extends KtNode {
     }
 }
 const createInitBlock = (body, options) => new KtInitBlock({ ...options, body });
+/**
+ * Factory for creating init block nodes. The `write` function writes one or more init block nodes to a builder.
+ *
+ * @param body The statements written inside the braces of the init block. See `KtInitBlock.body`.
+ * @param options The settings of the init block. See `KtInitBlock` for the available properties.
+ * @example
+ * ```ts
+ * ktInitBlock('println("Hello")');
+ * // Emits:
+ * // init {
+ * //     println("Hello")
+ * // }
+ * ```
+ */
 export const ktInitBlock = Object.assign(createInitBlock, {
     write: writeKtNodes,
 });