@goast/kotlin 0.7.0 → 0.7.1

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

@@ -22,20 +22,93 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     members?: Nullable<Nullable<KtInterfaceMember<TBuilder>>[]>;
     companionObject?: Nullable<KtObject<TBuilder>>;
 }>;
+/**
+ * A member that can be written in the body of an interface: an enum, an interface, a property, a function, a class,
+ * or any appended value.
+ * @template TBuilder The type of the builder that the member is written to.
+ */
 export type KtInterfaceMember<TBuilder extends SourceBuilder> = KtEnum<TBuilder> | KtInterface<TBuilder> | KtProperty<TBuilder> | KtFunction<TBuilder> | KtClass<TBuilder> | AppendValue<TBuilder>;
+/**
+ * Represents a Kotlin interface declaration, such as `private interface Foo<T> : Bar, Baz { ... }`.
+ *
+ * Written in this order: the KDoc comment, the annotations, the access modifier, the `interface` keyword, the name, the
+ * generic parameters, the super-interfaces, then the body. The body is only written when there are members or a
+ * companion object. The descriptions of generic parameters are merged into the KDoc comment as `@param` tags.
+ *
+ * @template TBuilder The type of the source builder the interface is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktInterface
+ */
 export declare class KtInterface<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    /**
+     * The KDoc comment written above the interface, or `null` to omit it. The descriptions of the generic parameters are
+     * added to it as `@param` tags.
+     */
     doc: KtDoc<TBuilder> | null;
+    /**
+     * The annotations written above the interface, each on a line of its own.
+     */
     annotations: KtAnnotation<TBuilder>[];
+    /**
+     * The visibility written before the `interface` keyword, such as `private`. `null` writes no visibility keyword.
+     */
     accessModifier: KtAccessModifier | null;
+    /**
+     * The interface name written after the `interface` keyword.
+     */
     name: string;
+    /**
+     * The generic parameters written in angle brackets after the name, such as `<T, U>`. Plain strings are written as
+     * they are. Described parameters also add a `@param` tag to the KDoc comment.
+     */
     generics: (KtGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    /**
+     * The super-interfaces written after ` : ` as a comma-separated list, such as `Bar, Baz`. The clause is omitted when
+     * the list is empty.
+     */
     extends: KtType<TBuilder>[];
+    /**
+     * The members written in the body, in the given order. Properties without a doc comment or annotations are written
+     * without blank lines between them, other members are set off by blank lines.
+     */
     members: KtInterfaceMember<TBuilder>[];
+    /**
+     * The companion object written first in the body, with the `companion` modifier. Setting it writes the body even when
+     * there are no other members.
+     */
     companionObject: KtObject<TBuilder> | null;
+    /**
+     * Initializes a new instance of the KtInterface class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createInterface: <TBuilder extends SourceBuilder>(name: KtInterface<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => KtInterface<TBuilder>;
+/**
+ * Factory for creating interface nodes. The `write` function writes one or more interface nodes to a builder.
+ *
+ * @param name The name of the interface.
+ * @param options The settings of the interface. See `KtInterface` for the available properties.
+ * @example
+ * ```ts
+ * ktInterface('Foo', {
+ *   annotations: [ktAnnotation('Deprecated')],
+ *   accessModifier: 'private',
+ *   generics: [ktGenericParameter('T')],
+ *   extends: ['Bar', 'Baz'],
+ *   members: [ktProperty('x', { type: 'Int' })],
+ *   companionObject: ktObject(),
+ * });
+ * // Emits:
+ * // @Deprecated
+ * // private interface Foo<T> : Bar, Baz {
+ * //     companion object {}
+ * //
+ * //     val x: Int
+ * // }
+ * ```
+ */
 export declare const ktInterface: typeof createInterface & {
     write: typeof writeKtNodes;
 };

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

@@ -5,15 +5,59 @@ import { writeKtNodes } from '../utils/write-kt-node.js';
 import { ktAnnotation } from './annotation.js';
 import { ktDoc } from './doc.js';
 import { ktGenericParameter } from './generic-parameter.js';
+/**
+ * Represents a Kotlin interface declaration, such as `private interface Foo<T> : Bar, Baz { ... }`.
+ *
+ * Written in this order: the KDoc comment, the annotations, the access modifier, the `interface` keyword, the name, the
+ * generic parameters, the super-interfaces, then the body. The body is only written when there are members or a
+ * companion object. The descriptions of generic parameters are merged into the KDoc comment as `@param` tags.
+ *
+ * @template TBuilder The type of the source builder the interface is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktInterface
+ */
 export class KtInterface extends KtNode {
+    /**
+     * The KDoc comment written above the interface, or `null` to omit it. The descriptions of the generic parameters are
+     * added to it as `@param` tags.
+     */
     doc;
+    /**
+     * The annotations written above the interface, each on a line of its own.
+     */
     annotations;
+    /**
+     * The visibility written before the `interface` keyword, such as `private`. `null` writes no visibility keyword.
+     */
     accessModifier;
+    /**
+     * The interface name written after the `interface` keyword.
+     */
     name;
+    /**
+     * The generic parameters written in angle brackets after the name, such as `<T, U>`. Plain strings are written as
+     * they are. Described parameters also add a `@param` tag to the KDoc comment.
+     */
     generics;
+    /**
+     * The super-interfaces written after ` : ` as a comma-separated list, such as `Bar, Baz`. The clause is omitted when
+     * the list is empty.
+     */
     extends;
+    /**
+     * The members written in the body, in the given order. Properties without a doc comment or annotations are written
+     * without blank lines between them, other members are set off by blank lines.
+     */
     members;
+    /**
+     * The companion object written first in the body, with the `companion` modifier. Setting it writes the body even when
+     * there are no other members.
+     */
     companionObject;
+    /**
+     * Initializes a new instance of the KtInterface class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.doc = options.doc ?? null;
@@ -65,6 +109,30 @@ export class KtInterface extends KtNode {
     }
 }
 const createInterface = (name, options) => new KtInterface({ ...options, name });
+/**
+ * Factory for creating interface nodes. The `write` function writes one or more interface nodes to a builder.
+ *
+ * @param name The name of the interface.
+ * @param options The settings of the interface. See `KtInterface` for the available properties.
+ * @example
+ * ```ts
+ * ktInterface('Foo', {
+ *   annotations: [ktAnnotation('Deprecated')],
+ *   accessModifier: 'private',
+ *   generics: [ktGenericParameter('T')],
+ *   extends: ['Bar', 'Baz'],
+ *   members: [ktProperty('x', { type: 'Int' })],
+ *   companionObject: ktObject(),
+ * });
+ * // Emits:
+ * // @Deprecated
+ * // private interface Foo<T> : Bar, Baz {
+ * //     companion object {}
+ * //
+ * //     val x: Int
+ * // }
+ * ```
+ */
 export const ktInterface = Object.assign(createInterface, {
     write: writeKtNodes,
 });

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

@@ -9,15 +9,57 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     returnType: KtType<TBuilder>;
     suspend?: boolean;
 }>;
+/**
+ * Represents a Kotlin function type, such as `(Int, String) -> Boolean`.
+ *
+ * Written in this order: the `suspend` modifier, the receiver type followed by a dot, the parameter types in
+ * parentheses, the arrow, then the return type.
+ *
+ * @template TBuilder The type of the source builder the lambda type is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktLambdaType
+ */
 export declare class KtLambdaType<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    /**
+     * The receiver type written before the parameters, followed by a dot, such as `Foo.(Int) -> Unit`. `null` writes a
+     * function type without a receiver.
+     */
     extensionFor: KtType<TBuilder> | null;
+    /**
+     * The parameter types written in parentheses, separated by commas. An empty list writes `()`. With more than two
+     * types, each type is written on a line of its own.
+     */
     parameters: KtType<TBuilder>[];
+    /**
+     * The return type written after the arrow, such as `Unit` in `() -> Unit`.
+     */
     returnType: KtType<TBuilder>;
+    /**
+     * Whether the type is written with the `suspend` modifier in front, such as `suspend () -> Unit`.
+     * @default false
+     */
     suspend: boolean;
+    /**
+     * Initializes a new instance of the KtLambdaType class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createLambdaType: <TBuilder extends SourceBuilder>(parameters: Options<TBuilder>['parameters'], returnType: Options<TBuilder>['returnType'], options?: Omit<Options<TBuilder>, 'parameters' | 'returnType'>) => KtLambdaType<TBuilder>;
+/**
+ * Factory for creating lambda type nodes. The `write` function writes one or more lambda type nodes to a builder.
+ *
+ * @param parameters The types of the parameters, or `null` for none. An empty list writes `()`.
+ * @param returnType The return type of the lambda type.
+ * @param options The settings of the lambda type. See `KtLambdaType` for the available properties.
+ * @example
+ * ```ts
+ * ktLambdaType(['Int'], 'Unit', { extensionFor: 'Foo' });
+ * // Emits:
+ * // Foo.(Int) -> Unit
+ * ```
+ */
 export declare const ktLambdaType: typeof createLambdaType & {
     write: typeof writeKtNodes;
 };

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

@@ -2,11 +2,40 @@ import { notNullish } from '@goast/core';
 import { KtNode } from '../node.js';
 import { writeKtNode, writeKtNodes } from '../utils/write-kt-node.js';
 import { ktParameter } from './parameter.js';
+/**
+ * Represents a Kotlin function type, such as `(Int, String) -> Boolean`.
+ *
+ * Written in this order: the `suspend` modifier, the receiver type followed by a dot, the parameter types in
+ * parentheses, the arrow, then the return type.
+ *
+ * @template TBuilder The type of the source builder the lambda type is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktLambdaType
+ */
 export class KtLambdaType extends KtNode {
+    /**
+     * The receiver type written before the parameters, followed by a dot, such as `Foo.(Int) -> Unit`. `null` writes a
+     * function type without a receiver.
+     */
     extensionFor;
+    /**
+     * The parameter types written in parentheses, separated by commas. An empty list writes `()`. With more than two
+     * types, each type is written on a line of its own.
+     */
     parameters;
+    /**
+     * The return type written after the arrow, such as `Unit` in `() -> Unit`.
+     */
     returnType;
+    /**
+     * Whether the type is written with the `suspend` modifier in front, such as `suspend () -> Unit`.
+     * @default false
+     */
     suspend;
+    /**
+     * Initializes a new instance of the KtLambdaType class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.extensionFor = options.extensionFor ?? null;
@@ -39,6 +68,19 @@ export class KtLambdaType extends KtNode {
     }
 }
 const createLambdaType = (parameters, returnType, options) => new KtLambdaType({ ...options, parameters, returnType });
+/**
+ * Factory for creating lambda type nodes. The `write` function writes one or more lambda type nodes to a builder.
+ *
+ * @param parameters The types of the parameters, or `null` for none. An empty list writes `()`.
+ * @param returnType The return type of the lambda type.
+ * @param options The settings of the lambda type. See `KtLambdaType` for the available properties.
+ * @example
+ * ```ts
+ * ktLambdaType(['Int'], 'Unit', { extensionFor: 'Foo' });
+ * // Emits:
+ * // Foo.(Int) -> Unit
+ * ```
+ */
 export const ktLambdaType = Object.assign(createLambdaType, {
     write: writeKtNodes,
 });

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

@@ -7,14 +7,55 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     body?: Nullable<AppendValue<TBuilder>>;
     singleline?: boolean;
 }>;
+/**
+ * Represents a Kotlin lambda expression, such as `{ a, b -> a + b }`.
+ *
+ * Written in this order: the opening brace, the parameter names followed by an arrow, the body, then the closing brace.
+ * A lambda without a body is always written on one line.
+ *
+ * @template TBuilder The type of the source builder the lambda is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktLambda
+ */
 export declare class KtLambda<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    /**
+     * The parameter names written after the opening brace, separated by commas and followed by `->`. Without any names,
+     * the arrow is omitted and the body follows the opening brace directly.
+     */
     arguments: BasicAppendValue<TBuilder>[];
+    /**
+     * The statements of the lambda. `null` writes an empty lambda on one line, such as `{ }`.
+     */
     body: AppendValue<TBuilder> | null;
+    /**
+     * Whether the body is written on the same line as the braces, such as `{ a, b -> a + b }`. Otherwise the body is
+     * written on an indented line of its own, between the arrow and the closing brace.
+     * @default false
+     */
     singleline: boolean;
+    /**
+     * Initializes a new instance of the KtLambda class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createLambda: <TBuilder extends SourceBuilder>(args: Options<TBuilder>['arguments'], body: Options<TBuilder>['body'], options?: Omit<Options<TBuilder>, 'arguments' | 'body'>) => KtLambda<TBuilder>;
+/**
+ * Factory for creating lambda nodes. The `write` function writes one or more lambda nodes to a builder.
+ *
+ * @param args The parameter names of the lambda, or `null` for none.
+ * @param body The statements of the lambda, or `null` for an empty lambda.
+ * @param options The settings of the lambda. See `KtLambda` for the available properties.
+ * @example
+ * ```ts
+ * ktLambda(['a'], 'println(a)');
+ * // Emits:
+ * // { a ->
+ * //     println(a)
+ * // }
+ * ```
+ */
 export declare const ktLambda: typeof createLambda & {
     write: typeof writeKtNodes;
 };

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

@@ -1,10 +1,36 @@
 import { notNullish, } from '@goast/core';
 import { KtNode } from '../node.js';
 import { writeKtNodes } from '../utils/write-kt-node.js';
+/**
+ * Represents a Kotlin lambda expression, such as `{ a, b -> a + b }`.
+ *
+ * Written in this order: the opening brace, the parameter names followed by an arrow, the body, then the closing brace.
+ * A lambda without a body is always written on one line.
+ *
+ * @template TBuilder The type of the source builder the lambda is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktLambda
+ */
 export class KtLambda extends KtNode {
+    /**
+     * The parameter names written after the opening brace, separated by commas and followed by `->`. Without any names,
+     * the arrow is omitted and the body follows the opening brace directly.
+     */
     arguments;
+    /**
+     * The statements of the lambda. `null` writes an empty lambda on one line, such as `{ }`.
+     */
     body;
+    /**
+     * Whether the body is written on the same line as the braces, such as `{ a, b -> a + b }`. Otherwise the body is
+     * written on an indented line of its own, between the arrow and the closing brace.
+     * @default false
+     */
     singleline;
+    /**
+     * Initializes a new instance of the KtLambda class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.arguments = options.arguments?.filter(notNullish) ?? [];
@@ -34,6 +60,21 @@ export class KtLambda extends KtNode {
     }
 }
 const createLambda = (args, body, options) => new KtLambda({ ...options, arguments: args, body });
+/**
+ * Factory for creating lambda nodes. The `write` function writes one or more lambda nodes to a builder.
+ *
+ * @param args The parameter names of the lambda, or `null` for none.
+ * @param body The statements of the lambda, or `null` for an empty lambda.
+ * @param options The settings of the lambda. See `KtLambda` for the available properties.
+ * @example
+ * ```ts
+ * ktLambda(['a'], 'println(a)');
+ * // Emits:
+ * // { a ->
+ * //     println(a)
+ * // }
+ * ```
+ */
 export const ktLambda = Object.assign(createLambda, {
     write: writeKtNodes,
 });

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

@@ -16,19 +16,85 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     members?: Nullable<Nullable<KtObjectMember<TBuilder>>[]>;
     companion?: Nullable<boolean>;
 }>;
+/**
+ * A member that can be written in the body of an object: an init block, a property, a function, or any appended value.
+ * @template TBuilder The type of the builder that the member is written to.
+ */
 export type KtObjectMember<TBuilder extends SourceBuilder> = KtInitBlock<TBuilder> | KtProperty<TBuilder> | KtFunction<TBuilder> | BasicAppendValue<TBuilder>;
+/**
+ * Represents a Kotlin `object` declaration or object expression, such as `object Foo : Bar(1, 2), Baz { ... }`.
+ *
+ * Written in this order: the `data` and `companion` modifiers, the `object` keyword, the name, the supertypes with the
+ * base class constructor call, then the body. A named object is followed by a line break. An anonymous object, such as
+ * `object : Bar() {}`, is not, so it can be written inside another expression.
+ *
+ * @template TBuilder The type of the source builder the object is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktObject
+ */
 export declare class KtObject<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    /**
+     * Whether the object is written with the `data` modifier, such as `data object Foo`.
+     * @default false
+     */
     data: boolean;
+    /**
+     * The object name written after the `object` keyword. `null` writes an anonymous object, such as `object : Bar() {}`.
+     */
     name: string | null;
+    /**
+     * The base class written after ` : `, followed by its constructor call in parentheses, such as `Bar()`. The call is
+     * always written, even without arguments. `null` writes no base class.
+     */
     class: KtType<TBuilder> | null;
+    /**
+     * The arguments written inside the parentheses of the base class constructor call, separated by commas. Only written
+     * when `class` is set.
+     */
     classArguments: (KtArgument<TBuilder> | KtValue<TBuilder>)[];
+    /**
+     * The interfaces written after the base class, separated by commas, such as `Bar, Baz`. Without a base class, they
+     * are written directly after ` : `. The clause is omitted when the list is empty.
+     */
     implements: KtType<TBuilder>[];
+    /**
+     * The members written in the body, in the given order. Properties without a doc comment or annotations and plain
+     * strings are written without blank lines between them, other members are set off by blank lines. An empty list
+     * writes `{}` on one line.
+     */
     members: KtObjectMember<TBuilder>[];
+    /**
+     * Whether the object is written with the `companion` modifier, such as `companion object`.
+     * @default false
+     */
     companion: boolean;
+    /**
+     * Initializes a new instance of the KtObject class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createObject: <TBuilder extends SourceBuilder>(options?: Options<TBuilder>) => KtObject<TBuilder>;
+/**
+ * Factory for creating object nodes. The `write` function writes one or more object nodes to a builder.
+ *
+ * @param options The settings of the object. See `KtObject` for the available properties.
+ * @example
+ * ```ts
+ * ktObject({
+ *   name: 'Foo',
+ *   class: 'Bar',
+ *   classArguments: ['1', '2'],
+ *   implements: ['Baz'],
+ *   members: [ktProperty('x', { type: 'Int', default: '1' })],
+ * });
+ * // Emits:
+ * // object Foo : Bar(1, 2), Baz {
+ * //     val x: Int = 1
+ * // }
+ * ```
+ */
 export declare const ktObject: typeof createObject & {
     write: typeof writeKtNodes;
 };

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

@@ -3,14 +3,57 @@ import { KtNode } from '../node.js';
 import { writeKtMembers } from '../utils/write-kt-members.js';
 import { writeKtNode, writeKtNodes } from '../utils/write-kt-node.js';
 import { ktArgument } from './argument.js';
+/**
+ * Represents a Kotlin `object` declaration or object expression, such as `object Foo : Bar(1, 2), Baz { ... }`.
+ *
+ * Written in this order: the `data` and `companion` modifiers, the `object` keyword, the name, the supertypes with the
+ * base class constructor call, then the body. A named object is followed by a line break. An anonymous object, such as
+ * `object : Bar() {}`, is not, so it can be written inside another expression.
+ *
+ * @template TBuilder The type of the source builder the object is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktObject
+ */
 export class KtObject extends KtNode {
+    /**
+     * Whether the object is written with the `data` modifier, such as `data object Foo`.
+     * @default false
+     */
     data;
+    /**
+     * The object name written after the `object` keyword. `null` writes an anonymous object, such as `object : Bar() {}`.
+     */
     name;
+    /**
+     * The base class written after ` : `, followed by its constructor call in parentheses, such as `Bar()`. The call is
+     * always written, even without arguments. `null` writes no base class.
+     */
     class;
+    /**
+     * The arguments written inside the parentheses of the base class constructor call, separated by commas. Only written
+     * when `class` is set.
+     */
     classArguments;
+    /**
+     * The interfaces written after the base class, separated by commas, such as `Bar, Baz`. Without a base class, they
+     * are written directly after ` : `. The clause is omitted when the list is empty.
+     */
     implements;
+    /**
+     * The members written in the body, in the given order. Properties without a doc comment or annotations and plain
+     * strings are written without blank lines between them, other members are set off by blank lines. An empty list
+     * writes `{}` on one line.
+     */
     members;
+    /**
+     * Whether the object is written with the `companion` modifier, such as `companion object`.
+     * @default false
+     */
     companion;
+    /**
+     * Initializes a new instance of the KtObject class.
+     * @param options The options to use for this instance.
+     */
     constructor(options) {
         super(options);
         this.data = options.data ?? false;
@@ -55,6 +98,25 @@ export class KtObject extends KtNode {
     }
 }
 const createObject = (options) => new KtObject(options ?? {});
+/**
+ * Factory for creating object nodes. The `write` function writes one or more object nodes to a builder.
+ *
+ * @param options The settings of the object. See `KtObject` for the available properties.
+ * @example
+ * ```ts
+ * ktObject({
+ *   name: 'Foo',
+ *   class: 'Bar',
+ *   classArguments: ['1', '2'],
+ *   implements: ['Baz'],
+ *   members: [ktProperty('x', { type: 'Int', default: '1' })],
+ * });
+ * // Emits:
+ * // object Foo : Bar(1, 2), Baz {
+ * //     val x: Int = 1
+ * // }
+ * ```
+ */
 export const ktObject = Object.assign(createObject, {
     write: writeKtNodes,
 });

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

@@ -17,22 +17,90 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     propertyDescription?: Nullable<BasicAppendValue<TBuilder>>;
     override?: Nullable<boolean>;
 }>;
+/**
+ * Represents a Kotlin parameter of a function or a class constructor. A class constructor parameter can also declare
+ * a property.
+ *
+ * Written in this order: the annotations, each on a line of its own, the modifiers, `val` or `var` for a property, the
+ * name, the type after a colon, then the default value after an equals sign.
+ *
+ * @template TBuilder The type of the source builder the parameter is written to.
+ * @template TInjects Additional names of custom injection points (`before*` and `after*`) accepted by this node.
+ * @see ktParameter
+ */
 export declare class KtParameter<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    /**
+     * The name of the parameter, written before the colon.
+     */
     name: string;
+    /**
+     * The type of the parameter, written after the colon, such as `Int` in `x: Int`.
+     */
     type: KtType<TBuilder>;
+    /**
+     * The annotations written above the parameter, each on a line of its own. A parameter list with annotations is
+     * written with one parameter per line.
+     */
     annotations: KtAnnotation<TBuilder>[];
+    /**
+     * The default value written after ` = `, such as `42` in `x: Int = 42`. `null` writes no default value.
+     */
     default: KtValue<TBuilder> | null;
+    /**
+     * Whether the parameter is written with the `vararg` modifier, such as `vararg x: Int`. The modifier is written for a
+     * plain parameter as well as for a class property.
+     * @default false
+     */
     vararg: boolean;
+    /**
+     * The description of the parameter. It is not written inline. It becomes a `@param` tag in the KDoc comment of the
+     * function or class whose parameter list contains the parameter.
+     */
     description: BasicAppendValue<TBuilder> | null;
+    /**
+     * The visibility written before `val` or `var`, such as `private var x: Int`. Only written when `property` is set.
+     */
     accessModifier: KtAccessModifier | null;
+    /**
+     * Whether the parameter declares a property: `readonly` writes `val` and `mutable` writes `var`. `null` writes a
+     * plain parameter without either keyword.
+     */
     property: 'readonly' | 'mutable' | null;
+    /**
+     * The description of the property. It is not written inline. It becomes a `@property` tag in the KDoc comment of the
+     * class that declares the parameter, when `property` is set.
+     */
     propertyDescription: BasicAppendValue<TBuilder> | null;
+    /**
+     * Whether the property is written with the `override` modifier, such as `override var x: Int`. Only written when
+     * `property` is set.
+     * @default false
+     */
     override: boolean;
+    /**
+     * Initializes a new instance of the KtParameter class.
+     * @param options The options to use for this instance.
+     */
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
 declare const createParameter: <TBuilder extends SourceBuilder>(name: KtParameter<TBuilder>['name'], type: KtParameter<TBuilder>['type'], options?: Prettify<Omit<Options<TBuilder>, 'name' | 'type' | 'accessModifier' | 'property' | 'propertyDescription' | 'override'>>) => KtParameter<TBuilder>;
 declare const createClassParameter: <TBuilder extends SourceBuilder>(name: KtParameter<TBuilder>['name'], type: KtParameter<TBuilder>['type'], options?: Prettify<Omit<Options<TBuilder>, 'name' | 'type'>>) => KtParameter<TBuilder>;
+/**
+ * Factory for creating parameter nodes. The `class` function creates a class constructor parameter, which can declare a
+ * property, and accepts the options for it. The `write` function writes a parenthesized parameter list.
+ *
+ * @param name The name of the parameter.
+ * @param type The type of the parameter.
+ * @param options The settings of the parameter. See `KtParameter` for the available properties.
+ * @example
+ * ```ts
+ * ktParameter('x', 'Int', { default: '42', annotations: [ktAnnotation('Inject')] });
+ * // Emits:
+ * // @Inject
+ * // x: Int = 42
+ * ```
+ */
 export declare const ktParameter: typeof createParameter & {
     class: typeof createClassParameter;
     write: typeof writeKtParameters;