@goast/kotlin 0.4.2-beta1 → 0.4.3

package/src/src/generators/models/model-generator.ts

@@ -0,0 +1,602 @@
+import { dirname } from 'node:path';
+
+
+import fs from 'fs-extra';
+
+import {
+  type ApiSchema,
+  type ApiSchemaKind,
+  type ApiSchemaProperty,
+  type AppendValue,
+  type AppendValueGroup,
+  appendValueGroup,
+  createOverwriteProxy,
+  getSchemaReference,
+  type MaybePromise,
+  modify,
+  modifyEach,
+  notNullish,
+  resolveAnyOfAndAllOf,
+  type SourceBuilder,
+  toCasing,
+} from '@goast/core';
+
+import { kt } from '../../ast/index.js';
+import { KotlinFileBuilder } from '../../file-builder.js';
+import { KotlinFileGenerator } from '../file-generator.js';
+import type { DefaultKotlinModelGeneratorArgs as Args } from './index.js';
+import type { KotlinModelGeneratorContext, KotlinModelGeneratorOutput } from './models.js';
+
+type Context = KotlinModelGeneratorContext;
+type Output = KotlinModelGeneratorOutput;
+type Builder = KotlinFileBuilder;
+
+export interface KotlinModelGenerator<TOutput extends Output = Output> {
+  generate(ctx: Context): MaybePromise<TOutput>;
+}
+
+export class DefaultKotlinModelGenerator extends KotlinFileGenerator<Context, Output> implements KotlinModelGenerator {
+  public generate(ctx: Context): MaybePromise<KotlinModelGeneratorOutput> {
+    if (/\/(anyOf|allOf)(\/[0-9]+)?$/.test(ctx.schema.$src.path)) {
+      // Do not generate types that are only used for anyOf and/or allOf
+      return { type: kt.refs.any({ nullable: true }) };
+    }
+
+    if (this.shouldGenerateTypeDeclaration(ctx, { schema: ctx.schema })) {
+      const typeName = this.getDeclarationTypeName(ctx, { schema: ctx.schema });
+      const packageName = this.getPackageName(ctx, { schema: ctx.schema });
+      const filePath = `${ctx.config.outputDir}/${packageName.replace(/\./g, '/')}/${typeName}.kt`;
+      console.log(`Generating model ${packageName}.${typeName} to ${filePath}...`);
+      fs.ensureDirSync(dirname(filePath));
+
+      fs.writeFileSync(
+        filePath,
+        new KotlinFileBuilder(packageName, ctx.config).append(this.getFileContent(ctx, {})).toString(),
+      );
+
+      return { type: kt.reference(typeName, packageName) };
+    } else {
+      return { type: this.getType(ctx, { schema: ctx.schema }) };
+    }
+  }
+
+  protected getFileContent(ctx: Context, _args: Args.GetFileContent): AppendValueGroup<Builder> {
+    return appendValueGroup<Builder>(
+      [this.getSchemaDeclaration(ctx, { schema: this.normalizeSchema(ctx, { schema: ctx.schema }) })],
+      '\n\n',
+    );
+  }
+
+  protected getSchemaDeclaration(ctx: Context, args: Args.GetSchemaDeclaration): AppendValue<Builder> {
+    const { schema } = args;
+
+    if (schema.kind === 'object') {
+      return schema.discriminator ? this.getInterface(ctx, { schema }) : this.getClass(ctx, { schema });
+    } else if (schema.enum !== undefined && schema.enum.length > 0) {
+      return this.getEnum(ctx, { schema });
+    }
+
+    return '// The generator was not able to generate this schema.\n// This should not happend. If you see this comment, please open an Issue on Github.';
+  }
+
+  protected getClass(ctx: Context, args: Args.GetClass): kt.Class<Builder> {
+    const { schema } = args;
+    const inheritedSchemas = this.getInheritedSchemas(ctx, { schema });
+    const parameters = this.getClassProperties(ctx, { schema });
+
+    return kt.class(this.getDeclarationTypeName(ctx, { schema }), {
+      doc: kt.doc(schema.description?.trim()),
+      annotations: [schema.deprecated ? kt.annotation(kt.refs.deprecated(), [kt.argument(kt.string(''))]) : null],
+      classKind: parameters.length === 0 ? null : 'data',
+      implements: inheritedSchemas.map((schema) => this.getType(ctx, { schema })),
+      primaryConstructor: kt.constructor(
+        parameters.map((property) => this.getClassParameter(ctx, { ...args, inheritedSchemas, parameters, property })),
+      ),
+      members: [
+        ...(schema.additionalProperties !== undefined && schema.additionalProperties !== false
+          ? [
+            this.getAdditionalPropertiesProperty(ctx, { schema }),
+            this.getAdditionalPropertiesSetter(ctx, { schema }),
+            this.getAdditionalPropertiesGetter(ctx, { schema }),
+          ]
+          : []),
+      ],
+    });
+  }
+
+  protected getInterface(ctx: Context, args: Args.GetInterface): kt.Interface<Builder> {
+    const { schema } = args;
+
+    return kt.interface(this.getDeclarationTypeName(ctx, { schema }), {
+      doc: kt.doc(schema.description?.trim()),
+      annotations: [
+        this.getJacksonJsonTypeInfoAnnotation(ctx, { schema }),
+        this.getJacksonJsonSubTypesAnnotation(ctx, { schema }),
+        schema.deprecated ? kt.annotation(kt.refs.deprecated(), [kt.argument(kt.string(''))]) : null,
+      ].filter(notNullish),
+      members: this.sortProperties(ctx, { schema, properties: schema.properties.values() }).map((property) =>
+        this.getInterfaceProperty(ctx, { schema, property })
+      ),
+    });
+  }
+
+  protected getEnum(ctx: Context, args: Args.GetEnum): kt.Enum<Builder> {
+    const { schema } = args;
+
+    return kt.enum(
+      this.getDeclarationTypeName(ctx, { schema }),
+      schema.enum?.map((x) =>
+        kt.enumValue(toCasing(String(x), ctx.config.enumValueNameCasing), {
+          annotations: [kt.annotation(kt.refs.jackson.jsonProperty(), [kt.argument(kt.string(String(x)))])],
+          arguments: [kt.argument(kt.string(String(x)))],
+        })
+      ) ?? [],
+      {
+        doc: kt.doc(schema.description?.trim()),
+        annotations: [schema.deprecated ? kt.annotation(kt.refs.deprecated(), [kt.argument(kt.string(''))]) : null],
+        primaryConstructor: kt.constructor([
+          kt.parameter.class(toCasing('value', ctx.config.propertyNameCasing), kt.refs.string(), {
+            property: 'readonly',
+          }),
+        ]),
+      },
+    );
+  }
+
+  protected getType(ctx: Context, args: Args.GetType): kt.Reference<SourceBuilder> {
+    const { schema } = args;
+
+    const generatedType = this.getGeneratedType(ctx, { schema, nullable: args.nullable });
+    if (generatedType) {
+      return generatedType;
+    }
+
+    const nullable = args.nullable ?? schema.nullable;
+    switch (schema.kind) {
+      case 'boolean':
+        return kt.refs.boolean({ nullable });
+      case 'integer':
+      case 'number':
+        switch (schema.format) {
+          case 'int32':
+            return kt.refs.int({ nullable });
+          case 'int64':
+            return kt.refs.long({ nullable });
+          case 'float':
+            return kt.refs.float({ nullable });
+          case 'double':
+            return kt.refs.double({ nullable });
+          default:
+            return schema.kind === 'integer' ? kt.refs.int({ nullable }) : kt.refs.double({ nullable });
+        }
+      case 'string':
+        switch (schema.format) {
+          case 'date-time':
+            return kt.refs.java.offsetDateTime({ nullable });
+          default:
+            return kt.refs.string({ nullable });
+        }
+      case 'null':
+        return kt.refs.nothing({ nullable });
+      case 'unknown':
+        return kt.refs.any({ nullable });
+      case 'array':
+        return kt.refs.list(
+          [schema.items ? this.getType(ctx, { schema: schema.items }) : kt.refs.any({ nullable: true })],
+          { nullable },
+        );
+      case 'object':
+        return schema.properties.size === 0 && schema.additionalProperties
+          ? kt.refs.map([kt.refs.string(), this.getAdditionalPropertiesType(ctx, { schema })], { nullable })
+          : kt.refs.any({ nullable });
+      default:
+        return kt.refs.any({ nullable });
+    }
+  }
+
+  protected getGeneratedType(ctx: Context, args: Args.GetGeneratedType): kt.Reference<SourceBuilder> | null {
+    const schema = getSchemaReference(args.schema, ['description']);
+    if (this.shouldGenerateTypeDeclaration(ctx, { schema })) {
+      return kt.reference(this.getDeclarationTypeName(ctx, { schema }), this.getPackageName(ctx, { schema }), {
+        nullable: args.nullable ?? schema.nullable,
+      });
+    }
+    return null;
+  }
+
+  protected getAdditionalPropertiesType(
+    ctx: Context,
+    args: Args.GetAdditionalPropertiesType,
+  ): kt.Reference<SourceBuilder> {
+    const { schema } = args;
+
+    return typeof schema.additionalProperties === 'object'
+      ? this.getType(ctx, { schema: schema.additionalProperties })
+      : kt.refs.any({ nullable: true });
+  }
+
+  protected getDefaultValue(ctx: Context, args: Args.GetDefaultValue): kt.Value<Builder> {
+    const { schema } = args;
+
+    if (schema.default === null || schema.default === undefined) {
+      return 'null';
+    } else {
+      switch (schema.kind) {
+        case 'boolean':
+          return Boolean(schema.default) || String(schema.default).toLowerCase() === 'true' ? 'true' : 'false';
+        case 'integer':
+        case 'number':
+          return String(schema.default);
+        case 'string':
+          return schema.enum && schema.enum.length > 0
+            ? kt.call([this.getType(ctx, { schema }), toCasing(String(schema.default), ctx.config.enumValueNameCasing)])
+            : kt.string(String(schema.default));
+        case 'array':
+          return kt.call(
+            kt.refs.listOf.infer(),
+            Array.isArray(schema.default) ? schema.default.map((x) => kt.toNode(x)) : [],
+          );
+        default:
+          return 'null';
+      }
+    }
+  }
+
+  // #region Members
+  protected getClassParameter(ctx: Context, args: Args.GetClassParameter): kt.Parameter<Builder> {
+    const { schema, inheritedSchemas, property } = args;
+
+    return kt.parameter.class(
+      toCasing(property.name, ctx.config.propertyNameCasing),
+      this.getType(ctx, { schema: property.schema, nullable: schema.required.has(property.name) ? undefined : true }),
+      {
+        description: property.schema.description?.trim(),
+        annotations: [
+          this.getJakartaPatternAnnotation(ctx, { schema, property }),
+          this.getJakartaValidAnnotation(ctx, { schema, property }),
+          this.getSwaggerSchemaAnnotation(ctx, { schema, property }),
+          this.getJacksonJsonPropertyAnnotation(ctx, { schema, property }),
+          modify(this.getJacksonJsonIncludeAnnotation(ctx, { schema, property }), (x) => (x.target = 'get')),
+          property.schema.deprecated ? kt.annotation(kt.refs.deprecated(), [kt.argument(kt.string(''))]) : null,
+        ].filter(notNullish),
+        override: inheritedSchemas.some((schema) => this.hasProperty(ctx, { schema, propertyName: property.name })),
+        property: 'readonly',
+        default: property.schema.default !== undefined || !schema.required.has(property.name)
+          ? this.getDefaultValue(ctx, { schema: property.schema })
+          : null,
+      },
+    );
+  }
+
+  protected getInterfaceProperty(ctx: Context, args: Args.GetInterfaceProperty): kt.Property<Builder> {
+    const { schema, property } = args;
+
+    return kt.property(toCasing(property.name, ctx.config.propertyNameCasing), {
+      doc: kt.doc(property.schema.description?.trim()),
+      annotations: modifyEach(
+        [
+          this.getJacksonJsonPropertyAnnotation(ctx, { schema, property }),
+          this.getJacksonJsonIncludeAnnotation(ctx, { schema, property }),
+          property.schema.deprecated ? kt.annotation(kt.refs.deprecated(), [kt.argument(kt.string(''))]) : null,
+        ].filter(notNullish),
+        (x) => (x.target = 'get'),
+      ),
+      type: this.getType(ctx, {
+        schema: property.schema,
+        nullable: schema.required.has(property.name) ? undefined : true,
+      }),
+    });
+  }
+
+  protected getAdditionalPropertiesProperty(
+    ctx: Context,
+    args: Args.GetAdditionalPropertiesProperty,
+  ): kt.Property<Builder> {
+    const { schema } = args;
+
+    return kt.property(toCasing('additionalProperties', ctx.config.propertyNameCasing), {
+      annotations: [kt.annotation(kt.refs.jackson.jsonIgnore())],
+      type: kt.reference('MutableMap', null, {
+        generics: ['String', this.getAdditionalPropertiesType(ctx, { schema })],
+      }),
+      default: 'mutableMapOf()',
+    });
+  }
+
+  protected getAdditionalPropertiesSetter(
+    ctx: Context,
+    args: Args.GetAdditionalPropertiesSetter,
+  ): kt.Function<Builder> {
+    const { schema } = args;
+
+    return kt.function(toCasing('set', ctx.config.functionNameCasing), {
+      annotations: [kt.annotation(kt.refs.jackson.jsonAnySetter())],
+      parameters: [
+        kt.parameter(toCasing('name', ctx.config.parameterNameCasing), 'String'),
+        kt.parameter(
+          toCasing('value', ctx.config.parameterNameCasing),
+          this.getAdditionalPropertiesType(ctx, { schema }),
+        ),
+      ],
+      body: `this.${toCasing('additionalProperties', ctx.config.propertyNameCasing)}[name] = value`,
+    });
+  }
+
+  protected getAdditionalPropertiesGetter(
+    ctx: Context,
+    args: Args.GetAdditionalPropertiesGetter,
+  ): kt.Function<Builder> {
+    const { schema } = args;
+
+    return kt.function(toCasing('getMap', ctx.config.functionNameCasing), {
+      annotations: [kt.annotation(kt.refs.jackson.jsonAnyGetter())],
+      returnType: kt.refs.map([kt.refs.string(), this.getAdditionalPropertiesType(ctx, { schema })]),
+      body: `return this.${toCasing('additionalProperties', ctx.config.propertyNameCasing)}`,
+    });
+  }
+  // #endregion
+
+  // #region Annotations
+  protected getJacksonJsonTypeInfoAnnotation(
+    ctx: Context,
+    args: Args.GetJacksonJsonTypeInfoAnnotation,
+  ): kt.Annotation<Builder> | null {
+    const { schema } = args;
+
+    return ctx.config.addJacksonAnnotations && schema.discriminator
+      ? kt.annotation(kt.refs.jackson.jsonTypeInfo(), [
+        kt.argument.named('use', 'JsonTypeInfo.Id.NAME'),
+        kt.argument.named(
+          'include',
+          'properties' in schema && schema.properties.has(schema.discriminator.propertyName)
+            ? 'JsonTypeInfo.As.EXISTING_PROPERTY'
+            : 'JsonTypeInfo.As.PROPERTY',
+        ),
+        kt.argument.named('property', kt.string(schema.discriminator.propertyName)),
+        kt.argument.named('visible', 'true'),
+      ])
+      : null;
+  }
+
+  protected getJacksonJsonSubTypesAnnotation(
+    ctx: Context,
+    args: Args.GetJacksonJsonSubTypesAnnotation,
+  ): kt.Annotation<Builder> | null {
+    const { schema } = args;
+
+    if (!ctx.config.addJacksonAnnotations || !schema.discriminator) return null;
+    const entries = Object.entries(schema.discriminator.mapping);
+    return entries.length > 0
+      ? kt.annotation(
+        kt.refs.jackson.jsonSubTypes(),
+        entries.map(([value, schema]) =>
+          kt.argument(
+            kt.call(
+              [kt.refs.jackson.jsonSubTypes(), 'Type'],
+              [
+                kt.argument.named(
+                  'value',
+                  modify(this.getType(ctx, { schema }), (x) => (x.classReference = true)),
+                ),
+                kt.argument.named('name', kt.string(value)),
+              ],
+            ),
+          )
+        ),
+      )
+      : null;
+  }
+
+  protected getJacksonJsonPropertyAnnotation(
+    ctx: Context,
+    args: Args.GetJacksonJsonPropertyAnnotation,
+  ): kt.Annotation<Builder> | null {
+    const { schema, property } = args;
+
+    return ctx.config.addJacksonAnnotations
+      ? kt.annotation(kt.refs.jackson.jsonProperty(), [
+        kt.argument(kt.string(property.name)),
+        schema.required.has(property.name) ? kt.argument.named('required', 'true') : null,
+      ])
+      : null;
+  }
+
+  protected getJacksonJsonIncludeAnnotation(
+    ctx: Context,
+    args: Args.GetJacksonJsonIncludeAnnotation,
+  ): kt.Annotation<Builder> | null {
+    const { property } = args;
+
+    return ctx.config.addJacksonAnnotations && property.schema.custom['exclude-when-null'] === true
+      ? kt.annotation(kt.refs.jackson.jsonInclude(), [
+        kt.argument(kt.call([kt.refs.jackson.jsonInclude(), 'Include', 'NON_NULL'])),
+      ])
+      : null;
+  }
+
+  protected getJakartaPatternAnnotation(
+    ctx: Context,
+    args: Args.GetJakartaPatternAnnotation,
+  ): kt.Annotation<Builder> | null {
+    const { property } = args;
+
+    return ctx.config.addJakartaValidationAnnotations && property.schema.kind === 'string' && property.schema.pattern
+      ? kt.annotation(kt.refs.jakarta.pattern(), [kt.argument.named('regexp', kt.string(property.schema.pattern))], {
+        target: 'get',
+      })
+      : null;
+  }
+
+  protected getJakartaValidAnnotation(
+    ctx: Context,
+    args: Args.GetJakartaValidAnnotation,
+  ): kt.Annotation<Builder> | null {
+    const { property } = args;
+
+    return ctx.config.addJakartaValidationAnnotations &&
+        this.shouldGenerateTypeDeclaration(ctx, { schema: property.schema })
+      ? kt.annotation(kt.refs.jakarta.valid(), [], { target: 'field' })
+      : null;
+  }
+
+  protected getSwaggerSchemaAnnotation(
+    ctx: Context,
+    args: Args.GetSwaggerSchemaAnnotation,
+  ): kt.Annotation<Builder> | null {
+    const { schema, property } = args;
+
+    return ctx.config.addSwaggerAnnotations
+      ? kt.annotation(kt.refs.swagger.schema(), [
+        property.schema.example !== undefined
+          ? kt.argument.named('example', kt.string(String(property.schema.example)))
+          : null,
+        schema.required.has(property.name) ? kt.argument.named('required', 'true') : null,
+        property.schema.description !== undefined
+          ? kt.argument.named('description', kt.string(property.schema.description))
+          : null,
+        property.schema.deprecated ? kt.argument.named('deprecated', kt.toNode(property.schema.deprecated)) : null,
+      ])
+      : null;
+  }
+  // #endregion
+
+  protected getPackageName(ctx: Context, args: Args.GetPackageName): string {
+    const { schema } = args;
+
+    const packageSuffix = typeof ctx.config.packageSuffix === 'string'
+      ? ctx.config.packageSuffix
+      : ctx.config.packageSuffix(schema);
+    return ctx.config.packageName + packageSuffix;
+  }
+
+  protected shouldGenerateTypeDeclaration(ctx: Context, args: Args.ShouldGenerateTypeDeclaration): boolean {
+    let { schema } = args;
+
+    // All enum types should have its own type declaration
+    if (schema.enum !== undefined && schema.enum.length > 0) {
+      return true;
+    }
+
+    // All primitive types already exist and do not need its own type declaration
+    if (
+      schema.kind !== 'combined' &&
+      schema.kind !== 'multi-type' &&
+      schema.kind !== 'object' &&
+      schema.kind !== 'oneOf'
+    ) {
+      return false;
+    }
+
+    // Too complex types cannot be represented in Kotlin, so they fallback to Any
+    if (schema.kind === 'multi-type') {
+      return false;
+    }
+    schema = this.normalizeSchema(ctx, { schema });
+    if (schema.kind === 'combined' || schema.kind === 'oneOf') {
+      return false;
+    }
+
+    // Schemas representable by a simple Map type do not need its own type declaration
+    if (schema.kind === 'object' && schema.properties.size === 0 && schema.additionalProperties) {
+      return false;
+    }
+
+    if (schema.kind === 'object' && ctx.config.emptyObjectTypeBehavior === 'use-any' && schema.properties.size === 0) {
+      return false;
+    }
+
+    // Dynamically generated schemas do not have its own type declaration
+    if (!ctx.data.schemas.some((x) => x.id === schema.id)) {
+      return false;
+    }
+
+    // multipart schemas should not have its own type declaration
+    if (schema.$src.path.endsWith('/requestBody/content/multipart/form-data/schema')) {
+      return false;
+    }
+
+    return true;
+  }
+
+  protected getDeclarationTypeName(ctx: Context, args: Args.GetDeclarationTypeName): string {
+    return toCasing(args.schema.name, ctx.config.typeNameCasing);
+  }
+
+  protected getInheritedSchemas(
+    ctx: Context,
+    args: Args.GetInheritedSchemas,
+  ): (ApiSchema<ApiSchemaKind> & { discriminator: NonNullable<ApiSchema['discriminator']> })[] {
+    return args.schema.inheritedSchemas
+      .filter((schema) => this.shouldGenerateTypeDeclaration(ctx, { schema }) && !schema.isNameGenerated)
+      .filter((item, index, self) => self.indexOf(item) === index);
+  }
+
+  protected getClassProperties(ctx: Context, args: Args.GetClassProperties): ApiSchemaProperty[] {
+    const { schema } = args;
+
+    const inheritedSchemas = this.getInheritedSchemas(ctx, { schema });
+    const properties: ApiSchemaProperty[] = [];
+    const appendedProperties: ApiSchemaProperty[] = [];
+    for (const property of schema.properties.values()) {
+      const discriminator = inheritedSchemas.find(
+        (x) => x.discriminator?.propertyName === property.name,
+      )?.discriminator;
+      if (discriminator) {
+        const schemaMappings = Object.entries(discriminator.mapping).filter(([_, v]) => v.id === schema.id);
+        if (schemaMappings.length === 1) {
+          const p = createOverwriteProxy(property);
+          const s = createOverwriteProxy(p.schema);
+          p.schema = s;
+          s.default = schemaMappings[0][0];
+          appendedProperties.push(p);
+          continue;
+        }
+      }
+
+      properties.push(property);
+    }
+
+    return [...this.sortProperties(ctx, { schema, properties }), ...appendedProperties];
+  }
+
+  protected sortProperties(_ctx: Context, args: Args.SortProperties): ApiSchemaProperty[] {
+    return [...args.properties].sort((a, b) => classify(a) - classify(b));
+
+    function classify(p: ApiSchemaProperty) {
+      if (p.schema.default !== undefined) return 1;
+      if (args.schema.required.has(p.name)) return 0;
+      return 2;
+    }
+  }
+
+  protected normalizeSchema(ctx: Context, args: Args.NormalizeSchema): ApiSchema {
+    let { schema } = args;
+
+    if (schema.kind === 'oneOf') {
+      schema = ctx.config.oneOfBehavior === 'treat-as-any-of'
+        // deno-lint-ignore no-explicit-any
+        ? { ...(schema as any), kind: 'combined', anyOf: schema.oneOf, allOf: [], oneOf: undefined }
+        // deno-lint-ignore no-explicit-any
+        : { ...(schema as any), kind: 'combined', allOf: schema.oneOf, anyOf: [], oneOf: undefined };
+      ctx.schema = schema;
+    }
+    if (schema.kind === 'object' || schema.kind === 'combined') {
+      const mergedSchema = resolveAnyOfAndAllOf(schema, true);
+      if (mergedSchema) {
+        schema = mergedSchema;
+      }
+    }
+
+    return schema;
+  }
+
+  protected hasProperty(ctx: Context, args: Args.HasProperty): boolean {
+    const { schema, propertyName } = args;
+
+    return (
+      ('properties' in schema && schema.properties.has(propertyName)) ||
+      ('anyOf' in schema && schema.anyOf.some((schema) => this.hasProperty(ctx, { schema, propertyName }))) ||
+      ('allOf' in schema && schema.allOf.some((schema) => this.hasProperty(ctx, { schema, propertyName })))
+    );
+  }
+}

package/src/src/generators/models/models-generator.ts

@@ -0,0 +1,65 @@
+import {
+  type ApiSchema,
+  Factory,
+  type MaybePromise,
+  type OpenApiGeneratorContext,
+  OpenApiSchemasGenerationProviderBase,
+} from '@goast/core';
+
+import { DefaultKotlinModelGenerator, type KotlinModelGenerator } from './model-generator.js';
+import {
+  defaultKotlinModelsGeneratorConfig,
+  type KotlinModelGeneratorOutput,
+  type KotlinModelsGeneratorConfig,
+  type KotlinModelsGeneratorContext,
+  type KotlinModelsGeneratorInput,
+  type KotlinModelsGeneratorOutput,
+} from './models.js';
+
+type Input = KotlinModelsGeneratorInput;
+type Output = KotlinModelsGeneratorOutput;
+type Config = KotlinModelsGeneratorConfig;
+type SchemaOutput = KotlinModelGeneratorOutput;
+type Context = KotlinModelsGeneratorContext;
+
+export class KotlinModelsGenerator extends OpenApiSchemasGenerationProviderBase<
+  Input,
+  Output,
+  Config,
+  SchemaOutput,
+  Context
+> {
+  private readonly _modelGeneratorFactory: Factory<KotlinModelGenerator, []>;
+
+  constructor(modelGeneratorFactory?: Factory<KotlinModelGenerator, []>) {
+    super();
+    this._modelGeneratorFactory = modelGeneratorFactory ?? Factory.fromValue(new DefaultKotlinModelGenerator());
+  }
+
+  protected override initResult(): Output {
+    return {
+      kotlin: {
+        models: {},
+      },
+    };
+  }
+
+  protected override buildContext(
+    context: OpenApiGeneratorContext<KotlinModelsGeneratorInput>,
+    config?: Partial<Config> | undefined,
+  ): Context {
+    return this.getProviderContext(context, config, defaultKotlinModelsGeneratorConfig);
+  }
+
+  protected override generateSchema(ctx: Context, schema: ApiSchema): MaybePromise<SchemaOutput> {
+    const modelGenerator = this._modelGeneratorFactory.create();
+    return modelGenerator.generate({
+      ...ctx,
+      schema,
+    });
+  }
+
+  protected override addSchemaResult(ctx: Context, schema: ApiSchema, result: SchemaOutput): void {
+    ctx.output.kotlin.models[schema.id] = result;
+  }
+}