@goast/kotlin 0.5.9-beta.1 → 0.5.9

package/src/src/ast/references/jackson.ts

@@ -0,0 +1,44 @@
+import { ktReference, type KtReferenceFactory } from '../nodes/reference.js';
+
+// com.fasterxml.jackson.annotation
+export const jsonTypeInfo: KtReferenceFactory = ktReference.factory('JsonTypeInfo', 'com.fasterxml.jackson.annotation');
+export const jsonSubTypes: KtReferenceFactory = ktReference.factory('JsonSubTypes', 'com.fasterxml.jackson.annotation');
+export const jsonClassDescription: KtReferenceFactory = ktReference.factory(
+  'JsonClassDescription',
+  'com.fasterxml.jackson.annotation',
+);
+export const jsonProperty: KtReferenceFactory = ktReference.factory('JsonProperty', 'com.fasterxml.jackson.annotation');
+export const jsonPropertyDescription: KtReferenceFactory = ktReference.factory(
+  'JsonPropertyDescription',
+  'com.fasterxml.jackson.annotation',
+);
+export const jsonInclude: KtReferenceFactory = ktReference.factory('JsonInclude', 'com.fasterxml.jackson.annotation');
+export const jsonIgnore: KtReferenceFactory = ktReference.factory('JsonIgnore', 'com.fasterxml.jackson.annotation');
+export const jsonAnySetter: KtReferenceFactory = ktReference.factory(
+  'JsonAnySetter',
+  'com.fasterxml.jackson.annotation',
+);
+export const jsonAnyGetter: KtReferenceFactory = ktReference.factory(
+  'JsonAnyGetter',
+  'com.fasterxml.jackson.annotation',
+);
+
+// com.fasterxml.jackson.databind
+export const objectMapper: KtReferenceFactory = ktReference.factory(
+  'ObjectMapper',
+  'com.fasterxml.jackson.databind',
+);
+export const serializationFeature: KtReferenceFactory = ktReference.factory(
+  'SerializationFeature',
+  'com.fasterxml.jackson.databind',
+);
+export const deserializationFeature: KtReferenceFactory = ktReference.factory(
+  'DeserializationFeature',
+  'com.fasterxml.jackson.databind',
+);
+
+// com.fasterxml.jackson.module.kotlin
+export const jacksonObjectMapper: KtReferenceFactory = ktReference.factory(
+  'jacksonObjectMapper',
+  'com.fasterxml.jackson.module.kotlin',
+);

package/src/src/ast/references/jakarta.ts

@@ -0,0 +1,14 @@
+import { ktReference, type KtReferenceFactory } from '../nodes/reference.js';
+
+// jakarta.annotation
+export const generated: KtReferenceFactory = ktReference.factory('Generated', 'jakarta.annotation');
+
+// jakarta.validation
+export const valid: KtReferenceFactory = ktReference.factory('Valid', 'jakarta.validation');
+
+// jakarta.validation.constraints
+export const pattern: KtReferenceFactory = ktReference.factory('Pattern', 'jakarta.validation.constraints');
+export const min: KtReferenceFactory = ktReference.factory('Min', 'jakarta.validation.constraints');
+export const max: KtReferenceFactory = ktReference.factory('Max', 'jakarta.validation.constraints');
+export const notEmpty: KtReferenceFactory = ktReference.factory('NotEmpty', 'jakarta.validation.constraints');
+export const size: KtReferenceFactory = ktReference.factory('Size', 'jakarta.validation.constraints');

package/src/src/ast/references/java.ts

@@ -0,0 +1,27 @@
+import { type KtGenericReferenceFactory, ktReference, type KtReferenceFactory } from '../nodes/reference.js';
+
+// java.io
+export const file: KtReferenceFactory = ktReference.factory('File', 'java.io');
+export const ioException: KtReferenceFactory = ktReference.factory('IOException', 'java.io');
+
+// java.lang
+export const illegalStateException: KtReferenceFactory = ktReference.factory('IllegalStateException', 'java.lang');
+export const system: KtReferenceFactory = ktReference.factory('System', 'java.lang');
+export const unsupportedOperationException: KtReferenceFactory = ktReference.factory(
+  'UnsupportedOperationException',
+  'java.lang',
+);
+export const void_: KtReferenceFactory = ktReference.factory('Void', 'java.lang');
+
+// java.net
+export const uri: KtReferenceFactory = ktReference.factory('URI', 'java.net');
+
+// java.time
+export const offsetDateTime: KtReferenceFactory = ktReference.factory('OffsetDateTime', 'java.time');
+export const offsetTime: KtReferenceFactory = ktReference.factory('OffsetTime', 'java.time');
+export const localDateTime: KtReferenceFactory = ktReference.factory('LocalDateTime', 'java.time');
+export const localDate: KtReferenceFactory = ktReference.factory('LocalDate', 'java.time');
+export const localTime: KtReferenceFactory = ktReference.factory('LocalTime', 'java.time');
+
+// java.util
+export const optional: KtGenericReferenceFactory<1> = ktReference.genericFactory<1>('Optional', 'java.util');

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,33 @@
+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',
+);

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,48 @@
+import type {
+  DefaultGenerationProviderConfig,
+  OpenApiGeneratorConfig,
+  StringCasing,
+  StringCasingWithOptions,
+} from '@goast/core';
+
+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;
+};
+
+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,
+};