@goast/kotlin 0.7.0 → 0.7.1

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

@@ -1,6 +1,22 @@
 import { isAppendValue, isAppendValueGroup, notNullish } from '@goast/core';
 import { KtProperty } from '../nodes/property.js';
 import { writeKtNode } from './write-kt-node.js';
+/**
+ * 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 function writeKtMembers(builder, members, options) {
     const filteredMembers = members.filter(notNullish);
     builder.forEach(filteredMembers, (b, m, i) => b.if(() => !(m instanceof KtProperty && !m.doc && m.annotations.length === 0) &&

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

@@ -1,7 +1,36 @@
 import { type AppendValue, type Nullable, type Separator, type SingleOrMultiple, type SourceBuilder } from '@goast/core';
 import { KtNode } from '../node.ts';
+/**
+ * A value that the Kotlin writers accept: a plain append value, which is appended as is, or a `KtNode`, which writes
+ * itself.
+ * @template TBuilder The type of the source builder the value is written to.
+ */
 export type KtAppendValue<TBuilder extends SourceBuilder> = AppendValue<TBuilder> | KtNode<TBuilder>;
+/**
+ * Writes one Kotlin node or append value to the builder.
+ *
+ * A `KtNode` writes itself. Any other value is appended as is, so nullish values write nothing. No separators, line
+ * breaks or blank lines are added.
+ *
+ * @template TBuilder The type of the source builder the node is written to.
+ * @param builder The builder to write to.
+ * @param node The node or append value to write. Nullish values write nothing.
+ */
 export declare function writeKtNode<TBuilder extends SourceBuilder>(builder: TBuilder, node: Nullable<KtAppendValue<TBuilder>>): void;
+/**
+ * Writes one or more Kotlin nodes or append values to the builder, ignoring nullish entries.
+ *
+ * After nullish entries are removed, a single entry is written as is, and several entries are written one after
+ * another.
+ * Between two entries the `separator` option is written: a string is appended as is, and a callback appends its own
+ * content. Without a separator, the entries are written back to back. No entries write nothing. No line breaks or blank
+ * lines are added by this function.
+ *
+ * @template TBuilder The type of the source builder the nodes are written to.
+ * @param builder The builder to write to.
+ * @param nodes A single node or an array of nodes. Nullish entries are ignored.
+ * @param options Options for writing. `separator` is written between each pair of consecutive entries.
+ */
 export declare function writeKtNodes<TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>, options?: {
     separator?: Separator<TBuilder, KtAppendValue<TBuilder>>;
 }): void;

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

@@ -1,5 +1,15 @@
 import { notNullish, toArray, } from '@goast/core';
 import { KtNode } from '../node.js';
+/**
+ * Writes one Kotlin node or append value to the builder.
+ *
+ * A `KtNode` writes itself. Any other value is appended as is, so nullish values write nothing. No separators, line
+ * breaks or blank lines are added.
+ *
+ * @template TBuilder The type of the source builder the node is written to.
+ * @param builder The builder to write to.
+ * @param node The node or append value to write. Nullish values write nothing.
+ */
 export function writeKtNode(builder, node) {
     if (node instanceof KtNode) {
         node.write(builder);
@@ -8,6 +18,20 @@ export function writeKtNode(builder, node) {
         builder.append(node);
     }
 }
+/**
+ * Writes one or more Kotlin nodes or append values to the builder, ignoring nullish entries.
+ *
+ * After nullish entries are removed, a single entry is written as is, and several entries are written one after
+ * another.
+ * Between two entries the `separator` option is written: a string is appended as is, and a callback appends its own
+ * content. Without a separator, the entries are written back to back. No entries write nothing. No line breaks or blank
+ * lines are added by this function.
+ *
+ * @template TBuilder The type of the source builder the nodes are written to.
+ * @param builder The builder to write to.
+ * @param nodes A single node or an array of nodes. Nullish entries are ignored.
+ * @param options Options for writing. `separator` is written between each pair of consecutive entries.
+ */
 export function writeKtNodes(builder, nodes, options) {
     const filteredNodes = toArray(nodes).filter(notNullish);
     if (filteredNodes.length === 1) {

package/dist/src/ast/utils/write-kt-parameters.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 a parenthesized parameter list, such as the parameters of a function or constructor.
+ *
+ * The list is multiline when there are more than two parameters or when any parameter has annotations. A multiline list
+ * puts the opening and closing parentheses on their own lines, indents the parameters and writes each one on its own
+ * line, separated by `,` and a line break. When any parameter has annotations, a blank line is also written between
+ * each pair of parameters. Otherwise the parameters are written inline, separated by `, `. An empty list is written
+ * as `()`. No trailing comma is written.
+ *
+ * @template TBuilder The type of the source builder the parameters are written to.
+ * @param builder The builder to write to.
+ * @param nodes The parameters, as a single node or an array. Nullish entries are ignored.
+ */
 export declare function writeKtParameters<TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>): void;

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

@@ -1,5 +1,18 @@
 import { notNullish, toArray } from '@goast/core';
 import { writeKtNode } from './write-kt-node.js';
+/**
+ * Writes a parenthesized parameter list, such as the parameters of a function or constructor.
+ *
+ * The list is multiline when there are more than two parameters or when any parameter has annotations. A multiline list
+ * puts the opening and closing parentheses on their own lines, indents the parameters and writes each one on its own
+ * line, separated by `,` and a line break. When any parameter has annotations, a blank line is also written between
+ * each pair of parameters. Otherwise the parameters are written inline, separated by `, `. An empty list is written
+ * as `()`. No trailing comma is written.
+ *
+ * @template TBuilder The type of the source builder the parameters are written to.
+ * @param builder The builder to write to.
+ * @param nodes The parameters, as a single node or an array. Nullish entries are ignored.
+ */
 export function writeKtParameters(builder, nodes) {
     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);

package/dist/src/common-results.d.ts

@@ -1,4 +1,13 @@
+/**
+ * Describes a type that a generated Kotlin file imports.
+ */
 export type KotlinImport = {
+    /**
+     * The package the type is declared in, such as `kotlin.collections`. Without a package, no import is written.
+     */
     packageName?: string;
+    /**
+     * The name of the type to import from the package, such as `List`.
+     */
     typeName: string;
 };

package/dist/src/config.d.ts

@@ -1,13 +1,80 @@
 import type { DefaultGenerationProviderConfig, OpenApiGeneratorConfig, StringCasing, StringCasingWithOptions } from '@goast/core';
 /** The Spring Boot major version the Kotlin generators target. */
 export type SpringBootVersion = 3 | 4;
+/**
+ * The configuration that all Kotlin generators share. It extends the core `OpenApiGeneratorConfig` with the casing
+ * rules for generated names, the imports that are left out of generated files, and the targeted Spring Boot version.
+ * @see defaultKotlinGeneratorConfig
+ */
 export type KotlinGeneratorConfig = OpenApiGeneratorConfig & {
+    /**
+     * The casing applied to type names, such as model classes, enums and the types of generated services. It also
+     * determines the file names of models, since each model file is named after its type.
+     * @default 'pascal'
+     * @see StringCasingWithOptions
+     */
     typeNameCasing: StringCasing | StringCasingWithOptions;
+    /**
+     * The casing applied to parameter names. Service generators use it for the parameters of endpoint functions, and the
+     * models generator uses it for the parameters of the generated `set` function for `additionalProperties`.
+     * @default 'camel'
+     */
     parameterNameCasing: StringCasing | StringCasingWithOptions;
+    /**
+     * The casing applied to function names. Service generators use it for the endpoint functions, and the models
+     * generator uses it for the generated `set` and `getMap` functions for `additionalProperties`.
+     * @default 'camel'
+     */
     functionNameCasing: StringCasing | StringCasingWithOptions;
+    /**
+     * The casing applied to property names. The models generator uses it for the properties of models, the `value`
+     * property of enums and the `additionalProperties` property.
+     * @default 'camel'
+     */
     propertyNameCasing: StringCasing | StringCasingWithOptions;
+    /**
+     * The casing applied to the names of enum constants. With the default casing, the value `available` becomes
+     * `AVAILABLE`, because `snake` writes words in upper case unless `wordCasing` is given.
+     * @default 'snake'
+     * @example
+     * ```ts
+     * enumValueNameCasing: 'snake'; // 'pending review' => 'PENDING_REVIEW'
+     * enumValueNameCasing: { casing: 'snake', wordCasing: 'all-lower' }; // 'pending review' => 'pending_review'
+     * ```
+     */
     enumValueNameCasing: StringCasing | StringCasingWithOptions;
+    /**
+     * The casing applied to constant names. The models generator does not write constants, and the spring-controller
+     * generator uses it for the path constants of endpoints.
+     * @default 'snake'
+     */
     constantNameCasing: StringCasing | StringCasingWithOptions;
+    /**
+     * The imports that are left out of generated files, because Kotlin already imports these packages implicitly. An
+     * entry ending in `.*` excludes a whole package, but not its subpackages. Any other entry excludes one type by its
+     * fully qualified name, such as `com.example.Shared`.
+     * @default
+     * [
+     *   'kotlin.*',
+     *   'kotlin.annotation.*',
+     *   'kotlin.collections.*',
+     *   'kotlin.comparisons.*',
+     *   'kotlin.io.*',
+     *   'kotlin.ranges.*',
+     *   'kotlin.sequences.*',
+     *   'kotlin.text.*',
+     *   'java.lang.*',
+     *   'kotlin.jvm.*',
+     * ]
+     * @example
+     * ```ts
+     * // With globalImports: ['kotlin.*', 'kotlin.collections.*', 'com.example.Shared']
+     * // 'kotlin.String' is not imported, because the package 'kotlin' is excluded.
+     * // 'kotlin.collections.List' is not imported, because the package 'kotlin.collections' is excluded.
+     * // 'com.example.Shared' is not imported, because the type is excluded by its full name.
+     * // 'kotlin.time.Duration' is imported, because 'kotlin.*' does not exclude subpackages.
+     * ```
+     */
     globalImports: string[];
     /**
      * Whether to include the source OpenAPI document path in the generated documentation comments.
@@ -23,4 +90,9 @@ export type KotlinGeneratorConfig = OpenApiGeneratorConfig & {
      */
     springBootVersion: SpringBootVersion;
 };
+/**
+ * The default values of the Kotlin generator configuration. Each property's `@default` tag in `KotlinGeneratorConfig`
+ * gives the same value. `indent` is four spaces here, while the core default is two.
+ * @see KotlinGeneratorConfig
+ */
 export declare const defaultKotlinGeneratorConfig: DefaultGenerationProviderConfig<KotlinGeneratorConfig>;

package/dist/src/config.js

@@ -1,3 +1,8 @@
+/**
+ * The default values of the Kotlin generator configuration. Each property's `@default` tag in `KotlinGeneratorConfig`
+ * gives the same value. `indent` is four spaces here, while the core default is two.
+ * @see KotlinGeneratorConfig
+ */
 export const defaultKotlinGeneratorConfig = {
     indent: { type: 'spaces', count: 4 },
     typeNameCasing: 'pascal',

package/dist/src/file-builder.d.ts

@@ -4,18 +4,109 @@ import { type KotlinGeneratorConfig } from './config.ts';
 import { ImportCollection } from './import-collection.ts';
 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];
+/**
+ * The values that can be appended to a `KotlinFileBuilder`: Kotlin nodes, and the additional values of the builder.
+ * @template TAdditionalAppends The additional values, besides Kotlin nodes, that the builder accepts.
+ */
 export type KotlinAppends<TAdditionalAppends> = KtNode<KotlinFileBuilder> | TAdditionalAppends;
+/**
+ * A parameter of an append method of a `KotlinFileBuilder`: a single value or builder function, or an array of them.
+ * @template TBuilder The Kotlin file builder type that the value is appended to.
+ * @template TAdditionalAppends The additional values, besides Kotlin nodes, that the builder accepts.
+ * @see KotlinAppends
+ */
 export type KotlinAppendParam<TBuilder extends KotlinFileBuilder, TAdditionalAppends> = AppendParam<TBuilder, KotlinAppends<TAdditionalAppends>>;
+/**
+ * Checks whether a value can be appended to a Kotlin file builder: an append value, or a Kotlin node.
+ * @template TBuilder The Kotlin file builder type that the value is appended to.
+ * @param value The value to check.
+ * @returns `true` if the value can be appended, otherwise `false`.
+ */
 export declare function isKotlinAppendValue<TBuilder extends KotlinFileBuilder>(value: unknown): value is AppendValue<TBuilder>;
+/**
+ * Builds the source of one Kotlin file. Besides the code, it collects the imports that the code needs and writes them
+ * above the code, after the `package` line.
+ *
+ * Imports are collected while the code is written. A `KtReference` created by `ktReference` writes its name and then
+ * calls `addImport` on the builder. The builder ignores references to its own package and passes the others to its
+ * `ImportCollection`. `toString` then writes the `package` line, the import statements that the collection writes, and
+ * finally the code. Annotations written with `appendAnnotation` register their imports the same way.
+ *
+ * @template TAdditionalAppends The additional values, besides Kotlin nodes, that can be appended to the builder.
+ * @see ImportCollection
+ * @see ktReference
+ */
 export declare class KotlinFileBuilder<TAdditionalAppends = never> extends SourceBuilder<KotlinAppends<TAdditionalAppends>> {
+    /**
+     * The package the file is declared in, or `undefined` for a file without a package. References to this package do not
+     * produce imports.
+     */
     readonly packageName: string | undefined;
+    /**
+     * The imports of this file. The collection is created with its default options, so its `globalImports` is always the
+     * default list, whatever the configuration of this builder says.
+     */
     readonly imports: ImportCollection;
+    /**
+     * Gets the options of this builder, which are the Kotlin generator configuration that it was created with, or the
+     * defaults.
+     * @returns The options of this builder.
+     */
     get options(): KotlinGeneratorConfig;
+    /**
+     * Initializes a new instance of the KotlinFileBuilder class.
+     * @param packageName The package of the file, or `undefined` for a file without a package.
+     * @param options The Kotlin generator configuration to use. Defaults to `defaultKotlinGeneratorConfig`.
+     */
     constructor(packageName?: string, options?: KotlinGeneratorConfig);
+    /**
+     * Registers the import of a type that the file refers to. Nothing is registered when `packageName` is missing, or
+     * when it is the package of this file, because no import is needed there.
+     * @param name The name of the type, such as `List`.
+     * @param packageName The package the type is declared in, such as `kotlin.collections`.
+     * @returns A reference to this instance.
+     */
     addImport(name: string, packageName?: string): this;
+    /**
+     * Appends an annotation, such as `@JsonProperty("id")`, on a line of its own, and registers its import.
+     *
+     * Each entry of `args` is either a value, which is written as a positional argument, or one of these tuples:
+     * - `[value, condition]` writes the value as a positional argument when the condition is `true`.
+     * - `[key, value]` writes the named argument `key = value`.
+     * - `[key, value, condition]` writes the named argument unless the condition is `false`.
+     *
+     * The arguments are written on one line, or one per line when a value is a builder function or the arguments are
+     * long.
+     * @param name The simple name of the annotation, such as `JsonProperty`.
+     * @param packageName The package of the annotation. It is imported unless it is the package of this file.
+     * @param args The arguments of the annotation, in the forms described above.
+     * @returns A reference to this instance.
+     * @example
+     * ```ts
+     * builder.appendAnnotation('JsonProperty', 'com.fasterxml.jackson.annotation', [
+     *   '"id"',
+     *   ['required', 'true', isRequired],
+     * ]);
+     * // Emits: @JsonProperty("id", required = true)
+     * ```
+     */
     appendAnnotation(name: string, packageName?: string, args?: AnnotationArgument<this>[]): this;
+    /**
+     * Removes the code and all collected imports. The package name is kept.
+     */
     clear(): void;
+    /**
+     * Gets the source of the file: the `package` line, the import statements, and the code.
+     * @param addPadding Whether to separate the imports from the code with an empty line, and to end the source with a
+     * line break. Defaults to `true`.
+     * @returns The source of the file.
+     */
     toString(addPadding?: boolean): string;
+    /**
+     * Writes the source of the file to a path, creating missing parent directories. If the file already exists, the
+     * `existingFileBehavior` of the configuration decides what happens.
+     * @param filePath The path of the file to write.
+     */
     writeToFile(filePath: string): void;
     protected appendSingle(value: KotlinAppendParam<this, TAdditionalAppends>): void;
 }

package/dist/src/file-builder.js

@@ -2,25 +2,92 @@ import { isAppendValue, SourceBuilder, writeGeneratedFile } from '@goast/core';
 import { KtNode } from './ast/node.js';
 import { defaultKotlinGeneratorConfig } from './config.js';
 import { ImportCollection } from './import-collection.js';
+/**
+ * Checks whether a value can be appended to a Kotlin file builder: an append value, or a Kotlin node.
+ * @template TBuilder The Kotlin file builder type that the value is appended to.
+ * @param value The value to check.
+ * @returns `true` if the value can be appended, otherwise `false`.
+ */
 export function isKotlinAppendValue(value) {
     return isAppendValue(value) || value instanceof KtNode;
 }
+/**
+ * Builds the source of one Kotlin file. Besides the code, it collects the imports that the code needs and writes them
+ * above the code, after the `package` line.
+ *
+ * Imports are collected while the code is written. A `KtReference` created by `ktReference` writes its name and then
+ * calls `addImport` on the builder. The builder ignores references to its own package and passes the others to its
+ * `ImportCollection`. `toString` then writes the `package` line, the import statements that the collection writes, and
+ * finally the code. Annotations written with `appendAnnotation` register their imports the same way.
+ *
+ * @template TAdditionalAppends The additional values, besides Kotlin nodes, that can be appended to the builder.
+ * @see ImportCollection
+ * @see ktReference
+ */
 export class KotlinFileBuilder extends SourceBuilder {
+    /**
+     * The package the file is declared in, or `undefined` for a file without a package. References to this package do not
+     * produce imports.
+     */
     packageName;
+    /**
+     * The imports of this file. The collection is created with its default options, so its `globalImports` is always the
+     * default list, whatever the configuration of this builder says.
+     */
     imports = new ImportCollection();
+    /**
+     * Gets the options of this builder, which are the Kotlin generator configuration that it was created with, or the
+     * defaults.
+     * @returns The options of this builder.
+     */
     get options() {
         return super.options;
     }
+    /**
+     * Initializes a new instance of the KotlinFileBuilder class.
+     * @param packageName The package of the file, or `undefined` for a file without a package.
+     * @param options The Kotlin generator configuration to use. Defaults to `defaultKotlinGeneratorConfig`.
+     */
     constructor(packageName, options) {
         super(options ?? defaultKotlinGeneratorConfig);
         this.packageName = packageName;
     }
+    /**
+     * Registers the import of a type that the file refers to. Nothing is registered when `packageName` is missing, or
+     * when it is the package of this file, because no import is needed there.
+     * @param name The name of the type, such as `List`.
+     * @param packageName The package the type is declared in, such as `kotlin.collections`.
+     * @returns A reference to this instance.
+     */
     addImport(name, packageName) {
         if (packageName !== undefined && packageName !== this.packageName) {
             this.imports.addImport(name, packageName);
         }
         return this;
     }
+    /**
+     * Appends an annotation, such as `@JsonProperty("id")`, on a line of its own, and registers its import.
+     *
+     * Each entry of `args` is either a value, which is written as a positional argument, or one of these tuples:
+     * - `[value, condition]` writes the value as a positional argument when the condition is `true`.
+     * - `[key, value]` writes the named argument `key = value`.
+     * - `[key, value, condition]` writes the named argument unless the condition is `false`.
+     *
+     * The arguments are written on one line, or one per line when a value is a builder function or the arguments are
+     * long.
+     * @param name The simple name of the annotation, such as `JsonProperty`.
+     * @param packageName The package of the annotation. It is imported unless it is the package of this file.
+     * @param args The arguments of the annotation, in the forms described above.
+     * @returns A reference to this instance.
+     * @example
+     * ```ts
+     * builder.appendAnnotation('JsonProperty', 'com.fasterxml.jackson.annotation', [
+     *   '"id"',
+     *   ['required', 'true', isRequired],
+     * ]);
+     * // Emits: @JsonProperty("id", required = true)
+     * ```
+     */
     appendAnnotation(name, packageName, args) {
         const allArgs = [];
         if (args) {
@@ -52,10 +119,19 @@ export class KotlinFileBuilder extends SourceBuilder {
         this.appendLine();
         return this;
     }
+    /**
+     * Removes the code and all collected imports. The package name is kept.
+     */
     clear() {
         super.clear();
         this.imports.clear();
     }
+    /**
+     * Gets the source of the file: the `package` line, the import statements, and the code.
+     * @param addPadding Whether to separate the imports from the code with an empty line, and to end the source with a
+     * line break. Defaults to `true`.
+     * @returns The source of the file.
+     */
     toString(addPadding = true) {
         return new SourceBuilder(this.options)
             .if(this.packageName !== undefined, (builder) => builder.appendLine(`package ${this.packageName}`).appendLine())
@@ -65,6 +141,11 @@ export class KotlinFileBuilder extends SourceBuilder {
             .if(addPadding, (builder) => builder.ensureCurrentLineEmpty())
             .toString();
     }
+    /**
+     * Writes the source of the file to a path, creating missing parent directories. If the file already exists, the
+     * `existingFileBehavior` of the configuration decides what happens.
+     * @param filePath The path of the file to write.
+     */
     writeToFile(filePath) {
         writeGeneratedFile(this.options, filePath, this.toString());
     }

package/dist/src/generators/file-generator.d.ts

@@ -1,6 +1,18 @@
 import { type MaybePromise, type Nullable, type OpenApiGenerationProviderContext, type OpenApiGeneratorInput } from '@goast/core';
 import type { KotlinGeneratorConfig } from '../config.ts';
+/**
+ * Base class for the generators that produce Kotlin output. It provides the naming helpers that the generators share,
+ * such as the enum constant names, which are derived from the enum values with the `enumValueNameCasing` option.
+ * Subclasses implement `generate` to produce the output for a context.
+ * @template TContext The type of the context the generator receives.
+ * @template TOutput The type of the output the generator produces.
+ */
 export declare abstract class KotlinFileGenerator<TContext extends OpenApiGenerationProviderContext<OpenApiGeneratorInput, KotlinGeneratorConfig>, TOutput> {
+    /**
+     * Generates the Kotlin output for the given context.
+     * @param context The context to generate the output from.
+     * @returns The generated output, or a promise of it.
+     */
     abstract generate(context: TContext): MaybePromise<TOutput>;
     protected toPropertyName(context: TContext, name: string): string;
     /**

package/dist/src/generators/file-generator.js

@@ -1,5 +1,12 @@
 import { toCasing, } from '@goast/core';
 import { toKotlinPropertyName, toKotlinStringLiteral } from '../utils.js';
+/**
+ * Base class for the generators that produce Kotlin output. It provides the naming helpers that the generators share,
+ * such as the enum constant names, which are derived from the enum values with the `enumValueNameCasing` option.
+ * Subclasses implement `generate` to produce the output for a context.
+ * @template TContext The type of the context the generator receives.
+ * @template TOutput The type of the output the generator produces.
+ */
 export class KotlinFileGenerator {
     toPropertyName(context, name) {
         return toKotlinPropertyName(toCasing(name, context.config.propertyNameCasing));