@goast/kotlin 0.7.0-beta.2 → 0.7.1

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

@@ -1,26 +1,54 @@
+/**
+ * Pre-built references to Kotlin standard library types, functions and annotations.
+ *
+ * The `kotlin`, `kotlin.collections` and `kotlin.jvm` packages are in the default `globalImports`, so no `import`
+ * is emitted for these references unless `globalImports` is changed.
+ */
 import { ktReference } from '../nodes/reference.js';
 // kotlin
+/** Reference to `Any` from the `kotlin` package. */
 export const any = ktReference.factory('Any', 'kotlin');
+/** Reference to `Nothing` from the `kotlin` package. */
 export const nothing = ktReference.factory('Nothing', 'kotlin');
+/** Reference to `Unit` from the `kotlin` package. */
 export const unit = ktReference.factory('Unit', 'kotlin');
+/** Reference to `String` from the `kotlin` package. */
 export const string = ktReference.factory('String', 'kotlin');
+/** Reference to `Int` from the `kotlin` package. */
 export const int = ktReference.factory('Int', 'kotlin');
+/** Reference to `Long` from the `kotlin` package. */
 export const long = ktReference.factory('Long', 'kotlin');
+/** Reference to `Float` from the `kotlin` package. */
 export const float = ktReference.factory('Float', 'kotlin');
+/** Reference to `Double` from the `kotlin` package. */
 export const double = ktReference.factory('Double', 'kotlin');
+/** Reference to `Boolean` from the `kotlin` package. */
 export const boolean = ktReference.factory('Boolean', 'kotlin');
+/** Reference to the `lazy` function from the `kotlin` package. Takes one type argument. */
 export const lazyFun = ktReference.genericFactory('lazy', 'kotlin');
+/** Reference to the `Throws` annotation from the `kotlin` package. */
 export const throws = ktReference.factory('Throws', 'kotlin');
+/** Reference to the `Deprecated` annotation from the `kotlin` package. */
 export const deprecated = ktReference.factory('Deprecated', 'kotlin');
+/** Reference to `Throwable` from the `kotlin` package. */
 export const throwable = ktReference.factory('Throwable', 'kotlin');
 // kotlin.collections
+/** Reference to the `List` type from the `kotlin.collections` package. Takes one type argument. */
 export const list = ktReference.genericFactory('List', 'kotlin.collections');
+/** Reference to the `MutableList` type from the `kotlin.collections` package. Takes one type argument. */
 export const mutableList = ktReference.genericFactory('MutableList', 'kotlin.collections');
+/** Reference to the `Map` type from the `kotlin.collections` package. Takes two type arguments. */
 export const map = ktReference.genericFactory('Map', 'kotlin.collections');
+/** Reference to the `MutableMap` type from the `kotlin.collections` package. Takes two type arguments. */
 export const mutableMap = ktReference.genericFactory('MutableMap', 'kotlin.collections');
+/** Reference to the `listOf` function from the `kotlin.collections` package. Takes one type argument. */
 export const listOf = ktReference.genericFactory('listOf', 'kotlin.collections');
+/** Reference to the `mutableListOf` function from the `kotlin.collections` package. Takes one type argument. */
 export const mutableListOf = ktReference.genericFactory('mutableListOf', 'kotlin.collections');
+/** Reference to the `mapOf` function from the `kotlin.collections` package. Takes two type arguments. */
 export const mapOf = ktReference.genericFactory('mapOf', 'kotlin.collections');
+/** Reference to the `mutableMapOf` function from the `kotlin.collections` package. Takes two type arguments. */
 export const mutableMapOf = ktReference.genericFactory('mutableMapOf', 'kotlin.collections');
 // kotlin.jvm
+/** Reference to the `JvmStatic` annotation from the `kotlin.jvm` package. */
 export const jvmStatic = ktReference.factory('JvmStatic', 'kotlin.jvm');

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

@@ -1,4 +1,12 @@
+/**
+ * Pre-built references to `kotlinx.coroutines` functions that bridge Reactive Streams and Reactor to coroutines.
+ *
+ * None of these packages is in the default `globalImports`, so every reference emits an `import`.
+ */
 import { type KtGenericReferenceFactory } from '../nodes/reference.ts';
+/** Reference to `awaitFirst` from the `kotlinx.coroutines.reactive` package. Takes one type argument. */
 export declare const awaitFirst: KtGenericReferenceFactory<1>;
+/** Reference to `awaitFirstOrNull` from the `kotlinx.coroutines.reactive` package. Takes one type argument. */
 export declare const awaitFirstOrNull: KtGenericReferenceFactory<1>;
+/** Reference to the `mono` builder from the `kotlinx.coroutines.reactor` package. Takes one type argument. */
 export declare const mono: KtGenericReferenceFactory<1>;

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

@@ -1,6 +1,14 @@
+/**
+ * Pre-built references to `kotlinx.coroutines` functions that bridge Reactive Streams and Reactor to coroutines.
+ *
+ * None of these packages is in the default `globalImports`, so every reference emits an `import`.
+ */
 import { ktReference } from '../nodes/reference.js';
 // kotlinx.coroutines.reactive
+/** Reference to `awaitFirst` from the `kotlinx.coroutines.reactive` package. Takes one type argument. */
 export const awaitFirst = ktReference.genericFactory('awaitFirst', 'kotlinx.coroutines.reactive');
+/** Reference to `awaitFirstOrNull` from the `kotlinx.coroutines.reactive` package. Takes one type argument. */
 export const awaitFirstOrNull = ktReference.genericFactory('awaitFirstOrNull', 'kotlinx.coroutines.reactive');
 // kotlinx.coroutines.reactor
+/** Reference to the `mono` builder from the `kotlinx.coroutines.reactor` package. Takes one type argument. */
 export const mono = ktReference.genericFactory('mono', 'kotlinx.coroutines.reactor');

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

@@ -1,3 +1,11 @@
+/**
+ * Pre-built references to OkHttp3 types.
+ *
+ * Each `export const` is a factory that creates a `KtReference` with the given name and package, so the
+ * generated code imports the type automatically. See `KtReferenceFactory` for the optional `options`.
+ */
 import { type KtReferenceFactory } from '../nodes/reference.ts';
+/** Reference to `Factory` nested in `okhttp3.Call`, used as the type of generated `client` parameters. */
 export declare const okHttpClient: KtReferenceFactory;
+/** Reference to `HttpUrl` from the `okhttp3` package. */
 export declare const httpUrl: KtReferenceFactory;

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

@@ -1,4 +1,12 @@
+/**
+ * Pre-built references to OkHttp3 types.
+ *
+ * Each `export const` is a factory that creates a `KtReference` with the given name and package, so the
+ * generated code imports the type automatically. See `KtReferenceFactory` for the optional `options`.
+ */
 import { ktReference } from '../nodes/reference.js';
 // okhttp3
+/** Reference to `Factory` nested in `okhttp3.Call`, used as the type of generated `client` parameters. */
 export const okHttpClient = ktReference.factory('Factory', 'okhttp3.Call');
+/** Reference to `HttpUrl` from the `okhttp3` package. */
 export const httpUrl = ktReference.factory('HttpUrl', 'okhttp3');

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

@@ -1,3 +1,11 @@
+/**
+ * Pre-built references to Project Reactor publisher types.
+ *
+ * Each `export const` is a generic factory that creates a `KtReference` with the given name and package, so the
+ * generated code imports the type automatically. See `KtGenericReferenceFactory` for the type-argument tuple.
+ */
 import { type KtGenericReferenceFactory } from '../nodes/reference.ts';
+/** Generic reference to `Flux` from the `reactor.core.publisher` package, taking one type argument. */
 export declare const flux: KtGenericReferenceFactory<1>;
+/** Generic reference to `Mono` from the `reactor.core.publisher` package, taking one type argument. */
 export declare const mono: KtGenericReferenceFactory<1>;

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

@@ -1,4 +1,12 @@
+/**
+ * Pre-built references to Project Reactor publisher types.
+ *
+ * Each `export const` is a generic factory that creates a `KtReference` with the given name and package, so the
+ * generated code imports the type automatically. See `KtGenericReferenceFactory` for the type-argument tuple.
+ */
 import { ktReference } from '../nodes/reference.js';
 // reactor.core.publisher
+/** Generic reference to `Flux` from the `reactor.core.publisher` package, taking one type argument. */
 export const flux = ktReference.genericFactory('Flux', 'reactor.core.publisher');
+/** Generic reference to `Mono` from the `reactor.core.publisher` package, taking one type argument. */
 export const mono = ktReference.genericFactory('Mono', 'reactor.core.publisher');

package/dist/src/ast/references/spring-reactive.d.ts

@@ -1,9 +1,27 @@
+/**
+ * Pre-built references to Spring WebFlux `WebClient` types and the Kotlin extension functions used with them.
+ *
+ * Each `export const` is a factory that creates a `KtReference` with the given name and package, so the
+ * generated code imports the type automatically. See `KtReferenceFactory` for the optional `options`, and
+ * `KtGenericReferenceFactory` for the type-argument tuple that generic factories take first.
+ */
 import { type KtGenericReferenceFactory, type KtReferenceFactory } from '../nodes/reference.ts';
+/** Reference to `BodyInserters` from the `org.springframework.web.reactive.function` package. */
 export declare const bodyInserters: KtReferenceFactory;
+/** Reference to `WebClient` from the `org.springframework.web.reactive.function.client` package. */
 export declare const webClient: KtReferenceFactory;
+/** Reference to `ClientResponse` from the `org.springframework.web.reactive.function.client` package. */
 export declare const clientResponse: KtReferenceFactory;
+/**
+ * Generic reference to `RequestHeadersSpec` from the `org.springframework.web.reactive.function.client.WebClient`
+ * package, a type nested in `WebClient`, taking one type argument.
+ */
 export declare const requestHeadersSpec: KtGenericReferenceFactory<1>;
+/** Generic reference to `toEntity` from the `org.springframework.web.reactive.function.client` package. */
 export declare const toEntity: KtGenericReferenceFactory<1>;
+/** Generic reference to `awaitBody` from the `org.springframework.web.reactive.function.client` package. */
 export declare const awaitBody: KtGenericReferenceFactory<1>;
+/** Reference to `awaitBodilessEntity` from the `org.springframework.web.reactive.function.client` package. */
 export declare const awaitBodilessEntity: KtReferenceFactory;
+/** Reference to `awaitExchange` from the `org.springframework.web.reactive.function.client` package. */
 export declare const awaitExchange: KtReferenceFactory;

package/dist/src/ast/references/spring-reactive.js

@@ -1,11 +1,29 @@
+/**
+ * Pre-built references to Spring WebFlux `WebClient` types and the Kotlin extension functions used with them.
+ *
+ * Each `export const` is a factory that creates a `KtReference` with the given name and package, so the
+ * generated code imports the type automatically. See `KtReferenceFactory` for the optional `options`, and
+ * `KtGenericReferenceFactory` for the type-argument tuple that generic factories take first.
+ */
 import { ktReference } from '../nodes/reference.js';
 // org.springframework.web.reactive.function
+/** Reference to `BodyInserters` from the `org.springframework.web.reactive.function` package. */
 export const bodyInserters = ktReference.factory('BodyInserters', 'org.springframework.web.reactive.function');
 // org.springframework.web.reactive.function.client
+/** Reference to `WebClient` from the `org.springframework.web.reactive.function.client` package. */
 export const webClient = ktReference.factory('WebClient', 'org.springframework.web.reactive.function.client');
+/** Reference to `ClientResponse` from the `org.springframework.web.reactive.function.client` package. */
 export const clientResponse = ktReference.factory('ClientResponse', 'org.springframework.web.reactive.function.client');
+/**
+ * Generic reference to `RequestHeadersSpec` from the `org.springframework.web.reactive.function.client.WebClient`
+ * package, a type nested in `WebClient`, taking one type argument.
+ */
 export const requestHeadersSpec = ktReference.genericFactory('RequestHeadersSpec', 'org.springframework.web.reactive.function.client.WebClient');
+/** Generic reference to `toEntity` from the `org.springframework.web.reactive.function.client` package. */
 export const toEntity = ktReference.genericFactory('toEntity', 'org.springframework.web.reactive.function.client');
+/** Generic reference to `awaitBody` from the `org.springframework.web.reactive.function.client` package. */
 export const awaitBody = ktReference.genericFactory('awaitBody', 'org.springframework.web.reactive.function.client');
+/** Reference to `awaitBodilessEntity` from the `org.springframework.web.reactive.function.client` package. */
 export const awaitBodilessEntity = ktReference.factory('awaitBodilessEntity', 'org.springframework.web.reactive.function.client');
+/** Reference to `awaitExchange` from the `org.springframework.web.reactive.function.client` package. */
 export const awaitExchange = ktReference.factory('awaitExchange', 'org.springframework.web.reactive.function.client');

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

@@ -1,21 +1,48 @@
+/**
+ * Pre-built references to well-known Spring Framework types.
+ *
+ * Each `export const` is a factory that creates a `KtReference` with the given name and package, so the
+ * generated code imports the type automatically. See `KtReferenceFactory` for the optional `options`, and
+ * `KtGenericReferenceFactory` for the type-argument tuple that generic factories take first.
+ */
 import { type KtGenericReferenceFactory, type KtReferenceFactory } from '../nodes/reference.ts';
+/** Reference to `Autowired` from the `org.springframework.beans.factory.annotation` package. */
 export declare const autowired: KtReferenceFactory;
+/** Reference to `HttpStatus` from the `org.springframework.http` package. */
 export declare const httpStatus: KtReferenceFactory;
+/** Reference to `HttpMethod` from the `org.springframework.http` package. */
 export declare const httpMethod: KtReferenceFactory;
+/** Generic reference to `ResponseEntity` from the `org.springframework.http` package, taking one type argument. */
 export declare const responseEntity: KtGenericReferenceFactory<1>;
+/** Reference to `MediaType` from the `org.springframework.http` package. */
 export declare const mediaType: KtReferenceFactory;
+/** Reference to `MultipartBodyBuilder` from the `org.springframework.http.client` package. */
 export declare const multipartBodyBuilder: KtReferenceFactory;
+/** Reference to `FilePart` from the `org.springframework.http.codec.multipart` package. */
 export declare const filePart: KtReferenceFactory;
+/** Reference to `Controller` from the `org.springframework.stereotype` package. */
 export declare const controller: KtReferenceFactory;
+/** Generic reference to `MultiValueMap` from the `org.springframework.util` package, taking two type arguments. */
 export declare const multiValueMap: KtGenericReferenceFactory<2>;
+/** Generic reference to `LinkedMultiValueMap` from `org.springframework.util`, taking two type arguments. */
 export declare const linkedMultiValueMap: KtGenericReferenceFactory<2>;
+/** Reference to `Validated` from the `org.springframework.validation.annotation` package. */
 export declare const validated: KtReferenceFactory;
+/** Reference to `PathVariable` from the `org.springframework.web.bind.annotation` package. */
 export declare const pathVariable: KtReferenceFactory;
+/** Reference to `RequestBody` from the `org.springframework.web.bind.annotation` package. */
 export declare const requestBody: KtReferenceFactory;
+/** Reference to `RequestMapping` from the `org.springframework.web.bind.annotation` package. */
 export declare const requestMapping: KtReferenceFactory;
+/** Reference to `RequestMethod` from the `org.springframework.web.bind.annotation` package. */
 export declare const requestMethod: KtReferenceFactory;
+/** Reference to `RequestParam` from the `org.springframework.web.bind.annotation` package. */
 export declare const requestParam: KtReferenceFactory;
+/** Reference to `RequestPart` from the `org.springframework.web.bind.annotation` package. */
 export declare const requestPart: KtReferenceFactory;
+/** Reference to `RequestHeader` from the `org.springframework.web.bind.annotation` package. */
 export declare const requestHeader: KtReferenceFactory;
+/** Reference to `NativeWebRequest` from the `org.springframework.web.context.request` package. */
 export declare const nativeWebRequest: KtReferenceFactory;
+/** Reference to `UriComponentsBuilder` from the `org.springframework.web.util` package. */
 export declare const uriComponentsBuilder: KtReferenceFactory;

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

@@ -1,31 +1,58 @@
+/**
+ * Pre-built references to well-known Spring Framework types.
+ *
+ * Each `export const` is a factory that creates a `KtReference` with the given name and package, so the
+ * generated code imports the type automatically. See `KtReferenceFactory` for the optional `options`, and
+ * `KtGenericReferenceFactory` for the type-argument tuple that generic factories take first.
+ */
 import { ktReference } from '../nodes/reference.js';
 // org.springframework.beans.factory.annotation
+/** Reference to `Autowired` from the `org.springframework.beans.factory.annotation` package. */
 export const autowired = ktReference.factory('Autowired', 'org.springframework.beans.factory.annotation');
 // org.springframework.http
+/** Reference to `HttpStatus` from the `org.springframework.http` package. */
 export const httpStatus = ktReference.factory('HttpStatus', 'org.springframework.http');
+/** Reference to `HttpMethod` from the `org.springframework.http` package. */
 export const httpMethod = ktReference.factory('HttpMethod', 'org.springframework.http');
+/** Generic reference to `ResponseEntity` from the `org.springframework.http` package, taking one type argument. */
 export const responseEntity = ktReference.genericFactory('ResponseEntity', 'org.springframework.http');
+/** Reference to `MediaType` from the `org.springframework.http` package. */
 export const mediaType = ktReference.factory('MediaType', 'org.springframework.http');
 // org.springframework.http.client
+/** Reference to `MultipartBodyBuilder` from the `org.springframework.http.client` package. */
 export const multipartBodyBuilder = ktReference.factory('MultipartBodyBuilder', 'org.springframework.http.client');
 // org.springframework.http.codec.multipart
+/** Reference to `FilePart` from the `org.springframework.http.codec.multipart` package. */
 export const filePart = ktReference.factory('FilePart', 'org.springframework.http.codec.multipart');
 // org.springframework.stereotype
+/** Reference to `Controller` from the `org.springframework.stereotype` package. */
 export const controller = ktReference.factory('Controller', 'org.springframework.stereotype');
 // org.springframework.util
+/** Generic reference to `MultiValueMap` from the `org.springframework.util` package, taking two type arguments. */
 export const multiValueMap = ktReference.genericFactory('MultiValueMap', 'org.springframework.util');
+/** Generic reference to `LinkedMultiValueMap` from `org.springframework.util`, taking two type arguments. */
 export const linkedMultiValueMap = ktReference.genericFactory('LinkedMultiValueMap', 'org.springframework.util');
 // org.springframework.validation.annotation
+/** Reference to `Validated` from the `org.springframework.validation.annotation` package. */
 export const validated = ktReference.factory('Validated', 'org.springframework.validation.annotation');
 // org.springframework.web.bind.annotation
+/** Reference to `PathVariable` from the `org.springframework.web.bind.annotation` package. */
 export const pathVariable = ktReference.factory('PathVariable', 'org.springframework.web.bind.annotation');
+/** Reference to `RequestBody` from the `org.springframework.web.bind.annotation` package. */
 export const requestBody = ktReference.factory('RequestBody', 'org.springframework.web.bind.annotation');
+/** Reference to `RequestMapping` from the `org.springframework.web.bind.annotation` package. */
 export const requestMapping = ktReference.factory('RequestMapping', 'org.springframework.web.bind.annotation');
+/** Reference to `RequestMethod` from the `org.springframework.web.bind.annotation` package. */
 export const requestMethod = ktReference.factory('RequestMethod', 'org.springframework.web.bind.annotation');
+/** Reference to `RequestParam` from the `org.springframework.web.bind.annotation` package. */
 export const requestParam = ktReference.factory('RequestParam', 'org.springframework.web.bind.annotation');
+/** Reference to `RequestPart` from the `org.springframework.web.bind.annotation` package. */
 export const requestPart = ktReference.factory('RequestPart', 'org.springframework.web.bind.annotation');
+/** Reference to `RequestHeader` from the `org.springframework.web.bind.annotation` package. */
 export const requestHeader = ktReference.factory('RequestHeader', 'org.springframework.web.bind.annotation');
 // org.springframework.web.context.request
+/** Reference to `NativeWebRequest` from the `org.springframework.web.context.request` package. */
 export const nativeWebRequest = ktReference.factory('NativeWebRequest', 'org.springframework.web.context.request');
 // org.springframework.web.util
+/** Reference to `UriComponentsBuilder` from the `org.springframework.web.util` package. */
 export const uriComponentsBuilder = ktReference.factory('UriComponentsBuilder', 'org.springframework.web.util');

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

@@ -1,8 +1,21 @@
+/**
+ * Pre-built references to Swagger/OpenAPI annotation types from the `io.swagger.v3.oas.annotations` packages.
+ *
+ * Each `export const` is a factory that creates a `KtReference` with the given name and package, so the
+ * generated code imports the type automatically. See `KtReferenceFactory` for the optional `options`.
+ */
 import { type KtReferenceFactory } from '../nodes/reference.ts';
+/** Reference to `Parameter` from the `io.swagger.v3.oas.annotations` package. */
 export declare const parameter: KtReferenceFactory;
+/** Reference to `Operation` from the `io.swagger.v3.oas.annotations` package. */
 export declare const operation: KtReferenceFactory;
+/** Reference to `Schema` from the `io.swagger.v3.oas.annotations.media` package. */
 export declare const schema: KtReferenceFactory;
+/** Reference to `ArraySchema` from the `io.swagger.v3.oas.annotations.media` package. */
 export declare const arraySchema: KtReferenceFactory;
+/** Reference to `Content` from the `io.swagger.v3.oas.annotations.media` package. */
 export declare const content: KtReferenceFactory;
+/** Reference to `ApiResponse` from the `io.swagger.v3.oas.annotations.responses` package. */
 export declare const apiResponse: KtReferenceFactory;
+/** Reference to `ApiResponses` from the `io.swagger.v3.oas.annotations.responses` package. */
 export declare const apiResponses: KtReferenceFactory;

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

@@ -1,11 +1,24 @@
+/**
+ * Pre-built references to Swagger/OpenAPI annotation types from the `io.swagger.v3.oas.annotations` packages.
+ *
+ * Each `export const` is a factory that creates a `KtReference` with the given name and package, so the
+ * generated code imports the type automatically. See `KtReferenceFactory` for the optional `options`.
+ */
 import { ktReference } from '../nodes/reference.js';
 // io.swagger.v3.oas.annotations
+/** Reference to `Parameter` from the `io.swagger.v3.oas.annotations` package. */
 export const parameter = ktReference.factory('Parameter', 'io.swagger.v3.oas.annotations');
+/** Reference to `Operation` from the `io.swagger.v3.oas.annotations` package. */
 export const operation = ktReference.factory('Operation', 'io.swagger.v3.oas.annotations');
 // io.swagger.v3.oas.annotations.media
+/** Reference to `Schema` from the `io.swagger.v3.oas.annotations.media` package. */
 export const schema = ktReference.factory('Schema', 'io.swagger.v3.oas.annotations.media');
+/** Reference to `ArraySchema` from the `io.swagger.v3.oas.annotations.media` package. */
 export const arraySchema = ktReference.factory('ArraySchema', 'io.swagger.v3.oas.annotations.media');
+/** Reference to `Content` from the `io.swagger.v3.oas.annotations.media` package. */
 export const content = ktReference.factory('Content', 'io.swagger.v3.oas.annotations.media');
 // io.swagger.v3.oas.annotations.responses
+/** Reference to `ApiResponse` from the `io.swagger.v3.oas.annotations.responses` package. */
 export const apiResponse = ktReference.factory('ApiResponse', 'io.swagger.v3.oas.annotations.responses');
+/** Reference to `ApiResponses` from the `io.swagger.v3.oas.annotations.responses` package. */
 export const apiResponses = ktReference.factory('ApiResponses', 'io.swagger.v3.oas.annotations.responses');

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

@@ -1,3 +1,13 @@
 import { type SourceBuilder } from '@goast/core';
 import { type KotlinGeneratorConfig } from '../../config.ts';
+/**
+ * Gets the Kotlin generator configuration that applies to a builder.
+ *
+ * A `KotlinFileBuilder` returns its own options. For any other builder, the OpenAPI defaults are overridden by the
+ * Kotlin defaults, which are overridden by the builder's own options. The merged result is also assigned to the
+ * builder under a private symbol key.
+ *
+ * @param builder The builder to get the configuration for.
+ * @returns The Kotlin generator configuration for the builder.
+ */
 export declare function getKotlinBuilderOptions(builder: SourceBuilder): KotlinGeneratorConfig;

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

@@ -2,6 +2,16 @@ import { defaultOpenApiGeneratorConfig } from '@goast/core';
 import { defaultKotlinGeneratorConfig } from '../../config.js';
 import { KotlinFileBuilder } from '../../file-builder.js';
 const ktConfigSymbol = Symbol();
+/**
+ * Gets the Kotlin generator configuration that applies to a builder.
+ *
+ * A `KotlinFileBuilder` returns its own options. For any other builder, the OpenAPI defaults are overridden by the
+ * Kotlin defaults, which are overridden by the builder's own options. The merged result is also assigned to the
+ * builder under a private symbol key.
+ *
+ * @param builder The builder to get the configuration for.
+ * @returns The Kotlin generator configuration for the builder.
+ */
 export function getKotlinBuilderOptions(builder) {
     if (builder instanceof KotlinFileBuilder) {
         return builder.options;

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

@@ -1,7 +1,47 @@
 import type { BasicAppendValue, SourceBuilder } from '@goast/core';
 import { type KtCall } from '../nodes/call.ts';
 import { type KtString } from '../nodes/string.ts';
+/**
+ * Converts a plain object into a Kotlin `mapOf(...)` call, with one `"key".to(value)` entry per property.
+ *
+ * Each property value is converted with the same rules, recursively. The entries are the arguments of the call, so
+ * they are written inline with `, ` between them, or one per line separated by `,` when there are more than three.
+ * No blank lines are written.
+ *
+ * @template TBuilder The type of the source builder the call is written to.
+ * @param object The object whose own enumerable properties become the map entries.
+ * @returns A Kotlin call node for `mapOf`.
+ */
 export declare function toKtNode<TBuilder extends SourceBuilder>(object: Record<string | number, unknown>): KtCall<TBuilder>;
+/**
+ * Converts an array into a Kotlin `listOf(...)` call, with each element converted recursively.
+ *
+ * The elements are the arguments of the call, so they are written inline, separated by `, `, or one per line separated
+ * by `,` when there are more than three. No blank lines are written.
+ *
+ * @template TBuilder The type of the source builder the call is written to.
+ * @param list The array whose elements become the list entries.
+ * @returns A Kotlin call node for `listOf`.
+ */
 export declare function toKtNode<TBuilder extends SourceBuilder>(list: unknown[]): KtCall<TBuilder>;
+/**
+ * Converts a string into a Kotlin string literal node.
+ *
+ * @template TBuilder The type of the source builder the literal is written to.
+ * @param string The string to convert.
+ * @returns A Kotlin string literal node.
+ */
 export declare function toKtNode<TBuilder extends SourceBuilder>(string: string): KtString<TBuilder>;
+/**
+ * Converts any value into a Kotlin node or a plain append value.
+ *
+ * `null` and `undefined` become the text `null`. Booleans and numbers are written with `String(value)`. Arrays and
+ * objects are converted to `listOf` and `mapOf` calls, as described for the other overloads. All remaining values are
+ * converted to a string literal of their `String` representation.
+ *
+ * @template TBuilder The type of the source builder the value is written to.
+ * @param value The value to convert.
+ * @returns A Kotlin call or string node for arrays, objects and other values, or the text of `null`, booleans and
+ * numbers.
+ */
 export declare function toKtNode<TBuilder extends SourceBuilder>(value: unknown): BasicAppendValue<TBuilder>;

package/dist/src/ast/utils/write-kt-annotations.d.ts

@@ -1,5 +1,18 @@
 import { type Nullable, type SingleOrMultiple, type SourceBuilder } from '@goast/core';
 import { type KtAppendValue } from './write-kt-node.ts';
+/**
+ * Writes a list of annotations, each followed by a separator.
+ *
+ * Each annotation, including the last one, is followed by a line break when `options.multiline` is set, or by a single
+ * space otherwise. Nothing is written before the first annotation, and no blank lines are added. Content written after
+ * the annotations therefore starts after that trailing separator.
+ *
+ * @template TBuilder The type of the source builder the annotations are written to.
+ * @param builder The builder to write to.
+ * @param nodes The annotations, as a single node or an array. Nullish entries are ignored.
+ * @param options Options for writing. When `multiline` is `true`, each annotation is followed by a line break instead
+ * of a space.
+ */
 export declare function writeKtAnnotations<TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>, options?: {
     multiline: boolean;
 }): void;

package/dist/src/ast/utils/write-kt-annotations.js

@@ -1,5 +1,18 @@
 import { notNullish, toArray } from '@goast/core';
 import { writeKtNode } from './write-kt-node.js';
+/**
+ * Writes a list of annotations, each followed by a separator.
+ *
+ * Each annotation, including the last one, is followed by a line break when `options.multiline` is set, or by a single
+ * space otherwise. Nothing is written before the first annotation, and no blank lines are added. Content written after
+ * the annotations therefore starts after that trailing separator.
+ *
+ * @template TBuilder The type of the source builder the annotations are written to.
+ * @param builder The builder to write to.
+ * @param nodes The annotations, as a single node or an array. Nullish entries are ignored.
+ * @param options Options for writing. When `multiline` is `true`, each annotation is followed by a line break instead
+ * of a space.
+ */
 export function writeKtAnnotations(builder, nodes, options) {
     const filteredNodes = toArray(nodes).filter(notNullish);
     builder.forEach(filteredNodes, (b, a) => {

package/dist/src/ast/utils/write-kt-arguments.d.ts

@@ -1,3 +1,18 @@
 import { type Nullable, type SingleOrMultiple, type SourceBuilder } from '@goast/core';
 import { type KtAppendValue } from './write-kt-node.ts';
+/**
+ * Writes a call's argument list, moving a trailing lambda after the closing parenthesis.
+ *
+ * - No arguments write `()`.
+ * - A trailing `KtLambda`, passed directly or as the value of an unnamed argument, is removed from the arguments and
+ *   written after them with a leading space, such as `foo(a) { ... }`.
+ * - If the lambda is the only argument, the parentheses are omitted, such as `foo { ... }`.
+ * - Arguments are written inline, separated by `, `. With more than three arguments, the parentheses go on their own
+ *   lines and each argument is written on its own line, separated by `,` and a line break.
+ * - No blank lines and no trailing comma are written.
+ *
+ * @template TBuilder The type of the source builder the arguments are written to.
+ * @param builder The builder to write to.
+ * @param nodes The arguments, as a single node or an array. Nullish entries are ignored.
+ */
 export declare function writeKtArguments<TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>): void;

package/dist/src/ast/utils/write-kt-arguments.js

@@ -1,6 +1,21 @@
 import { notNullish, toArray } from '@goast/core';
 import { KtLambda } from '../nodes/lambda.js';
 import { writeKtNode, writeKtNodes } from './write-kt-node.js';
+/**
+ * Writes a call's argument list, moving a trailing lambda after the closing parenthesis.
+ *
+ * - No arguments write `()`.
+ * - A trailing `KtLambda`, passed directly or as the value of an unnamed argument, is removed from the arguments and
+ *   written after them with a leading space, such as `foo(a) { ... }`.
+ * - If the lambda is the only argument, the parentheses are omitted, such as `foo { ... }`.
+ * - Arguments are written inline, separated by `, `. With more than three arguments, the parentheses go on their own
+ *   lines and each argument is written on its own line, separated by `,` and a line break.
+ * - No blank lines and no trailing comma are written.
+ *
+ * @template TBuilder The type of the source builder the arguments are written to.
+ * @param builder The builder to write to.
+ * @param nodes The arguments, as a single node or an array. Nullish entries are ignored.
+ */
 export function writeKtArguments(builder, nodes) {
     const filteredNodes = toArray(nodes).filter(notNullish);
     if (filteredNodes.length === 0) {

package/dist/src/ast/utils/write-kt-enum-values.d.ts

@@ -1,3 +1,16 @@
 import { type Nullable, type SingleOrMultiple, type SourceBuilder } from '@goast/core';
 import { type KtAppendValue } from './write-kt-node.ts';
+/**
+ * Writes the entries of a Kotlin enum class, separated by commas.
+ *
+ * The entries are written inline, separated by `, `, unless the list is multiline. The list is multiline when any entry
+ * has annotations, a doc comment or members, when there are more than four entries, or when any entry has arguments.
+ * A multiline list writes each entry on its own line, separated by `,` and a line break. When any entry has
+ * annotations, a doc comment or members, a blank line is also written before every entry except the first. No trailing
+ * comma or semicolon is written, so the caller adds the terminator.
+ *
+ * @template TBuilder The type of the source builder the entries are written to.
+ * @param builder The builder to write to.
+ * @param nodes The enum entries, as a single node or an array. Nullish entries are ignored.
+ */
 export declare function writeKtEnumValues<TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>): void;

package/dist/src/ast/utils/write-kt-enum-values.js

@@ -1,5 +1,18 @@
 import { notNullish, toArray } from '@goast/core';
 import { writeKtNode } from './write-kt-node.js';
+/**
+ * Writes the entries of a Kotlin enum class, separated by commas.
+ *
+ * The entries are written inline, separated by `, `, unless the list is multiline. The list is multiline when any entry
+ * has annotations, a doc comment or members, when there are more than four entries, or when any entry has arguments.
+ * A multiline list writes each entry on its own line, separated by `,` and a line break. When any entry has
+ * annotations, a doc comment or members, a blank line is also written before every entry except the first. No trailing
+ * comma or semicolon is written, so the caller adds the terminator.
+ *
+ * @template TBuilder The type of the source builder the entries are written to.
+ * @param builder The builder to write to.
+ * @param nodes The enum entries, as a single node or an array. Nullish entries are ignored.
+ */
 export function writeKtEnumValues(builder, nodes) {
     const filteredNodes = toArray(nodes).filter(notNullish);
     const spacing = filteredNodes.some((v) => typeof v === 'object' &&

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

@@ -1,3 +1,13 @@
 import { type Nullable, type SingleOrMultiple, type SourceBuilder } from '@goast/core';
 import { type KtAppendValue } from './write-kt-node.ts';
+/**
+ * Writes a list of generic parameters or type arguments in angle brackets, such as `<T, U>`.
+ *
+ * Nothing is written when there are no entries. Otherwise the entries are always written on one line, separated by
+ * `, `.
+ *
+ * @template TBuilder The type of the source builder the entries are written to.
+ * @param builder The builder to write to.
+ * @param nodes The type parameters or type arguments, as a single node or an array. Nullish entries are ignored.
+ */
 export declare function writeKtGenericParameters<TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>): void;

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

@@ -1,5 +1,15 @@
 import { notNullish, toArray } from '@goast/core';
 import { writeKtNode } from './write-kt-node.js';
+/**
+ * Writes a list of generic parameters or type arguments in angle brackets, such as `<T, U>`.
+ *
+ * Nothing is written when there are no entries. Otherwise the entries are always written on one line, separated by
+ * `, `.
+ *
+ * @template TBuilder The type of the source builder the entries are written to.
+ * @param builder The builder to write to.
+ * @param nodes The type parameters or type arguments, as a single node or an array. Nullish entries are ignored.
+ */
 export function writeKtGenericParameters(builder, nodes) {
     const filteredNodes = toArray(nodes).filter(notNullish);
     if (filteredNodes.length === 0)

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

@@ -1,5 +1,21 @@
 import { type Nullable, type SourceBuilder } from '@goast/core';
 import { type KtAppendValue } from './write-kt-node.ts';
+/**
+ * Writes class members, separating them with blank lines where needed.
+ *
+ * Each member is either compact or a block. A compact member is a `KtProperty` without a doc comment and without
+ * annotations, or a plain append value such as a string. All other members are blocks. The rules are:
+ * - A block member is preceded by a blank line, except when it is the first member and `alreadyHasMembers` is not set.
+ * - A block member is followed by a blank line, except when it is the last member.
+ * - A compact member is written on its own line and followed by a line break. No blank line is added before or after
+ *   it, so consecutive compact members are written on consecutive lines.
+ *
+ * @template TBuilder The type of the source builder the members are written to.
+ * @param builder The builder to write to.
+ * @param members The members in the order they are written. Nullish entries are ignored.
+ * @param options Options for writing. Set `alreadyHasMembers` when other members precede these, so that a first block
+ * member also gets a blank line before it.
+ */
 export declare function writeKtMembers<TBuilder extends SourceBuilder>(builder: TBuilder, members: Nullable<KtAppendValue<TBuilder>>[], options?: {
     alreadyHasMembers?: boolean;
 }): void;