@goast/kotlin 0.5.11-beta.2 → 0.5.11

package/src/src/ast/references/kotlin.ts

@@ -0,0 +1,41 @@
+import { type KtGenericReferenceFactory, ktReference, type KtReferenceFactory } from '../nodes/reference.js';
+
+// kotlin
+export const any: KtReferenceFactory = ktReference.factory('Any', 'kotlin');
+export const nothing: KtReferenceFactory = ktReference.factory('Nothing', 'kotlin');
+export const unit: KtReferenceFactory = ktReference.factory('Unit', 'kotlin');
+export const string: KtReferenceFactory = ktReference.factory('String', 'kotlin');
+export const int: KtReferenceFactory = ktReference.factory('Int', 'kotlin');
+export const long: KtReferenceFactory = ktReference.factory('Long', 'kotlin');
+export const float: KtReferenceFactory = ktReference.factory('Float', 'kotlin');
+export const double: KtReferenceFactory = ktReference.factory('Double', 'kotlin');
+export const boolean: KtReferenceFactory = ktReference.factory('Boolean', 'kotlin');
+export const lazyFun: KtGenericReferenceFactory<1> = ktReference.genericFactory<1>('lazy', 'kotlin');
+export const throws: KtReferenceFactory = ktReference.factory('Throws', 'kotlin');
+export const deprecated: KtReferenceFactory = ktReference.factory('Deprecated', 'kotlin');
+export const throwable: KtReferenceFactory = ktReference.factory('Throwable', 'kotlin');
+
+// kotlin.collections
+export const list: KtGenericReferenceFactory<1> = ktReference.genericFactory<1>('List', 'kotlin.collections');
+export const mutableList: KtGenericReferenceFactory<1> = ktReference.genericFactory<1>(
+  'MutableList',
+  'kotlin.collections',
+);
+export const map: KtGenericReferenceFactory<2> = ktReference.genericFactory<2>('Map', 'kotlin.collections');
+export const mutableMap: KtGenericReferenceFactory<2> = ktReference.genericFactory<2>(
+  'MutableMap',
+  'kotlin.collections',
+);
+export const listOf: KtGenericReferenceFactory<1> = ktReference.genericFactory<1>('listOf', 'kotlin.collections');
+export const mutableListOf: KtGenericReferenceFactory<1> = ktReference.genericFactory<1>(
+  'mutableListOf',
+  'kotlin.collections',
+);
+export const mapOf: KtGenericReferenceFactory<2> = ktReference.genericFactory<2>('mapOf', 'kotlin.collections');
+export const mutableMapOf: KtGenericReferenceFactory<2> = ktReference.genericFactory<2>(
+  'mutableMapOf',
+  'kotlin.collections',
+);
+
+// kotlin.jvm
+export const jvmStatic: KtReferenceFactory = ktReference.factory('JvmStatic', 'kotlin.jvm');

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

@@ -0,0 +1,14 @@
+import { type KtGenericReferenceFactory, ktReference } from '../nodes/reference.js';
+
+// kotlinx.coroutines.reactive
+export const awaitFirst: KtGenericReferenceFactory<1> = ktReference.genericFactory(
+  'awaitFirst',
+  'kotlinx.coroutines.reactive',
+);
+export const awaitFirstOrNull: KtGenericReferenceFactory<1> = ktReference.genericFactory(
+  'awaitFirstOrNull',
+  'kotlinx.coroutines.reactive',
+);
+
+// kotlinx.coroutines.reactor
+export const mono: KtGenericReferenceFactory<1> = ktReference.genericFactory('mono', 'kotlinx.coroutines.reactor');

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

@@ -0,0 +1,5 @@
+import { ktReference, type KtReferenceFactory } from '../nodes/reference.js';
+
+// okhttp3
+export const okHttpClient: KtReferenceFactory = ktReference.factory('Factory', 'okhttp3.Call');
+export const httpUrl: KtReferenceFactory = ktReference.factory('HttpUrl', 'okhttp3');

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

@@ -0,0 +1,5 @@
+import { type KtGenericReferenceFactory, ktReference } from '../nodes/reference.js';
+
+// reactor.core.publisher
+export const flux: KtGenericReferenceFactory<1> = ktReference.genericFactory<1>('Flux', 'reactor.core.publisher');
+export const mono: KtGenericReferenceFactory<1> = ktReference.genericFactory<1>('Mono', 'reactor.core.publisher');

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

@@ -0,0 +1,37 @@
+import { type KtGenericReferenceFactory, ktReference, type KtReferenceFactory } from '../nodes/reference.js';
+
+// org.springframework.web.reactive.function
+export const bodyInserters: KtReferenceFactory = ktReference.factory(
+  'BodyInserters',
+  'org.springframework.web.reactive.function',
+);
+
+// org.springframework.web.reactive.function.client
+export const webClient: KtReferenceFactory = ktReference.factory(
+  'WebClient',
+  'org.springframework.web.reactive.function.client',
+);
+export const clientResponse: KtReferenceFactory = ktReference.factory(
+  'ClientResponse',
+  'org.springframework.web.reactive.function.client',
+);
+export const requestHeadersSpec: KtGenericReferenceFactory<1> = ktReference.genericFactory(
+  'RequestHeadersSpec',
+  'org.springframework.web.reactive.function.client.WebClient',
+);
+export const toEntity: KtGenericReferenceFactory<1> = ktReference.genericFactory(
+  'toEntity',
+  'org.springframework.web.reactive.function.client',
+);
+export const awaitBody: KtGenericReferenceFactory<1> = ktReference.genericFactory(
+  'awaitBody',
+  'org.springframework.web.reactive.function.client',
+);
+export const awaitBodilessEntity: KtReferenceFactory = ktReference.factory(
+  'awaitBodilessEntity',
+  'org.springframework.web.reactive.function.client',
+);
+export const awaitExchange: KtReferenceFactory = ktReference.factory(
+  'awaitExchange',
+  'org.springframework.web.reactive.function.client',
+);

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

@@ -0,0 +1,86 @@
+import { type KtGenericReferenceFactory, ktReference, type KtReferenceFactory } from '../nodes/reference.js';
+
+// org.springframework.beans.factory.annotation
+export const autowired: KtReferenceFactory = ktReference.factory(
+  'Autowired',
+  'org.springframework.beans.factory.annotation',
+);
+
+// org.springframework.http
+export const httpStatus: KtReferenceFactory = ktReference.factory('HttpStatus', 'org.springframework.http');
+export const httpMethod: KtReferenceFactory = ktReference.factory('HttpMethod', 'org.springframework.http');
+export const responseEntity: KtGenericReferenceFactory<1> = ktReference.genericFactory<1>(
+  'ResponseEntity',
+  'org.springframework.http',
+);
+export const mediaType: KtReferenceFactory = ktReference.factory('MediaType', 'org.springframework.http');
+
+// org.springframework.http.client
+export const multipartBodyBuilder: KtReferenceFactory = ktReference.factory(
+  'MultipartBodyBuilder',
+  'org.springframework.http.client',
+);
+
+// org.springframework.http.codec.multipart
+export const filePart: KtReferenceFactory = ktReference.factory('FilePart', 'org.springframework.http.codec.multipart');
+
+// org.springframework.stereotype
+export const controller: KtReferenceFactory = ktReference.factory('Controller', 'org.springframework.stereotype');
+
+// org.springframework.util
+export const multiValueMap: KtGenericReferenceFactory<2> = ktReference.genericFactory<2>(
+  'MultiValueMap',
+  'org.springframework.util',
+);
+export const linkedMultiValueMap: KtGenericReferenceFactory<2> = ktReference.genericFactory<2>(
+  'LinkedMultiValueMap',
+  'org.springframework.util',
+);
+
+// org.springframework.validation.annotation
+export const validated: KtReferenceFactory = ktReference.factory(
+  'Validated',
+  'org.springframework.validation.annotation',
+);
+
+// org.springframework.web.bind.annotation
+export const pathVariable: KtReferenceFactory = ktReference.factory(
+  'PathVariable',
+  'org.springframework.web.bind.annotation',
+);
+export const requestBody: KtReferenceFactory = ktReference.factory(
+  'RequestBody',
+  'org.springframework.web.bind.annotation',
+);
+export const requestMapping: KtReferenceFactory = ktReference.factory(
+  'RequestMapping',
+  'org.springframework.web.bind.annotation',
+);
+export const requestMethod: KtReferenceFactory = ktReference.factory(
+  'RequestMethod',
+  'org.springframework.web.bind.annotation',
+);
+export const requestParam: KtReferenceFactory = ktReference.factory(
+  'RequestParam',
+  'org.springframework.web.bind.annotation',
+);
+export const requestPart: KtReferenceFactory = ktReference.factory(
+  'RequestPart',
+  'org.springframework.web.bind.annotation',
+);
+export const requestHeader: KtReferenceFactory = ktReference.factory(
+  'RequestHeader',
+  'org.springframework.web.bind.annotation',
+);
+
+// org.springframework.web.context.request
+export const nativeWebRequest: KtReferenceFactory = ktReference.factory(
+  'NativeWebRequest',
+  'org.springframework.web.context.request',
+);
+
+// org.springframework.web.util
+export const uriComponentsBuilder: KtReferenceFactory = ktReference.factory(
+  'UriComponentsBuilder',
+  'org.springframework.web.util',
+);

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

@@ -0,0 +1,23 @@
+import { ktReference, type KtReferenceFactory } from '../nodes/reference.js';
+
+// io.swagger.v3.oas.annotations
+export const parameter: KtReferenceFactory = ktReference.factory('Parameter', 'io.swagger.v3.oas.annotations');
+export const operation: KtReferenceFactory = ktReference.factory('Operation', 'io.swagger.v3.oas.annotations');
+
+// io.swagger.v3.oas.annotations.media
+export const schema: KtReferenceFactory = ktReference.factory('Schema', 'io.swagger.v3.oas.annotations.media');
+export const arraySchema: KtReferenceFactory = ktReference.factory(
+  'ArraySchema',
+  'io.swagger.v3.oas.annotations.media',
+);
+export const content: KtReferenceFactory = ktReference.factory('Content', 'io.swagger.v3.oas.annotations.media');
+
+// io.swagger.v3.oas.annotations.responses
+export const apiResponse: KtReferenceFactory = ktReference.factory(
+  'ApiResponse',
+  'io.swagger.v3.oas.annotations.responses',
+);
+export const apiResponses: KtReferenceFactory = ktReference.factory(
+  'ApiResponses',
+  'io.swagger.v3.oas.annotations.responses',
+);

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

@@ -0,0 +1,19 @@
+import { defaultOpenApiGeneratorConfig, type SourceBuilder } from '@goast/core';
+
+import { defaultKotlinGeneratorConfig, type KotlinGeneratorConfig } from '../../config.js';
+import { KotlinFileBuilder } from '../../file-builder.js';
+
+const ktConfigSymbol = Symbol();
+type _BuilderWithConfig = SourceBuilder & { [ktConfigSymbol]?: KotlinGeneratorConfig };
+
+export function getKotlinBuilderOptions(builder: SourceBuilder): KotlinGeneratorConfig {
+  if (builder instanceof KotlinFileBuilder) {
+    return builder.options;
+  }
+  if (ktConfigSymbol in builder.options) {
+    return builder.options[ktConfigSymbol] as KotlinGeneratorConfig;
+  }
+  const options = { ...defaultOpenApiGeneratorConfig, ...defaultKotlinGeneratorConfig, ...builder.options };
+  (builder as _BuilderWithConfig)[ktConfigSymbol] = options;
+  return options;
+}

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

@@ -0,0 +1,31 @@
+import type { BasicAppendValue, SourceBuilder } from '@goast/core';
+
+import { type KtCall, ktCall } from '../nodes/call.js';
+import { type KtString, ktString } from '../nodes/string.js';
+import { listOf, mapOf } from '../references/index.js';
+
+export function toKtNode<TBuilder extends SourceBuilder>(object: Record<string | number, unknown>): KtCall<TBuilder>;
+export function toKtNode<TBuilder extends SourceBuilder>(list: unknown[]): KtCall<TBuilder>;
+export function toKtNode<TBuilder extends SourceBuilder>(string: string): KtString<TBuilder>;
+export function toKtNode<TBuilder extends SourceBuilder>(value: unknown): BasicAppendValue<TBuilder>;
+export function toKtNode<TBuilder extends SourceBuilder>(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return ktCall(
+      [listOf.infer()],
+      value.map((x) => toKtNode<TBuilder>(x)),
+    );
+  }
+  if (typeof value === 'object' && value !== null) {
+    return ktCall(
+      [mapOf.infer()],
+      Object.entries(value).map(([k, v]) => ktCall([toKtNode(k), 'to'], [toKtNode(v)])),
+    );
+  }
+  if (value === null || value === undefined) {
+    return 'null';
+  }
+  if (typeof value === 'boolean' || typeof value === 'number') {
+    return String(value);
+  }
+  return ktString(String(value));
+}

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

@@ -0,0 +1,15 @@
+import { notNullish, type Nullable, type SingleOrMultiple, type SourceBuilder, toArray } from '@goast/core';
+
+import { type KtAppendValue, writeKtNode } from './write-kt-node.js';
+
+export function writeKtAnnotations<TBuilder extends SourceBuilder>(
+  builder: TBuilder,
+  nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>,
+  options?: { multiline: boolean },
+) {
+  const filteredNodes = toArray(nodes).filter(notNullish);
+  builder.forEach(filteredNodes, (b, a) => {
+    writeKtNode(b, a);
+    b.append(options?.multiline ? '\n' : ' ');
+  });
+}

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

@@ -0,0 +1,45 @@
+import { notNullish, type Nullable, type SingleOrMultiple, type SourceBuilder, toArray } from '@goast/core';
+
+import { KtLambda } from '../nodes/lambda.js';
+import { type KtAppendValue, writeKtNode, writeKtNodes } from './write-kt-node.js';
+
+export function writeKtArguments<TBuilder extends SourceBuilder>(
+  builder: TBuilder,
+  nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>,
+) {
+  const filteredNodes = toArray(nodes).filter(notNullish);
+
+  if (filteredNodes.length === 0) {
+    builder.append('()');
+    return;
+  }
+
+  const lastNode = filteredNodes[filteredNodes.length - 1];
+  let lambda: KtAppendValue<TBuilder> | null = null;
+  if (lastNode instanceof KtLambda) {
+    lambda = lastNode;
+    filteredNodes.pop();
+  } else if (
+    typeof lastNode === 'object' &&
+    (!('name' in lastNode) || !lastNode.name) &&
+    'value' in lastNode &&
+    lastNode.value instanceof KtLambda
+  ) {
+    lambda = lastNode.value;
+    filteredNodes.pop();
+  }
+
+  const multiline = filteredNodes.length > 3;
+
+  builder.parenthesizeIf(
+    filteredNodes.length > 0,
+    '()',
+    (b) => writeKtNodes(b, filteredNodes, { separator: multiline ? ',\n' : ', ' }),
+    { multiline },
+  );
+
+  if (lambda) {
+    builder.append(' ');
+    writeKtNode(builder, lambda);
+  }
+}

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

@@ -0,0 +1,27 @@
+import { notNullish, type Nullable, type SingleOrMultiple, type SourceBuilder, toArray } from '@goast/core';
+
+import { type KtAppendValue, writeKtNode } from './write-kt-node.js';
+
+export function writeKtEnumValues<TBuilder extends SourceBuilder>(
+  builder: TBuilder,
+  nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>,
+) {
+  const filteredNodes = toArray(nodes).filter(notNullish);
+  const spacing = filteredNodes.some(
+    (v) =>
+      typeof v === 'object' &&
+      (('annotations' in v && Array.isArray(v.annotations) && v.annotations.length > 0) ||
+        ('doc' in v && v.doc) ||
+        ('members' in v && Array.isArray(v.members) && v.members.some(notNullish))),
+  );
+  const multiline = spacing ||
+    filteredNodes.length > 4 ||
+    filteredNodes.some(
+      (v) => typeof v === 'object' && 'arguments' in v && Array.isArray(v.arguments) && v.arguments.length > 0,
+    );
+  builder.forEach(
+    filteredNodes,
+    (b, v, i) => b.if(spacing && i > 0, (b) => b.ensurePreviousLineEmpty()).append((b) => writeKtNode(b, v)),
+    { separator: multiline ? ',\n' : ', ' },
+  );
+}

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

@@ -0,0 +1,12 @@
+import { notNullish, type Nullable, type SingleOrMultiple, type SourceBuilder, toArray } from '@goast/core';
+
+import { type KtAppendValue, writeKtNode } from './write-kt-node.js';
+
+export function writeKtGenericParameters<TBuilder extends SourceBuilder>(
+  builder: TBuilder,
+  nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>,
+) {
+  const filteredNodes = toArray(nodes).filter(notNullish);
+  if (filteredNodes.length === 0) return;
+  builder.parenthesize('<>', (b) => b.forEach(filteredNodes, writeKtNode, { separator: ', ' }));
+}

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

@@ -0,0 +1,25 @@
+import { isAppendValue, isAppendValueGroup, notNullish, type Nullable, type SourceBuilder } from '@goast/core';
+
+import { KtProperty } from '../nodes/property.js';
+import { type KtAppendValue, writeKtNode } from './write-kt-node.js';
+
+export function writeKtMembers<TBuilder extends SourceBuilder>(
+  builder: TBuilder,
+  members: Nullable<KtAppendValue<TBuilder>>[],
+  options?: { alreadyHasMembers?: boolean },
+): void {
+  const filteredMembers = members.filter(notNullish);
+  builder.forEach(filteredMembers, (b, m, i) =>
+    b.if(
+      () =>
+        !(m instanceof KtProperty && !m.doc && m.annotations.length === 0) &&
+        !isAppendValue(m) &&
+        !isAppendValueGroup(m),
+      (b) =>
+        b
+          .if(i > 0 || !!options?.alreadyHasMembers, (b) => b.ensurePreviousLineEmpty())
+          .append((b) => writeKtNode(b, m))
+          .if(i < filteredMembers.length - 1, (b) => b.ensurePreviousLineEmpty()),
+      (b) => b.append((b) => writeKtNode(b, m)).ensureCurrentLineEmpty(),
+    ));
+}

package/src/src/ast/utils/write-kt-node.ts

@@ -0,0 +1,37 @@
+import {
+  type AppendValue,
+  notNullish,
+  type Nullable,
+  type Separator,
+  type SingleOrMultiple,
+  type SourceBuilder,
+  toArray,
+} from '@goast/core';
+
+import { KtNode } from '../node.js';
+
+export type KtAppendValue<TBuilder extends SourceBuilder> = AppendValue<TBuilder> | KtNode<TBuilder>;
+
+export function writeKtNode<TBuilder extends SourceBuilder>(
+  builder: TBuilder,
+  node: Nullable<KtAppendValue<TBuilder>>,
+): void {
+  if (node instanceof KtNode) {
+    node.write(builder);
+  } else {
+    builder.append(node);
+  }
+}
+
+export function writeKtNodes<TBuilder extends SourceBuilder>(
+  builder: TBuilder,
+  nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>,
+  options?: { separator?: Separator<TBuilder, KtAppendValue<TBuilder>> },
+): void {
+  const filteredNodes = toArray(nodes).filter(notNullish);
+  if (filteredNodes.length === 1) {
+    writeKtNode(builder, filteredNodes[0]);
+  } else if (filteredNodes.length > 1) {
+    builder.forEach(filteredNodes, writeKtNode, { separator: options?.separator });
+  }
+}

package/src/src/ast/utils/write-kt-parameters.ts

@@ -0,0 +1,25 @@
+import { notNullish, type Nullable, type SingleOrMultiple, type SourceBuilder, toArray } from '@goast/core';
+
+import { type KtAppendValue, writeKtNode } from './write-kt-node.js';
+
+export function writeKtParameters<TBuilder extends SourceBuilder>(
+  builder: TBuilder,
+  nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>,
+) {
+  const filteredNodes = toArray(nodes).filter(notNullish);
+  const hasAnnotations = filteredNodes.some(
+    (p) => typeof p === 'object' && 'annotations' in p && Array.isArray(p.annotations) && p.annotations.length > 0,
+  );
+  const multiline = filteredNodes.length > 2 || hasAnnotations;
+  const spacing = multiline && hasAnnotations;
+  builder.parenthesize(
+    '()',
+    (b) =>
+      b.forEach(
+        filteredNodes,
+        (b, p, i) => b.if(i > 0 && spacing, (b) => b.ensurePreviousLineEmpty()).append((b) => writeKtNode(b, p)),
+        { separator: multiline ? ',\n' : ', ' },
+      ),
+    { multiline },
+  );
+}

package/src/src/common-results.ts

@@ -0,0 +1,4 @@
+export type KotlinImport = {
+  packageName?: string;
+  typeName: string;
+};

package/src/src/config.ts

@@ -0,0 +1,61 @@
+import type {
+  DefaultGenerationProviderConfig,
+  OpenApiGeneratorConfig,
+  StringCasing,
+  StringCasingWithOptions,
+} from '@goast/core';
+
+/** The Spring Boot major version the Kotlin generators target. */
+export type SpringBootVersion = 3 | 4;
+
+export type KotlinGeneratorConfig = OpenApiGeneratorConfig & {
+  typeNameCasing: StringCasing | StringCasingWithOptions;
+  parameterNameCasing: StringCasing | StringCasingWithOptions;
+  functionNameCasing: StringCasing | StringCasingWithOptions;
+  propertyNameCasing: StringCasing | StringCasingWithOptions;
+  enumValueNameCasing: StringCasing | StringCasingWithOptions;
+  constantNameCasing: StringCasing | StringCasingWithOptions;
+
+  globalImports: string[];
+
+  /**
+   * Whether to include the source OpenAPI document path in the generated documentation comments.
+   * @default false
+   */
+  includeSourceInDocs: boolean;
+
+  /**
+   * The targeted Spring Boot major version. Controls Jackson package names, Kotlin generic bounds, and
+   * `ResponseEntity` nullability so the generated code compiles against the matching framework generation.
+   * - `3`: Spring Boot 3 (Spring Framework 6 / Jackson 2). Produces output identical to previous versions.
+   * - `4`: Spring Boot 4 (Spring Framework 7 / Jackson 3 / JSpecify null-safety).
+   * @default 3
+   */
+  springBootVersion: SpringBootVersion;
+};
+
+export const defaultKotlinGeneratorConfig: DefaultGenerationProviderConfig<KotlinGeneratorConfig> = {
+  indent: { type: 'spaces', count: 4 },
+
+  typeNameCasing: 'pascal',
+  parameterNameCasing: 'camel',
+  functionNameCasing: 'camel',
+  propertyNameCasing: 'camel',
+  enumValueNameCasing: 'snake',
+  constantNameCasing: 'snake',
+
+  globalImports: [
+    'kotlin.*',
+    'kotlin.annotation.*',
+    'kotlin.collections.*',
+    'kotlin.comparisons.*',
+    'kotlin.io.*',
+    'kotlin.ranges.*',
+    'kotlin.sequences.*',
+    'kotlin.text.*',
+    'java.lang.*',
+    'kotlin.jvm.*',
+  ],
+  includeSourceInDocs: false,
+  springBootVersion: 3,
+};

package/src/src/file-builder.ts

@@ -0,0 +1,112 @@
+import { type AppendParam, type AppendValue, isAppendValue, SourceBuilder, writeGeneratedFile } from '@goast/core';
+
+import { KtNode } from './ast/node.js';
+import { defaultKotlinGeneratorConfig, type KotlinGeneratorConfig } from './config.js';
+import { ImportCollection } from './import-collection.js';
+
+type AnnotationArgumentValue<T extends SourceBuilder> = string | ((builder: T) => void);
+type AnnotationArgument<T extends SourceBuilder> =
+  | AnnotationArgumentValue<T>
+  | [key: string, value: AnnotationArgumentValue<T>]
+  | [value: AnnotationArgumentValue<T>, condition: boolean]
+  | [key: string, value: AnnotationArgumentValue<T>, condition: boolean];
+
+export type KotlinAppends<TAdditionalAppends> = KtNode<KotlinFileBuilder> | TAdditionalAppends;
+export type KotlinAppendParam<TBuilder extends KotlinFileBuilder, TAdditionalAppends> = AppendParam<
+  TBuilder,
+  KotlinAppends<TAdditionalAppends>
+>;
+
+export function isKotlinAppendValue<TBuilder extends KotlinFileBuilder>(
+  value: unknown,
+): value is AppendValue<TBuilder> {
+  return isAppendValue(value) || value instanceof KtNode;
+}
+
+export class KotlinFileBuilder<TAdditionalAppends = never> extends SourceBuilder<KotlinAppends<TAdditionalAppends>> {
+  public readonly packageName: string | undefined;
+  public readonly imports: ImportCollection = new ImportCollection();
+
+  public override get options(): KotlinGeneratorConfig {
+    return super.options as KotlinGeneratorConfig;
+  }
+
+  constructor(packageName?: string, options?: KotlinGeneratorConfig) {
+    super(options ?? defaultKotlinGeneratorConfig);
+    this.packageName = packageName;
+  }
+
+  public addImport(name: string, packageName?: string): this {
+    if (packageName !== undefined && packageName !== this.packageName) {
+      this.imports.addImport(name, packageName);
+    }
+    return this;
+  }
+
+  public appendAnnotation(name: string, packageName?: string, args?: AnnotationArgument<this>[]): this {
+    const allArgs: [key: string | undefined, value: AnnotationArgumentValue<this>][] = [];
+    if (args) {
+      for (const a of args) {
+        if (!Array.isArray(a)) {
+          allArgs.push([undefined, a]);
+        } else if (a.length === 2 && a[1] === true) {
+          allArgs.push([undefined, a[0]]);
+        }
+      }
+      for (const a of args) {
+        if (Array.isArray(a) && typeof a[1] !== 'boolean' && a[2] !== false) {
+          allArgs.push(a.length === 2 ? a : [a[0], a[1]]);
+        }
+      }
+    }
+
+    this.append(`@${name}`).addImport(name, packageName);
+
+    if (allArgs.length > 0) {
+      const multiline = allArgs.some((x) => typeof x[1] !== 'string') ||
+        allArgs.reduce((c, [key, value]) => c + (key ? key.length + 3 : 0) + (value?.length ?? 0), 0) > 80;
+      this.parenthesize('()', (builder) =>
+        builder
+          .appendLineIf(multiline)
+          .forEach(
+            allArgs,
+            (builder, [name, value]) =>
+              builder
+                .append(name ? `${name} = ` : '')
+                .append((builder) => (typeof value === 'string' ? builder.append(value) : value(builder))),
+            { separator: multiline ? ',\n' : ', ' },
+          )
+          .appendLineIf(multiline));
+    }
+
+    this.appendLine();
+
+    return this;
+  }
+
+  public override clear(): void {
+    super.clear();
+    this.imports.clear();
+  }
+
+  public override toString(addPadding: boolean = true): string {
+    return new SourceBuilder(this.options)
+      .if(this.packageName !== undefined, (builder) => builder.appendLine(`package ${this.packageName}`).appendLine())
+      .append((builder) => this.imports.writeTo(builder))
+      .if(addPadding, (builder) => builder.ensurePreviousLineEmpty())
+      .append(super.toString())
+      .if(addPadding, (builder) => builder.ensureCurrentLineEmpty())
+      .toString();
+  }
+
+  public writeToFile(filePath: string) {
+    writeGeneratedFile(this.options, filePath, this.toString());
+  }
+
+  protected override appendSingle(value: KotlinAppendParam<this, TAdditionalAppends>): void {
+    super.appendSingle(value);
+    if (value instanceof KtNode) {
+      value.write(this);
+    }
+  }
+}