@goast/typescript 0.8.0-beta.1 → 0.8.0

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

@@ -0,0 +1,530 @@
+import { resolve } from 'node:path';
+
+import {
+  type ApiSchema,
+  type AppendValue,
+  type AppendValueGroup,
+  appendValueGroup,
+  type ArrayLikeApiSchema,
+  type BasicAppendValue,
+  type CombinedLikeApiSchema,
+  DEFAULT_IGNORED_SCHEMA_PROPERTIES,
+  getSchemaReference,
+  getSourceDisplayName,
+  type MaybePromise,
+  notNullish,
+  type Nullable,
+  type ObjectLikeApiSchema,
+  resolveAnyOfAndAllOf,
+  type StringLikeApiSchema,
+  toCasing,
+} from '@goast/core';
+
+import { ts } from '../../ast/index.js';
+import type { TypeScriptComponentOutputKind } from '../../common-results.js';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { getSourceDocLine } from '../../utils.js';
+import { TypeScriptFileGenerator } from '../file-generator.js';
+import type { TypeScriptModelGeneratorContext, TypeScriptModelGeneratorOutput } from './models.js';
+
+type Context = TypeScriptModelGeneratorContext;
+type Output = TypeScriptModelGeneratorOutput;
+type Builder = TypeScriptFileBuilder;
+
+export interface TypeScriptModelGenerator<TOutput extends Output = Output> {
+  generate(ctx: Context): MaybePromise<TOutput>;
+}
+
+export class DefaultTypeScriptModelGenerator extends TypeScriptFileGenerator<Context, Output>
+  implements TypeScriptModelGenerator {
+  public generate(ctx: Context): MaybePromise<Output> {
+    if (this.shouldGenerateTypeDeclaration(ctx, ctx.schema)) {
+      const name = this.getDeclarationTypeName(ctx, ctx.schema);
+      const filePath = this.getFilePath(ctx, ctx.schema);
+
+      const fileContent = this.getFileContent(ctx);
+      TypeScriptFileBuilder.generate({
+        logName: `model ${getSourceDisplayName(ctx.data, ctx.schema)} [${name}]`,
+        filePath,
+        options: ctx.config,
+        generator: (b) => b.append(fileContent),
+      });
+
+      const exports = fileContent.values.filter(
+        (x): x is AppendValue<Builder> & { name: string; export: true } =>
+          typeof x === 'object' && x !== null && 'export' in x && x.export === true && 'name' in x,
+      );
+      const node = exports.find((x) => x.name === name);
+      return {
+        component: name,
+        filePath,
+        imports: [
+          {
+            kind: 'file',
+            name,
+            modulePath: filePath,
+            type: node instanceof ts.Interface || node instanceof ts.TypeAlias ? 'type-import' : 'import',
+          },
+        ],
+        additionalExports: exports
+          .filter((x) => x.name !== name)
+          .map(
+            (x) => ({
+              name: x.name,
+              type: x instanceof ts.TypeAlias || x instanceof ts.Interface ? 'type-export' : 'export',
+            } as const),
+          ),
+        kind: this.getNodeKind(node),
+      };
+    } else {
+      const builder = new TypeScriptFileBuilder(undefined, ctx.config);
+      builder.append(this.getType(ctx, ctx.schema));
+      const imports = builder.imports.imports;
+      builder.imports.clear();
+      return { component: builder.toString(false), imports };
+    }
+  }
+
+  protected getNodeKind(node: unknown): TypeScriptComponentOutputKind | undefined {
+    if (node instanceof ts.Interface) return 'interface';
+    if (node instanceof ts.TypeAlias) return 'type';
+    if (node instanceof ts.Enum) return 'enum';
+    if (node instanceof ts.Class) return 'class';
+    return undefined;
+  }
+
+  protected getFileContent(ctx: Context): AppendValueGroup<Builder> {
+    const content = appendValueGroup<Builder>([], '\n');
+    const interfaceSchema = this.resolveInterfaceSchema(ctx);
+    if (interfaceSchema) {
+      content.values.push(this.getInterface(ctx, interfaceSchema));
+    } else if (
+      ctx.config.enumGeneration !== 'union' &&
+      ctx.schema.kind === 'string' &&
+      ctx.schema.enum !== undefined &&
+      ctx.schema.enum.length > 0
+    ) {
+      content.values.push(this.getEnum(ctx));
+    } else if (ctx.schema.discriminator && Object.keys(ctx.schema.discriminator.mapping).length > 0) {
+      content.values.push(
+        ts.typeAlias(
+          this.getDiscriminatorTypeName(ctx, ctx.schema),
+          ts.unionType(Object.keys(ctx.schema.discriminator.mapping).map((x) => ts.string(x))),
+        ),
+        ts.typeAlias(
+          this.getBaseTypeName(ctx, ctx.schema),
+          this.getType(ctx, ctx.schema, { skipSchemas: true }) ?? this.getAnyType(ctx),
+          { export: true },
+        ),
+        this.getTypeAlias(ctx, ctx.schema),
+      );
+    } else {
+      content.values.push(this.getTypeAlias(ctx, ctx.schema));
+      if (ctx.schema.enum) {
+        content.values.push(this.getEnumValuesVariable(ctx, ctx.schema));
+      }
+    }
+    return content;
+  }
+
+  protected getEnum(ctx: Context): ts.Enum<Builder> {
+    return ts.enum(this.getDeclarationTypeName(ctx, ctx.schema), {
+      doc: ts.doc({
+        description: this.getSchemaDocDescription(ctx, ctx.schema),
+        tags: [ctx.schema.deprecated ? ts.docTag('deprecated') : null],
+      }),
+      export: true,
+      members: (ctx.schema.enum?.map((x) => String(x)) ?? []).map((x) =>
+        ts.enumValue(toCasing(x, ctx.config.enumValueNameCasing), { value: ts.string(x) })
+      ),
+    });
+  }
+
+  protected getInterface(ctx: Context, schema: ObjectLikeApiSchema): ts.Interface<Builder> {
+    return ts.interface(this.getDeclarationTypeName(ctx, ctx.schema), {
+      export: true,
+      doc: ts.doc({
+        description: this.getSchemaDocDescription(ctx, schema as ApiSchema),
+        tags: [ctx.schema.deprecated ? ts.docTag('deprecated') : null],
+      }),
+      members: [...this.getProperties(ctx, schema), this.getIndexer(ctx, schema)],
+    });
+  }
+
+  protected getTypeAlias(ctx: Context, schema: ApiSchema): ts.TypeAlias<Builder> {
+    const hasDiscriminator = schema.discriminator && Object.keys(schema.discriminator.mapping).length > 0;
+    const result = ts.typeAlias<Builder>(
+      this.getDeclarationTypeName(ctx, schema),
+      (hasDiscriminator ? this.getDiscriminatorType(ctx, schema) : this.getType(ctx, schema, { skipSchemas: true })) ??
+        this.getAnyType(ctx),
+      {
+        export: true,
+        doc: ts.doc({
+          description: this.getSchemaDocDescription(ctx, schema),
+          tags: [ctx.schema.deprecated ? ts.docTag('deprecated') : null],
+        }),
+      },
+    );
+
+    if (hasDiscriminator) {
+      const propertyValue = this.getDiscriminatorTypeName(ctx, ctx.schema);
+      result.generics.push(
+        ts.genericParameter(this.getDiscriminatorGenericParamName(ctx, schema), {
+          constraint: propertyValue,
+          default: propertyValue,
+        }),
+      );
+    }
+
+    const inheritedSchemas = this.getInheritedSchemas(ctx, schema);
+    if (inheritedSchemas.length > 0) {
+      const fixedProperties = inheritedSchemas.reduce((p, c) => {
+        const mappingValues = Object.entries(c.discriminator.mapping)
+          .filter(([_, value]) => value.id === schema.id)
+          .map(([key]) => ts.string(key));
+        if (c.discriminator.propertyName in p) {
+          p[c.discriminator.propertyName].types.push(...mappingValues);
+        } else {
+          p[c.discriminator.propertyName] = ts.unionType(mappingValues);
+        }
+        return p;
+      }, {} as Record<string, ts.UnionType<Builder>>);
+      result.type = ts.intersectionType([
+        ts.refs.omit([result.type, ts.unionType(Object.keys(fixedProperties).map((x) => ts.string(x)))]),
+        ts.objectType({
+          members: Object.entries(fixedProperties).map(([key, value]) =>
+            ts.property(key, { type: value, readonly: ctx.config.immutableTypes })
+          ),
+        }),
+      ]);
+    }
+
+    return result;
+  }
+
+  protected getEnumValuesVariable(ctx: Context, schema: ApiSchema): ts.Variable<Builder> {
+    const enumTypeName = this.getDeclarationTypeName(ctx, schema);
+    const values = schema.enum?.map((x) => ts.toNode(x)) ?? [];
+    return ts.variable(toCasing(`${enumTypeName}-Values`, ctx.config.constantNameCasing), {
+      doc: ts.doc({
+        description: `All possible values of the enum \`${enumTypeName}\`.`,
+      }),
+      export: true,
+      readonly: true,
+      value: ts.tuple(values, { asConst: true }),
+    });
+  }
+
+  protected getIndexer(ctx: Context, schema: ObjectLikeApiSchema): ts.Indexer<Builder> | null {
+    return schema.additionalProperties
+      ? ts.indexer(
+        ts.refs.string(),
+        (schema.additionalProperties === true ? null : this.getMemberType(ctx, schema.additionalProperties)) ??
+          this.getAnyType(ctx),
+        { readonly: ctx.config.immutableTypes },
+      )
+      : null;
+  }
+
+  protected getProperties(ctx: Context, schema: ObjectLikeApiSchema): ts.Property<Builder>[] {
+    return Array.from(schema.properties.values()).map((property) => {
+      return ts.property(property.name, {
+        doc: ts.doc({
+          description: this.getSchemaDocDescription(ctx, property.schema),
+          tags: [property.schema.deprecated ? ts.docTag('deprecated') : null],
+        }),
+        readonly: ctx.config.immutableTypes,
+        optional: !schema.required.has(property.name),
+        type: ts.unionType([this.getType(ctx, property.schema), property.schema.nullable ? 'null' : null]),
+      });
+    });
+  }
+
+  /**
+   * The type of a schema used as a *member* of an enclosing type - a composition branch, an array element, an
+   * `additionalProperties` value - with the schema's own nullability applied.
+   *
+   * `getType` renders a schema's type without its `null` on purpose: the two contexts that render a schema's type
+   * as a whole declare nullability themselves. A property has it added by `getProperties`, and a top-level type
+   * alias deliberately does not hoist it, because that would change what every declared type means for consumers.
+   * A member position has neither - nothing downstream can add the `null` back - so unless it is admitted here the
+   * emitted type cannot represent a value the spec explicitly permits.
+   */
+  protected getMemberType(
+    ctx: Context,
+    schema: Nullable<ApiSchema>,
+    options?: { skipSchemas?: boolean; useBaseType?: boolean },
+  ): ts.Type<Builder> | null {
+    const type = this.getType(ctx, schema, options);
+    return type !== null && schema && this.isNullableMember(schema) ? ts.unionType([type, 'null']) : type;
+  }
+
+  /**
+   * Whether a schema needs a `null` added to the type `getType` renders for it. A schema that only ever renders as
+   * `null` (the null type itself) already admits it, and adding a second one would emit `(null) | (null)`.
+   *
+   * Nullability is read through the reference chain the same way `getType` reads the type, so a `$ref` to a
+   * declared nullable schema - whose own declaration does not hoist the `null` - still admits null where it is used.
+   */
+  protected isNullableMember(schema: ApiSchema): boolean {
+    const resolved = getSchemaReference(schema, DEFAULT_IGNORED_SCHEMA_PROPERTIES);
+    if (resolved.kind === 'null') return false;
+    return schema.nullable === true || resolved.nullable === true;
+  }
+
+  protected getType(
+    ctx: Context,
+    schema: Nullable<ApiSchema>,
+    options?: { skipSchemas?: boolean; useBaseType?: boolean },
+  ): ts.Type<Builder> | null {
+    if (!schema) return this.getAnyType(ctx);
+
+    schema = getSchemaReference(schema, DEFAULT_IGNORED_SCHEMA_PROPERTIES);
+
+    if (options?.useBaseType && ctx.schema.inheritedSchemas.some((x) => x.id === schema.id)) {
+      return ts.reference(this.getBaseTypeName(ctx, schema), this.getFilePath(ctx, schema), {
+        importType: 'type-import',
+      });
+    }
+
+    if (!options?.skipSchemas && this.shouldGenerateTypeDeclaration(ctx, schema)) {
+      if (schema.id === ctx.schema.id) {
+        return null;
+      }
+      return ts.reference(this.getDeclarationTypeName(ctx, schema), this.getFilePath(ctx, schema), {
+        importType: 'type-import',
+      });
+    }
+
+    if (schema.enum) {
+      return ts.unionType(schema.enum.map((x) => ts.toNode(x)));
+    }
+
+    switch (schema.kind) {
+      case 'boolean':
+        return 'boolean';
+      case 'integer':
+      case 'number':
+        return 'number';
+      case 'string':
+        return this.getStringType(ctx, schema);
+      case 'null':
+        return 'null';
+      case 'unknown':
+        return this.getAnyType(ctx);
+      case 'array':
+        return this.getArrayType(ctx, schema);
+      case 'object':
+        return this.getObjectType(ctx, schema);
+      case 'combined':
+        return this.getCombinedType(ctx, schema);
+      case 'multi-type':
+        return this.getMultiType(ctx, schema);
+      case 'oneOf':
+        return this.getOneOfType(ctx, schema);
+      default:
+        return this.getAnyType(ctx);
+    }
+  }
+
+  protected getStringType(ctx: Context, schema: StringLikeApiSchema): ts.Type<Builder> {
+    if (schema.format === 'binary') {
+      return ctx.config.binarySchemaType();
+    }
+    return 'string';
+  }
+
+  protected getArrayType(ctx: Context, schema: ArrayLikeApiSchema): ts.Type<Builder> {
+    return ts.arrayType(this.getMemberType(ctx, schema.items) ?? this.getAnyType(ctx), {
+      readonly: ctx.config.immutableTypes,
+    });
+  }
+
+  protected getObjectType(ctx: Context, schema: ObjectLikeApiSchema): ts.Type<Builder> {
+    const parts = [
+      schema.properties.size > 0 ? ts.objectType({ members: this.getProperties(ctx, schema) }) : null,
+      schema.additionalProperties ? ts.objectType({ members: [this.getIndexer(ctx, schema)] }) : null,
+      schema.allOf.length > 0 || schema.anyOf.length > 0 ? this.getCombinedType(ctx, schema) : null,
+    ].filter(notNullish);
+    if (parts.length === 0) {
+      parts.push(
+        ts.objectType({
+          members: [ts.indexer(ts.refs.string(), ts.refs.never(), { readonly: ctx.config.immutableTypes })],
+        }),
+      );
+    }
+    return ts.intersectionType(parts);
+  }
+
+  protected getDiscriminatorType(ctx: Context, schema: ApiSchema): ts.Type<Builder> {
+    if (schema.discriminator && Object.keys(schema.discriminator.mapping).length > 0) {
+      const discriminator = schema.discriminator;
+      return ts.intersectionType([
+        this.getBaseTypeName(ctx, schema as ApiSchema),
+        ts.lookupType(
+          ts.objectType({
+            members: Object.entries(discriminator.mapping).map(([key, value]) =>
+              ts.property(key, {
+                type: ts.intersectionType([
+                  ts.objectType({
+                    members: [
+                      ts.property(discriminator.propertyName, {
+                        type: ts.string(key),
+                        readonly: ctx.config.immutableTypes,
+                      }),
+                    ],
+                  }),
+                  this.getType(ctx, value),
+                ]),
+              })
+            ),
+          }),
+          this.getDiscriminatorGenericParamName(ctx, schema as ApiSchema),
+        ),
+      ]);
+    } else {
+      return ts.refs.unknown();
+    }
+  }
+
+  protected getCombinedType(ctx: Context, schema: CombinedLikeApiSchema): ts.Type<Builder> {
+    if (schema.allOf.length === 0 && schema.anyOf.length === 0) {
+      return this.getAnyType(ctx);
+    }
+    const useBaseType = schema.id === ctx.schema.id;
+    // allOf branches must all hold at once, i.e. an intersection. anyOf branches only require at least one to hold,
+    // i.e. a union - TypeScript unions already admit values matching several branches, so no Partial<> wrapper is
+    // needed to express that overlap. A schema with both intersects the allOf branches with the anyOf union.
+    return ts.intersectionType([
+      ...schema.allOf.map((x) => this.getMemberType(ctx, x, { useBaseType })),
+      schema.anyOf.length > 0
+        ? ts.unionType(schema.anyOf.map((x) => this.getMemberType(ctx, x, { useBaseType })))
+        : null,
+    ]);
+  }
+
+  protected getOneOfType(ctx: Context, schema: ApiSchema<'oneOf'>): ts.Type<Builder> {
+    if (schema.oneOf.length === 0) {
+      return this.getAnyType(ctx);
+    }
+    return ts.unionType(schema.oneOf.map((x) => this.getMemberType(ctx, x)));
+  }
+
+  protected getMultiType(ctx: Context, schema: ApiSchema<'multi-type'>): ts.Type<Builder> {
+    if (schema.type.length === 0) {
+      return this.getAnyType(ctx);
+    }
+    return ts.unionType(
+      schema.type.map((x) => {
+        switch (x) {
+          case 'string':
+            return this.getStringType(ctx, schema);
+          case 'number':
+          case 'integer':
+            return 'number';
+          case 'boolean':
+            return 'boolean';
+          case 'null':
+            return 'null';
+          case 'array':
+            return this.getArrayType(ctx, schema);
+          case 'object':
+            return this.getObjectType(ctx, schema);
+          default:
+            return 'never';
+        }
+      }),
+    );
+  }
+
+  protected getSchemaDocDescription(ctx: Context, schema: ApiSchema): BasicAppendValue<Builder> {
+    const docSegments = [schema.description?.trim()];
+
+    if (ctx.config.includeSourceInDocs) {
+      docSegments.push(getSourceDocLine(schema));
+    }
+
+    return docSegments.filter(notNullish).join('\n\n');
+  }
+
+  protected shouldGenerateTypeDeclaration(ctx: Context, schema: ApiSchema): boolean {
+    // All named schemas should have its own type declaration
+    if (!schema.isNameGenerated) {
+      return true;
+    }
+
+    // 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 !== 'array' &&
+      schema.kind !== 'combined' &&
+      schema.kind !== 'multi-type' &&
+      schema.kind !== 'object' &&
+      schema.kind !== 'oneOf'
+    ) {
+      return false;
+    }
+
+    // Nullable by oneOf schemas do not need their own type declaration
+    if (schema.kind === 'oneOf' && schema.oneOf?.length === 2 && schema.oneOf.some((x) => x.kind === 'null')) {
+      return false;
+    }
+
+    // Dynamically generated schemas do not have its own type declaration
+    if (!ctx.data.schemas.some((x) => x.id === schema.id)) {
+      return false;
+    }
+
+    // Check if "real" schema
+    if (getSchemaReference(ctx.schema, DEFAULT_IGNORED_SCHEMA_PROPERTIES) !== ctx.schema) {
+      return false;
+    }
+
+    // For all other types, check if the user has enabled inline unnamed schemas
+    return !ctx.config.inlineUnnamedSchemas;
+  }
+
+  protected resolveInterfaceSchema(ctx: Context): ApiSchema<'object'> | undefined {
+    if (
+      ctx.config.typeDeclaration === 'prefer-interface' &&
+      (ctx.schema.kind === 'object' || ctx.schema.kind === 'combined')
+    ) {
+      return resolveAnyOfAndAllOf(ctx.schema, true);
+    }
+    return undefined;
+  }
+
+  protected getDeclarationTypeName(ctx: Context, schema: ApiSchema): string {
+    return toCasing(schema.name, ctx.config.typeNameCasing);
+  }
+
+  protected getDiscriminatorGenericParamName(ctx: Context, schema: ApiSchema): string {
+    return toCasing(schema.discriminator?.propertyName, ctx.config.genericParamNameCasing);
+  }
+
+  protected getDiscriminatorTypeName(ctx: Context, schema: ApiSchema): string {
+    return toCasing(schema.name + '_Discriminator', ctx.config.typeNameCasing);
+  }
+
+  protected getBaseTypeName(ctx: Context, schema: ApiSchema): string {
+    return toCasing(schema.name, ctx.config.discriminatorBaseTypeCasing);
+  }
+
+  protected getInheritedSchemas(ctx: Context, schema: ApiSchema): ApiSchema['inheritedSchemas'] {
+    return schema.inheritedSchemas
+      .filter((schema) => this.shouldGenerateTypeDeclaration(ctx, schema) && !schema.isNameGenerated)
+      .filter((item, index, self) => self.indexOf(item) === index);
+  }
+
+  protected getFilePath(ctx: Context, schema: ApiSchema): string {
+    return resolve(
+      ctx.config.outputDir,
+      ctx.config.modelsDir,
+      `${toCasing(schema.name, ctx.config.modelFileNameCasing ?? ctx.config.fileNameCasing)}.ts`,
+    );
+  }
+}

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

@@ -0,0 +1,108 @@
+import { resolve } from 'node:path';
+
+import {
+  type ApiSchema,
+  type AppendValueGroup,
+  appendValueGroup,
+  Factory,
+  type MaybePromise,
+  type OpenApiGeneratorContext,
+  OpenApiSchemasGenerationProviderBase,
+} from '@goast/core';
+
+import { ts } from '../../ast/index.js';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { DefaultTypeScriptModelGenerator, type TypeScriptModelGenerator } from './model-generator.js';
+import {
+  defaultTypeScriptModelsGeneratorConfig,
+  type TypeScriptModelGeneratorOutput,
+  type TypeScriptModelsGeneratorConfig,
+  type TypeScriptModelsGeneratorContext,
+  type TypeScriptModelsGeneratorInput,
+  type TypeScriptModelsGeneratorOutput,
+} from './models.js';
+
+type Input = TypeScriptModelsGeneratorInput;
+type Output = TypeScriptModelsGeneratorOutput;
+type Config = TypeScriptModelsGeneratorConfig;
+type SchemaOutput = TypeScriptModelGeneratorOutput;
+type Context = TypeScriptModelsGeneratorContext;
+
+export class TypeScriptModelsGenerator extends OpenApiSchemasGenerationProviderBase<
+  Input,
+  Output,
+  Config,
+  SchemaOutput,
+  Context
+> {
+  private readonly _modelGeneratorFactory: Factory<TypeScriptModelGenerator, []>;
+
+  constructor(modelGeneratorFactory?: Factory<TypeScriptModelGenerator, []>) {
+    super();
+    this._modelGeneratorFactory = modelGeneratorFactory ?? Factory.fromValue(new DefaultTypeScriptModelGenerator());
+  }
+
+  protected override initResult(): Output {
+    return {
+      typescript: {
+        models: {},
+        indexFiles: { models: undefined },
+      },
+    };
+  }
+
+  protected override buildContext(
+    context: OpenApiGeneratorContext<TypeScriptModelsGeneratorInput>,
+    config?: Partial<Config> | undefined,
+  ): Context {
+    return this.getProviderContext(context, config, defaultTypeScriptModelsGeneratorConfig);
+  }
+
+  protected override generateAdditionalFiles(ctx: TypeScriptModelsGeneratorContext): MaybePromise<void> {
+    ctx.output.typescript.indexFiles.models = this.generateIndexFile(ctx);
+  }
+
+  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.typescript.models[schema.id] = result;
+  }
+
+  protected generateIndexFile(ctx: Context): string | null {
+    const filePath = this.getIndexFilePath(ctx);
+    TypeScriptFileBuilder.tryGenerate({
+      logName: 'model index file',
+      filePath,
+      options: ctx.config,
+      generator: (b) => b.append(this.getIndexFileContent(ctx)),
+    });
+    return filePath;
+  }
+
+  protected getIndexFilePath(ctx: Context): string | null {
+    return ctx.config.modelsIndexFile ? resolve(ctx.config.outputDir, ctx.config.modelsIndexFile) : null;
+  }
+
+  protected getIndexFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder> {
+    return appendValueGroup(
+      Object.values(ctx.output.typescript.models).flatMap((x) => {
+        const { filePath } = x;
+        if (!filePath) return [];
+        return [
+          ts.export(x.component, filePath, {
+            kind: x.kind === 'type' || x.kind === 'interface' ? 'type-export' : 'export',
+          }),
+          ...(x.additionalExports?.map((e) =>
+            typeof e === 'string' ? ts.export(e, filePath) : ts.export(e.name, filePath, { kind: e.type })
+          ) ?? []),
+        ];
+      }),
+    );
+  }
+}