@goast/kotlin 0.6.0-beta.1 → 0.6.0

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

@@ -0,0 +1,850 @@
+import {
+  type ApiSchema,
+  type ApiSchemaKind,
+  type ApiSchemaProperty,
+  type AppendValue,
+  type AppendValueGroup,
+  appendValueGroup,
+  type BasicAppendValue,
+  builderTemplate as s,
+  createOverwriteProxy,
+  DEFAULT_IGNORED_SCHEMA_PROPERTIES,
+  getSchemaReference,
+  getSourceDisplayName,
+  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 { getSourceDocLine, getStringEnumSchema } from '../../utils.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 }) };
+    }
+
+    const schemaReference = getSchemaReference(ctx.schema, DEFAULT_IGNORED_SCHEMA_PROPERTIES);
+    if (schemaReference !== ctx.schema) {
+      const typeName = this.getDeclarationTypeName(ctx, { schema: schemaReference });
+      const packageName = this.getPackageName(ctx, { schema: schemaReference });
+      return { type: kt.reference(typeName, packageName) };
+    }
+
+    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 ${getSourceDisplayName(ctx.data, ctx.schema)} [${packageName}.${typeName}] to ${filePath}...`,
+      );
+      const builder = new KotlinFileBuilder(packageName, ctx.config);
+      builder.append(this.getFileContent(ctx, {}));
+      builder.writeToFile(filePath);
+
+      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(this.getSchemaDocDescription(ctx, { schema })),
+      annotations: [
+        this.getJacksonJsonClassDescriptionAnnotation(ctx, { schema }),
+        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, nullable: false })),
+      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(this.getSchemaDocDescription(ctx, { schema })),
+      annotations: [
+        this.getJacksonJsonTypeInfoAnnotation(ctx, { schema }),
+        this.getJacksonJsonSubTypesAnnotation(ctx, { schema }),
+        this.getJacksonJsonClassDescriptionAnnotation(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;
+
+    const name = this.getDeclarationTypeName(ctx, { schema });
+    // One set of names for both generation sites below, so the constant and its `when` branch agree.
+    const valueNames = this.toEnumValueNames(ctx, schema.enum);
+    return kt.enum(
+      name,
+      schema.enum?.map((x, i) =>
+        kt.enumValue(valueNames[i], {
+          annotations: [kt.annotation(kt.refs.jackson.jsonProperty(), [kt.argument(kt.string(String(x)))])],
+          arguments: [kt.argument(kt.string(String(x)))],
+        })
+      ) ?? [],
+      {
+        doc: kt.doc(this.getSchemaDocDescription(ctx, { schema })),
+        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',
+          }),
+        ]),
+        companionObject: kt.object({
+          members: [
+            kt.function('fromValue', {
+              parameters: [kt.parameter('value', kt.refs.string())],
+              returnType: kt.reference(name, null, { nullable: true }),
+              singleExpression: true,
+              body: !schema.enum?.length ? 'null' : s`\nwhen(value) {${s.indent`${
+                appendValueGroup([
+                  schema.enum.map((x, i) => s`\n${kt.string(String(x))} -> ${valueNames[i]}`),
+                ])
+              }
+                else -> null`}
+              }`,
+            }),
+          ],
+        }),
+      },
+    );
+  }
+
+  protected getSchemaDocDescription(ctx: Context, args: Args.GetSchemaDocDescription): BasicAppendValue<Builder> {
+    const docSegments = [args.schema.description?.trim()];
+
+    if (ctx.config.includeSourceInDocs) {
+      docSegments.push(getSourceDocLine(args.schema));
+    }
+
+    return docSegments.filter(notNullish).join('\n\n');
+  }
+
+  protected getType(ctx: Context, args: Args.GetType): kt.Reference<SourceBuilder> {
+    let { schema, nullable } = args;
+
+    if (schema.kind === 'oneOf' && schema.oneOf.length === 2 && schema.oneOf.some((x) => x.kind === 'null')) {
+      const nonNullSchema = schema.oneOf.find((x) => x.kind !== 'null')!;
+      if (nonNullSchema) {
+        schema = nonNullSchema;
+        nullable ??= true;
+      }
+    }
+
+    const generatedType = this.getGeneratedType(ctx, { schema, nullable });
+    if (generatedType) {
+      return generatedType;
+    }
+
+    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 });
+          case 'time':
+            return kt.refs.java.offsetTime({ nullable });
+          case 'date':
+            return kt.refs.java.localDate({ nullable });
+          case 'local-date-time':
+            return kt.refs.java.localDateTime({ nullable });
+          case 'local-time':
+            return kt.refs.java.localTime({ nullable });
+          case 'uri':
+            return kt.refs.java.uri({ 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, DEFAULT_IGNORED_SCHEMA_PROPERTIES);
+    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 }), this.toEnumValueName(ctx, schema.enum, schema.default)])
+            : kt.string(String(schema.default));
+        case 'array': {
+          const itemEnumSchema = getStringEnumSchema(schema.items);
+          return kt.call(
+            kt.refs.listOf.infer(),
+            Array.isArray(schema.default)
+              ? schema.default.map((x) =>
+                itemEnumSchema
+                  ? kt.call([
+                    this.getType(ctx, { schema: itemEnumSchema }),
+                    this.toEnumValueName(ctx, itemEnumSchema.enum, 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.getJakartaValidationAnnotations(ctx, { schema, property }),
+          this.getSwaggerSchemaAnnotation(ctx, { schema, property }),
+          modify(this.getJacksonJsonPropertyAnnotation(ctx, { schema, property }), (x) => (x.target = 'param')),
+          ...modifyEach(
+            [
+              this.getJacksonJsonPropertyAnnotation(ctx, { schema, property }),
+              this.getJacksonJsonPropertyDescriptionAnnotation(ctx, { schema, property }),
+              this.getJacksonJsonIncludeAnnotation(ctx, { schema, property }),
+            ].filter(notNullish),
+            (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(this.getSchemaDocDescription(ctx, { schema: property.schema })),
+      annotations: modifyEach(
+        [
+          this.getJacksonJsonPropertyAnnotation(ctx, { schema, property }),
+          this.getJacksonJsonPropertyDescriptionAnnotation(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 getJacksonJsonClassDescriptionAnnotation(
+    ctx: Context,
+    args: Args.GetJacksonJsonClassDescriptionAnnotation,
+  ): kt.Annotation<Builder> | null {
+    const { schema } = args;
+
+    return ctx.config.addJacksonAnnotations && schema.description
+      ? kt.annotation(kt.refs.jackson.jsonClassDescription(), [
+        kt.argument(kt.string(schema.description)),
+      ])
+      : 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 getJacksonJsonPropertyDescriptionAnnotation(
+    ctx: Context,
+    args: Args.GetJacksonJsonPropertyDescriptionAnnotation,
+  ): kt.Annotation<Builder> | null {
+    const { property } = args;
+
+    return ctx.config.addJacksonAnnotations && property.schema.description
+      ? kt.annotation(kt.refs.jackson.jsonPropertyDescription(), [
+        kt.argument(kt.string(property.schema.description)),
+      ])
+      : 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 getJakartaValidationAnnotations(
+    ctx: Context,
+    args: Args.GetJakartaValidationAnnotations,
+  ): kt.Annotation<Builder>[] {
+    const { property } = args;
+    const annotations: kt.Annotation<Builder>[] = [];
+    if (!ctx.config.addJakartaValidationAnnotations) {
+      return annotations;
+    }
+
+    if (property.schema.kind === 'string') {
+      if (property.schema.pattern) {
+        annotations.push(
+          kt.annotation(kt.refs.jakarta.pattern(), [kt.argument.named('regexp', kt.string(property.schema.pattern))], {
+            target: 'get',
+          }),
+        );
+      }
+      if (property.schema.minLength === 1 && property.schema.maxLength === undefined) {
+        annotations.push(kt.annotation(kt.refs.jakarta.notEmpty(), [], { target: 'get' }));
+      } else if (property.schema.minLength !== undefined || property.schema.maxLength !== undefined) {
+        annotations.push(kt.annotation(kt.refs.jakarta.size(), [
+          property.schema.minLength !== undefined ? kt.argument.named('min', property.schema.minLength) : null,
+          property.schema.maxLength !== undefined ? kt.argument.named('max', property.schema.maxLength) : null,
+        ], { target: 'get' }));
+      }
+    } else if (property.schema.kind === 'number' || property.schema.kind === 'integer') {
+      if (property.schema.minimum !== undefined) {
+        annotations.push(
+          kt.annotation(kt.refs.jakarta.min(), [kt.argument.named('value', property.schema.minimum)], {
+            target: 'get',
+          }),
+        );
+      }
+      if (property.schema.maximum !== undefined) {
+        annotations.push(
+          kt.annotation(kt.refs.jakarta.max(), [kt.argument.named('value', property.schema.maximum)], {
+            target: 'get',
+          }),
+        );
+      }
+    } else if (property.schema.kind === 'array') {
+      if (property.schema.minItems !== undefined || property.schema.maxItems !== undefined) {
+        annotations.push(kt.annotation(kt.refs.jakarta.size(), [
+          property.schema.minItems !== undefined ? kt.argument.named('min', property.schema.minItems) : null,
+          property.schema.maxItems !== undefined ? kt.argument.named('max', property.schema.maxItems) : null,
+        ], { target: 'get' }));
+      }
+    }
+
+    if (this.shouldGenerateTypeDeclaration(ctx, { schema: property.schema })) {
+      annotations.push(kt.annotation(kt.refs.jakarta.valid(), [], { target: 'field' }));
+    }
+
+    return annotations;
+  }
+
+  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;
+    }
+
+    // A discriminated schema is the supertype its subtypes implement and the carrier of the
+    // `@JsonTypeInfo`/`@JsonSubTypes` pair, so it always needs a declaration of its own. The two rules below
+    // simplify a schema that nothing refers to as a type; degrading a polymorphic base to `Any` or to a `Map`
+    // instead drops the supertype from every subtype and the polymorphism with it. This matters for a base
+    // whose `discriminator.propertyName` is declared on the mapping targets rather than on the base, which is
+    // legal and leaves the base with no properties of its own.
+    const isDiscriminatedBase = schema.kind === 'object' && schema.discriminator !== undefined;
+
+    // Schemas representable by a simple Map type do not need its own type declaration
+    if (
+      !isDiscriminatedBase && schema.kind === 'object' && schema.properties.size === 0 && schema.additionalProperties
+    ) {
+      return false;
+    }
+
+    if (
+      !isDiscriminatedBase && 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;
+
+    schema = this.normalizeDiscriminatedBases(ctx, { schema });
+    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;
+  }
+
+  /**
+   * Rewrites every discriminated `oneOf` base reachable from the schema through a composition into the
+   * `object` it describes, so that the merge in `normalizeSchema` treats it as one.
+   *
+   * A schema that declares a `oneOf` is of kind `oneOf` even when it also declares `type: object` and
+   * properties of its own — `determineSchemaKind` looks at `oneOf` first. For a *discriminated* `oneOf` that
+   * loses the very information the Kotlin declarations need, because the branches of such a `oneOf` are the
+   * schema's subtypes rather than parts of it (the same distinction `resolveAnyOfAndAllOf` draws for a `oneOf`
+   * nested inside a composition):
+   *
+   * - the base is an object in its own right, described by its own `properties`, `required` and any
+   *   `allOf`/`anyOf` it composes — so its interface must declare those and nothing else, not the union of
+   *   what its subtypes declare;
+   * - a subtype's `allOf: [Base]` is a composition with that object — so the subtype must inherit the base's
+   *   own properties, including the discriminator, while inheriting nothing from its siblings.
+   *
+   * Both follow from turning the base into an `object` before the merge runs: the merge already collects the
+   * properties of an `object` branch and already declines to collect the branches of a discriminated `oneOf`.
+   * This is why `AllOfInheritanceDiscriminator` in test/specs/v3/discriminator-variants.yml has always been
+   * correct — with no `oneOf` keyword it is of kind `object` already — while every `oneOf`-holder base in the
+   * same document was not.
+   */
+  protected normalizeDiscriminatedBases(_ctx: Context, args: Args.NormalizeDiscriminatedBases): ApiSchema {
+    // `normalizeSchema` runs once per property type via `shouldGenerateTypeDeclaration`, and almost no schema
+    // has a discriminated base anywhere below it. Answering that first costs one traversal and one set, and
+    // lets the overwhelmingly common case return the schema itself rather than a copy per composing schema.
+    //
+    // The question is asked once for the whole call rather than again per branch: a per-branch answer would
+    // have to be memoised to stay linear, and memoising it is unsound, because a walk truncated by the cycle
+    // guard can record `false` for a branch that reaches a base only by going back through an ancestor.
+    if (!containsDiscriminatedBase(args.schema, new Set())) return args.schema;
+
+    const rewritten = new Map<ApiSchema, ApiSchema>();
+    return rewrite(args.schema);
+
+    function rewrite(schema: ApiSchema): ApiSchema {
+      const existing = rewritten.get(schema);
+      if (existing) return existing;
+
+      const isBase = isDiscriminatedBase(schema);
+      const allOf = branches(schema, 'allOf');
+      const anyOf = branches(schema, 'anyOf');
+      // The branches of a discriminated `oneOf` are dropped rather than descended into: they are the schema's
+      // subtypes, and a subtype is generated from its own file where it is the root of this walk.
+      const oneOf = isBase ? [] : branches(schema, 'oneOf');
+      if (!isBase && allOf.length === 0 && anyOf.length === 0 && oneOf.length === 0) {
+        return schema;
+      }
+
+      // Registered before descending, so a branch composing back to one of its own ancestors terminates.
+      // deno-lint-ignore no-explicit-any
+      const copy: any = { ...schema };
+      rewritten.set(schema, copy);
+      if (isBase) {
+        copy.kind = 'object';
+        copy.type = 'object';
+      }
+      copy.allOf = allOf.map(rewrite);
+      copy.anyOf = anyOf.map(rewrite);
+      copy.oneOf = oneOf.map(rewrite);
+      return copy as ApiSchema;
+    }
+
+    /** Whether the schema or anything it composes is a base this walk would rewrite. */
+    function containsDiscriminatedBase(schema: ApiSchema, visited: Set<ApiSchema>): boolean {
+      if (visited.has(schema)) return false;
+      visited.add(schema);
+      if (isDiscriminatedBase(schema)) return true;
+
+      const contains = (x: ApiSchema) => containsDiscriminatedBase(x, visited);
+      return branches(schema, 'allOf').some(contains) ||
+        branches(schema, 'anyOf').some(contains) ||
+        branches(schema, 'oneOf').some(contains);
+    }
+
+    function isDiscriminatedBase(schema: ApiSchema): boolean {
+      return schema.kind === 'oneOf' && schema.discriminator !== undefined;
+    }
+
+    /**
+     * The branches a schema composes under one keyword. `normalizeSchema` leaves an explicit
+     * `oneOf: undefined` behind when it rewrites a `oneOf` holder, so a keyword can be present with no value.
+     */
+    function branches(schema: ApiSchema, keyword: 'allOf' | 'anyOf' | 'oneOf'): ApiSchema[] {
+      const values = schema as unknown as Record<string, ApiSchema[] | undefined>;
+      return values[keyword] ?? [];
+    }
+  }
+
+  protected hasProperty(ctx: Context, args: Args.HasProperty): boolean {
+    // A composition branch may compose back to one of its own ancestors (see test/specs/v3/anyof-cycle.yml).
+    // Without this guard such a cycle recurses until the stack overflows. Re-visiting a schema can never
+    // change the answer, so returning `false` for one is safe: another path either already found the
+    // property or does not contain it at all.
+    const { schema, propertyName, visited = new Set<ApiSchema>() } = args;
+    if (visited.has(schema)) return false;
+    visited.add(schema);
+
+    return (
+      ('properties' in schema && schema.properties.has(propertyName)) ||
+      ('anyOf' in schema && schema.anyOf.some((schema) => this.hasProperty(ctx, { schema, propertyName, visited }))) ||
+      ('allOf' in schema && schema.allOf.some((schema) => this.hasProperty(ctx, { schema, propertyName, visited }))) ||
+      // Only an undiscriminated `oneOf` composes into the schema that references it, matching which `oneOf`
+      // branches `resolveAnyOfAndAllOf` merges. A discriminated one lists subtypes, whose properties are not
+      // the referencing schema's, so an inherited property never comes from there.
+      ('oneOf' in schema && !schema.discriminator &&
+        schema.oneOf.some((schema) => this.hasProperty(ctx, { schema, propertyName, visited })))
+    );
+  }
+}