@goast/kotlin 0.7.0-beta.2 → 0.7.1

package/dist/src/ast/nodes/collection-literal.d.ts

@@ -6,12 +6,47 @@ type Injects = never;
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     elements: Nullable<Nullable<KtValue<TBuilder>>[]>;
 }>;
+/**
+ * Represents a Kotlin collection literal, such as `["read", "write"]`. Kotlin accepts collection literals only inside
+ * annotation arguments.
+ *
+ * Written in this order: the opening bracket, the elements separated by commas, then the closing bracket.
+ *
+ * @template TBuilder The type of the source builder the collection literal is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktCollectionLiteral
+ */
 export declare class KtCollectionLiteral<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    /**
+     * The elements written between the brackets, in the given order. Nullish elements are dropped before counting.
+     * Literals with more than two elements are written one element per line, shorter ones on a single line.
+     */
     elements: KtValue<TBuilder>[];
+    /**
+     * Initializes a new instance of the KtCollectionLiteral class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createCollectionLiteral: <TBuilder extends SourceBuilder>(elements: Options<TBuilder>['elements'], options?: Omit<Options<TBuilder>, 'elements'>) => KtCollectionLiteral<TBuilder>;
+/**
+ * Factory for creating collection literal nodes. The `write` function writes one or more collection literals to a
+ * builder.
+ *
+ * @param elements The elements of the literal. Nullish elements are dropped.
+ * @param options The settings of the literal, which only contain the injection points. See `KtCollectionLiteral`.
+ * @example
+ * ```ts
+ * ktCollectionLiteral(['"read"', '"write"', '"admin"']);
+ * // Emits:
+ * // [
+ * //     "read",
+ * //     "write",
+ * //     "admin"
+ * // ]
+ * ```
+ */
 export declare const ktCollectionLiteral: typeof createCollectionLiteral & {
     write: typeof writeKtNodes;
 };

package/dist/src/ast/nodes/collection-literal.js

@@ -1,8 +1,26 @@
 import { notNullish } from '@goast/core';
 import { KtNode } from '../node.js';
 import { writeKtNodes } from '../utils/write-kt-node.js';
+/**
+ * Represents a Kotlin collection literal, such as `["read", "write"]`. Kotlin accepts collection literals only inside
+ * annotation arguments.
+ *
+ * Written in this order: the opening bracket, the elements separated by commas, then the closing bracket.
+ *
+ * @template TBuilder The type of the source builder the collection literal is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktCollectionLiteral
+ */
 export class KtCollectionLiteral extends KtNode {
+    /**
+     * The elements written between the brackets, in the given order. Nullish elements are dropped before counting.
+     * Literals with more than two elements are written one element per line, shorter ones on a single line.
+     */
     elements;
+    /**
+     * Initializes a new instance of the KtCollectionLiteral class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.elements = options.elements?.filter(notNullish) ?? [];
@@ -15,6 +33,23 @@ export class KtCollectionLiteral extends KtNode {
     }
 }
 const createCollectionLiteral = (elements, options) => new KtCollectionLiteral({ ...options, elements });
+/**
+ * Factory for creating collection literal nodes. The `write` function writes one or more collection literals to a
+ * builder.
+ *
+ * @param elements The elements of the literal. Nullish elements are dropped.
+ * @param options The settings of the literal, which only contain the injection points. See `KtCollectionLiteral`.
+ * @example
+ * ```ts
+ * ktCollectionLiteral(['"read"', '"write"', '"admin"']);
+ * // Emits:
+ * // [
+ * //     "read",
+ * //     "write",
+ * //     "admin"
+ * // ]
+ * ```
+ */
 export const ktCollectionLiteral = Object.assign(createCollectionLiteral, {
     write: writeKtNodes,
 });

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

@@ -15,20 +15,85 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     delegateTarget?: Nullable<KtDelegateTarget>;
     delegateArguments?: Nullable<Nullable<KtArgument<TBuilder> | KtValue<TBuilder>>[]>;
 }>;
+/**
+ * The constructor that a constructor delegates to, written after `:` as `this(...)` or `super(...)`.
+ */
 export type KtDelegateTarget = 'this' | 'super';
+/**
+ * Represents a constructor of a Kotlin class. A secondary constructor is written in the class body, while a primary
+ * constructor is written in the class header.
+ *
+ * Written in this order as a secondary constructor: annotations, access modifier, the `constructor` keyword,
+ * parameters, the delegation, then the body. As a primary constructor, only the annotations, the access modifier,
+ * and the parameters are written in the header, and the containing class writes the body as an `init` block.
+ *
+ * @template TBuilder The type of the source builder the constructor is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktConstructor
+ */
 export declare class KtConstructor<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    /**
+     * The visibility modifier written before the `constructor` keyword, or `null` to omit it. For a primary
+     * constructor, a set modifier also makes the `constructor` keyword appear in the header, such as
+     * `Foo private constructor(x: Int)`.
+     */
     accessModifier: KtAccessModifier | null;
+    /**
+     * The annotations written above a secondary constructor, each on its own line. For a primary constructor they are
+     * written inline before the parameters, separated by spaces.
+     */
     annotations: KtAnnotation<TBuilder>[];
+    /**
+     * The parameters written in parentheses after the `constructor` keyword. A parameter with a `property` also
+     * declares a property of the class when it is part of a primary constructor. A secondary constructor always writes
+     * the parentheses, while a primary constructor omits them when there is nothing to write.
+     */
     parameters: (KtParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    /**
+     * The statements written inside the braces of a secondary constructor, or `null` for empty braces. A primary
+     * constructor does not write its body here, since the containing class writes it as an `init` block.
+     */
     body: AppendValue<TBuilder> | null;
+    /**
+     * The constructor that is called before the body, written as ` : this(...)` or ` : super(...)`, or `null` to omit
+     * the delegation. A primary constructor writes no delegation itself, so the containing class writes `super` after
+     * its base class instead.
+     */
     delegateTarget: KtDelegateTarget | null;
+    /**
+     * The arguments written in parentheses after the delegation target, such as `(42, true)`. Only written when
+     * `delegateTarget` is set, and an empty list writes `()`.
+     */
     delegateArguments: (KtArgument<TBuilder> | KtValue<TBuilder>)[];
+    /**
+     * Initializes a new instance of the KtConstructor class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
     writeAsPrimary(builder: TBuilder): void;
     protected onWriteAsPrimary(builder: TBuilder): void;
 }
 declare const createConstructor: <TBuilder extends SourceBuilder>(parameters?: Options<TBuilder>['parameters'], body?: Options<TBuilder>['body'], options?: Prettify<Omit<Options<TBuilder>, 'parameters' | 'body'>>) => KtConstructor<TBuilder>;
+/**
+ * Factory for creating constructor nodes. The `write` function writes one or more constructor nodes to a builder.
+ *
+ * @param parameters The parameters of the constructor. Pass nothing for a constructor without parameters.
+ * @param body The statements of the constructor body, or `null` for an empty body.
+ * @param options The settings of the constructor. See `KtConstructor` for the available properties.
+ * @example
+ * ```ts
+ * ktConstructor([ktParameter('x', 'Int')], 'println(x)', {
+ *   accessModifier: 'private',
+ *   delegateTarget: 'this',
+ *   delegateArguments: ['x'],
+ * });
+ * // Emits:
+ * // private constructor(x: Int) : this(x) {
+ * //     println(x)
+ * // }
+ * ```
+ */
 export declare const ktConstructor: typeof createConstructor & {
     write: typeof writeKtNodes;
 };

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

@@ -4,13 +4,56 @@ import { writeKtNodes } from '../utils/write-kt-node.js';
 import { ktAnnotation } from './annotation.js';
 import { ktArgument } from './argument.js';
 import { ktParameter } from './parameter.js';
+/**
+ * Represents a constructor of a Kotlin class. A secondary constructor is written in the class body, while a primary
+ * constructor is written in the class header.
+ *
+ * Written in this order as a secondary constructor: annotations, access modifier, the `constructor` keyword,
+ * parameters, the delegation, then the body. As a primary constructor, only the annotations, the access modifier,
+ * and the parameters are written in the header, and the containing class writes the body as an `init` block.
+ *
+ * @template TBuilder The type of the source builder the constructor is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktConstructor
+ */
 export class KtConstructor extends KtNode {
+    /**
+     * The visibility modifier written before the `constructor` keyword, or `null` to omit it. For a primary
+     * constructor, a set modifier also makes the `constructor` keyword appear in the header, such as
+     * `Foo private constructor(x: Int)`.
+     */
     accessModifier;
+    /**
+     * The annotations written above a secondary constructor, each on its own line. For a primary constructor they are
+     * written inline before the parameters, separated by spaces.
+     */
     annotations;
+    /**
+     * The parameters written in parentheses after the `constructor` keyword. A parameter with a `property` also
+     * declares a property of the class when it is part of a primary constructor. A secondary constructor always writes
+     * the parentheses, while a primary constructor omits them when there is nothing to write.
+     */
     parameters;
+    /**
+     * The statements written inside the braces of a secondary constructor, or `null` for empty braces. A primary
+     * constructor does not write its body here, since the containing class writes it as an `init` block.
+     */
     body;
+    /**
+     * The constructor that is called before the body, written as ` : this(...)` or ` : super(...)`, or `null` to omit
+     * the delegation. A primary constructor writes no delegation itself, so the containing class writes `super` after
+     * its base class instead.
+     */
     delegateTarget;
+    /**
+     * The arguments written in parentheses after the delegation target, such as `(42, true)`. Only written when
+     * `delegateTarget` is set, and an empty list writes `()`.
+     */
     delegateArguments;
+    /**
+     * Initializes a new instance of the KtConstructor class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.parameters = options.parameters?.filter(notNullish) ?? [];
@@ -71,6 +114,25 @@ export class KtConstructor extends KtNode {
     }
 }
 const createConstructor = (parameters, body, options) => new KtConstructor({ ...options, parameters: parameters ?? undefined, body });
+/**
+ * Factory for creating constructor nodes. The `write` function writes one or more constructor nodes to a builder.
+ *
+ * @param parameters The parameters of the constructor. Pass nothing for a constructor without parameters.
+ * @param body The statements of the constructor body, or `null` for an empty body.
+ * @param options The settings of the constructor. See `KtConstructor` for the available properties.
+ * @example
+ * ```ts
+ * ktConstructor([ktParameter('x', 'Int')], 'println(x)', {
+ *   accessModifier: 'private',
+ *   delegateTarget: 'this',
+ *   delegateArguments: ['x'],
+ * });
+ * // Emits:
+ * // private constructor(x: Int) : this(x) {
+ * //     println(x)
+ * // }
+ * ```
+ */
 export const ktConstructor = Object.assign(createConstructor, {
     write: writeKtNodes,
 });

package/dist/src/ast/nodes/doc-tag.d.ts

@@ -7,10 +7,34 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     args?: Nullable<Nullable<BasicAppendValue<TBuilder>>[]>;
     description?: Nullable<BasicAppendValue<TBuilder>>;
 }>;
+/**
+ * Represents a documentation tag, such as `@param x The value.` or `@see Foo`. Tags are written inside the KDoc comment
+ * of the declaration that they document.
+ *
+ * Written in this order: the `@` sign and the tag name, the arguments, then the description. Each part after the tag
+ * name is preceded by a space.
+ *
+ * @template TBuilder The type of the source builder the tag is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktDocTag
+ */
 export declare class KtDocTag<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    /**
+     * The name of the tag, written after the `@` sign, such as `param` or `see`.
+     */
     tag: string;
+    /**
+     * The arguments written after the tag name, each preceded by a space. For `@param x`, the name `x` is an argument.
+     */
     args: BasicAppendValue<TBuilder>[];
+    /**
+     * The text written at the end of the tag, preceded by a space, or `null` to omit it.
+     */
     description: BasicAppendValue<TBuilder> | null;
+    /**
+     * Initializes a new instance of the KtDocTag class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
@@ -29,6 +53,23 @@ type _KtDocTagArgsMap<TBuilder extends SourceBuilder> = {
 type _KtDocTagArgs<TTagName extends StringSuggestions<keyof _KtDocTagArgsMap<TBuilder>>, TBuilder extends SourceBuilder> = TTagName extends keyof _KtDocTagArgsMap<TBuilder> ? _KtDocTagArgsMap<TBuilder>[TTagName] extends (...args: any[]) => any ? ParametersWithOverloads<_KtDocTagArgsMap<TBuilder>[TTagName]> : never : [options?: _KtDocTagOpt<TBuilder>];
 declare function createDocTag<TTagName extends StringSuggestions<keyof _KtDocTagArgsMap<TBuilder>>, TBuilder extends SourceBuilder>(tag: TTagName, ...args: _KtDocTagArgs<TTagName, TBuilder>): KtDocTag<TBuilder>;
 declare const writeDocTags: <TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>) => void;
+/**
+ * Factory for creating doc tag nodes. The `write` function writes one or more tags to a builder, one per line.
+ *
+ * The arguments depend on the tag. `param` and `property` take a name and a description, `throws` and `exception` take
+ * a class and a description, and `see` and `sample` take an identifier. `suppress` takes no arguments, and tags such as
+ * `return` take only a description. Other tags take their arguments as given. A settings object can be passed last.
+ *
+ * @param tag The name of the tag, written after the `@` sign.
+ * @param args The arguments of the tag, followed by an optional settings object. See the description for the arguments
+ * of each tag.
+ * @example
+ * ```ts
+ * ktDocTag('param', 'id', 'The identifier of the pet.');
+ * // Emits:
+ * // @param id The identifier of the pet.
+ * ```
+ */
 export declare const ktDocTag: typeof createDocTag & {
     write: typeof writeDocTags;
 };

package/dist/src/ast/nodes/doc-tag.js

@@ -2,10 +2,34 @@ import { basicAppendValueGroup, notNullish, } from '@goast/core';
 import { isKotlinAppendValue } from '../../file-builder.js';
 import { KtNode } from '../node.js';
 import { writeKtNodes } from '../utils/write-kt-node.js';
+/**
+ * Represents a documentation tag, such as `@param x The value.` or `@see Foo`. Tags are written inside the KDoc comment
+ * of the declaration that they document.
+ *
+ * Written in this order: the `@` sign and the tag name, the arguments, then the description. Each part after the tag
+ * name is preceded by a space.
+ *
+ * @template TBuilder The type of the source builder the tag is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktDocTag
+ */
 export class KtDocTag extends KtNode {
+    /**
+     * The name of the tag, written after the `@` sign, such as `param` or `see`.
+     */
     tag;
+    /**
+     * The arguments written after the tag name, each preceded by a space. For `@param x`, the name `x` is an argument.
+     */
     args;
+    /**
+     * The text written at the end of the tag, preceded by a space, or `null` to omit it.
+     */
     description;
+    /**
+     * Initializes a new instance of the KtDocTag class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.tag = options.tag;
@@ -53,6 +77,23 @@ function createDocTag(tag, ...args) {
 const writeDocTags = (builder, nodes) => {
     writeKtNodes(builder, nodes, { separator: '\n' });
 };
+/**
+ * Factory for creating doc tag nodes. The `write` function writes one or more tags to a builder, one per line.
+ *
+ * The arguments depend on the tag. `param` and `property` take a name and a description, `throws` and `exception` take
+ * a class and a description, and `see` and `sample` take an identifier. `suppress` takes no arguments, and tags such as
+ * `return` take only a description. Other tags take their arguments as given. A settings object can be passed last.
+ *
+ * @param tag The name of the tag, written after the `@` sign.
+ * @param args The arguments of the tag, followed by an optional settings object. See the description for the arguments
+ * of each tag.
+ * @example
+ * ```ts
+ * ktDocTag('param', 'id', 'The identifier of the pet.');
+ * // Emits:
+ * // @param id The identifier of the pet.
+ * ```
+ */
 export const ktDocTag = Object.assign(createDocTag, {
     write: writeDocTags,
 });

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

@@ -9,9 +9,31 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     description?: Nullable<BasicAppendValue<TBuilder>>;
     tags?: Nullable<Nullable<KtDocTag<TBuilder>>[]>;
 }>;
+/**
+ * Represents a KDoc comment block that is written above a declaration. The block is omitted when it has neither a
+ * description nor tags.
+ *
+ * Written in this order: the description, a blank line, then the tags. Every line of the block is prefixed with an
+ * asterisk.
+ *
+ * @template TBuilder The type of the source builder the doc comment is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktDoc
+ */
 export declare class KtDoc<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    /**
+     * The text written at the start of the block, or `null` to write only the tags.
+     */
     description: BasicAppendValue<TBuilder> | null;
+    /**
+     * The tags written after the description, one per line, such as `@param` or `@see`. Tags that `ktDoc.get` generates
+     * from the descriptions of generic and value parameters are placed before these tags.
+     */
     tags: KtDocTag<TBuilder>[];
+    /**
+     * Initializes a new instance of the KtDoc class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
@@ -20,6 +42,28 @@ declare function getDoc<TBuilder extends SourceBuilder>(baseDoc: KtDoc<TBuilder>
     parameters?: Nullable<Nullable<KtParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
     generics?: Nullable<Nullable<KtGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
 }): KtDoc<TBuilder> | null;
+/**
+ * Factory for creating doc comment nodes. The `write` function writes one or more doc comments to a builder. The `get`
+ * function returns the doc comment of a declaration with the descriptions of its generic and parameters added as tags,
+ * or `null` when there is nothing to write.
+ *
+ * @param description The text at the start of the block, or `null` for none.
+ * @param tags The tags written after the description.
+ * @param options The settings of the doc comment. See `KtDoc` for the available properties.
+ * @example
+ * ```ts
+ * ktDoc('Returns the pet with the given id.', [
+ *   ktDocTag('param', 'id', 'The identifier of the pet.'),
+ *   ktDocTag('return', 'The pet, or null.'),
+ * ]);
+ * // Emits a KDoc block with one line per entry, which is closed after the last tag:
+ * // /**
+ * // * Returns the pet with the given id.
+ * // *
+ * // * @param id The identifier of the pet.
+ * // * @return The pet, or null.
+ * ```
+ */
 export declare const ktDoc: typeof createDoc & {
     write: typeof writeKtNodes;
     get: typeof getDoc;

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

@@ -4,9 +4,31 @@ import { writeKtNodes } from '../utils/write-kt-node.js';
 import { ktDocTag } from './doc-tag.js';
 import { KtGenericParameter } from './generic-parameter.js';
 import { KtParameter } from './parameter.js';
+/**
+ * Represents a KDoc comment block that is written above a declaration. The block is omitted when it has neither a
+ * description nor tags.
+ *
+ * Written in this order: the description, a blank line, then the tags. Every line of the block is prefixed with an
+ * asterisk.
+ *
+ * @template TBuilder The type of the source builder the doc comment is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktDoc
+ */
 export class KtDoc extends KtNode {
+    /**
+     * The text written at the start of the block, or `null` to write only the tags.
+     */
     description;
+    /**
+     * The tags written after the description, one per line, such as `@param` or `@see`. Tags that `ktDoc.get` generates
+     * from the descriptions of generic and value parameters are placed before these tags.
+     */
     tags;
+    /**
+     * Initializes a new instance of the KtDoc class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.description = options.description ?? null;
@@ -51,6 +73,28 @@ function getDoc(baseDoc, options) {
     doc.tags.splice(0, 0, ...genericTags, ...paramTags, ...propertyTags);
     return doc;
 }
+/**
+ * Factory for creating doc comment nodes. The `write` function writes one or more doc comments to a builder. The `get`
+ * function returns the doc comment of a declaration with the descriptions of its generic and parameters added as tags,
+ * or `null` when there is nothing to write.
+ *
+ * @param description The text at the start of the block, or `null` for none.
+ * @param tags The tags written after the description.
+ * @param options The settings of the doc comment. See `KtDoc` for the available properties.
+ * @example
+ * ```ts
+ * ktDoc('Returns the pet with the given id.', [
+ *   ktDocTag('param', 'id', 'The identifier of the pet.'),
+ *   ktDocTag('return', 'The pet, or null.'),
+ * ]);
+ * // Emits a KDoc block with one line per entry, which is closed after the last tag:
+ * // /**
+ * // * Returns the pet with the given id.
+ * // *
+ * // * @param id The identifier of the pet.
+ * // * @return The pet, or null.
+ * ```
+ */
 export const ktDoc = Object.assign(createDoc, {
     write: writeKtNodes,
     get: getDoc,

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

@@ -14,17 +14,67 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     arguments?: Nullable<Nullable<KtArgument<TBuilder> | AppendValue<TBuilder>>[]>;
     members?: Nullable<Nullable<KtEnumValueMember<TBuilder>>[]>;
 }>;
+/**
+ * The nodes that can be written in the body of an enum value. Other append values are written as-is.
+ */
 export type KtEnumValueMember<TBuilder extends SourceBuilder> = KtParameter<TBuilder> | KtFunction<TBuilder> | AppendValue<TBuilder>;
+/**
+ * Represents a single value, also called an entry, of a Kotlin enum class, such as `RED(0xFF0000)`.
+ *
+ * Written in this order: the doc comment, annotations, the name, the arguments in parentheses, then the members in
+ * braces.
+ *
+ * @template TBuilder The type of the source builder the enum value is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktEnumValue
+ */
 export declare class KtEnumValue<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    /**
+     * The name of the entry, written verbatim.
+     */
     name: string;
+    /**
+     * The KDoc comment written above the entry, or `null` to omit it.
+     */
     doc: KtDoc<TBuilder> | null;
+    /**
+     * The annotations written above the entry, each on its own line.
+     */
     annotations: KtAnnotation<TBuilder>[];
+    /**
+     * The arguments written in parentheses after the name, such as `(0, 1)`. They are passed to the primary
+     * constructor of the enum. Nothing is written when the list is empty.
+     */
     arguments: (KtArgument<TBuilder> | AppendValue<TBuilder>)[];
+    /**
+     * The members written in braces after the entry, such as functions that only this entry overrides. The braces are
+     * omitted when there are no members.
+     */
     members: KtEnumValueMember<TBuilder>[];
+    /**
+     * Initializes a new instance of the KtEnumValue class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createEnumValue: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => KtEnumValue<TBuilder>;
+/**
+ * Factory for creating enum value nodes. The `write` function writes a list of enum values, separated by commas.
+ * The list is written with one value per line when there are more than four values, or when any value has arguments,
+ * a doc comment, annotations or members. Blank lines separate the values when any value has a doc comment, annotations
+ * or members.
+ *
+ * @param name The name of the entry, written verbatim.
+ * @param options The settings of the entry. See `KtEnumValue` for the available properties.
+ * @example
+ * ```ts
+ * ktEnumValue('ADMIN', { annotations: [ktAnnotation('Deprecated')], arguments: ['"admin"'] });
+ * // Emits:
+ * // @Deprecated
+ * // ADMIN("admin")
+ * ```
+ */
 export declare const ktEnumValue: typeof createEnumValue & {
     write: typeof writeKtEnumValues;
 };

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

@@ -4,12 +4,43 @@ import { writeKtEnumValues } from '../utils/write-kt-enum-values.js';
 import { writeKtMembers } from '../utils/write-kt-members.js';
 import { ktAnnotation } from './annotation.js';
 import { ktArgument } from './argument.js';
+/**
+ * Represents a single value, also called an entry, of a Kotlin enum class, such as `RED(0xFF0000)`.
+ *
+ * Written in this order: the doc comment, annotations, the name, the arguments in parentheses, then the members in
+ * braces.
+ *
+ * @template TBuilder The type of the source builder the enum value is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktEnumValue
+ */
 export class KtEnumValue extends KtNode {
+    /**
+     * The name of the entry, written verbatim.
+     */
     name;
+    /**
+     * The KDoc comment written above the entry, or `null` to omit it.
+     */
     doc;
+    /**
+     * The annotations written above the entry, each on its own line.
+     */
     annotations;
+    /**
+     * The arguments written in parentheses after the name, such as `(0, 1)`. They are passed to the primary
+     * constructor of the enum. Nothing is written when the list is empty.
+     */
     arguments;
+    /**
+     * The members written in braces after the entry, such as functions that only this entry overrides. The braces are
+     * omitted when there are no members.
+     */
     members;
+    /**
+     * Initializes a new instance of the KtEnumValue class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.name = options.name;
@@ -44,6 +75,22 @@ export class KtEnumValue extends KtNode {
     }
 }
 const createEnumValue = (name, options) => new KtEnumValue({ ...options, name });
+/**
+ * Factory for creating enum value nodes. The `write` function writes a list of enum values, separated by commas.
+ * The list is written with one value per line when there are more than four values, or when any value has arguments,
+ * a doc comment, annotations or members. Blank lines separate the values when any value has a doc comment, annotations
+ * or members.
+ *
+ * @param name The name of the entry, written verbatim.
+ * @param options The settings of the entry. See `KtEnumValue` for the available properties.
+ * @example
+ * ```ts
+ * ktEnumValue('ADMIN', { annotations: [ktAnnotation('Deprecated')], arguments: ['"admin"'] });
+ * // Emits:
+ * // @Deprecated
+ * // ADMIN("admin")
+ * ```
+ */
 export const ktEnumValue = Object.assign(createEnumValue, {
     write: writeKtEnumValues,
 });