@goast/typescript 0.5.3 → 0.6.0-beta.1

package/src/src/generators/services/k6-clients/k6-client-generator.ts

@@ -1,465 +0,0 @@
-import { resolve } from 'node:path';
-
-import {
-  type ApiEndpoint,
-  type ApiResponse,
-  type ApiSchema,
-  type AppendValueGroup,
-  appendValueGroup,
-  builderTemplate as s,
-  type MaybePromise,
-  toCasing,
-} from '@goast/core';
-
-import { ts } from '../../../ast/index.js';
-import type { TypeScriptExportOutput } from '../../../common-results.js';
-import { TypeScriptFileBuilder } from '../../../file-builder.js';
-import type { TypeScriptImportOptions } from '../../../import-collection.js';
-import { TypeScriptFileGenerator } from '../../file-generator.js';
-import type { TypeScriptK6ClientGeneratorContext, TypeScriptK6ClientGeneratorOutput } from './models.js';
-
-type Context = TypeScriptK6ClientGeneratorContext;
-type Output = TypeScriptK6ClientGeneratorOutput;
-type Builder = TypeScriptFileBuilder;
-
-export interface TypeScriptK6ClientGenerator<TOutput extends Output = Output> {
-  generate(context: Context): MaybePromise<TOutput>;
-}
-
-export class DefaultTypeScriptK6ClientGenerator extends TypeScriptFileGenerator<Context, Output>
-  implements TypeScriptK6ClientGenerator {
-  public override generate(ctx: TypeScriptK6ClientGeneratorContext): MaybePromise<TypeScriptK6ClientGeneratorOutput> {
-    const responseModels = this.generateResponseModels(ctx);
-
-    const filePath = this.getFilePath(ctx);
-    const name = this.getClassName(ctx);
-
-    TypeScriptFileBuilder.generate({
-      logName: `k6 client ${name}`,
-      filePath,
-      options: ctx.config,
-      generator: (b) => b.append(this.getClientFileContent(ctx)),
-    });
-
-    return {
-      filePath,
-      component: name,
-      responseModels,
-    };
-  }
-
-  // #region Response Model
-  protected generateResponseModels(ctx: Context): Record<string, TypeScriptExportOutput> {
-    const result: Record<string, TypeScriptExportOutput> = {};
-    const filePath = this.getResponseModelFilePath(ctx);
-    const builder = new TypeScriptFileBuilder(filePath, ctx.config);
-
-    for (const endpoint of ctx.service.endpoints) {
-      const name = this.getResponseModelName(ctx, endpoint);
-      builder.appendLine(this.getResponseModelFileContent(ctx, endpoint));
-      result[endpoint.id] = { component: name, filePath };
-    }
-
-    builder.writeToFile();
-    return result;
-  }
-
-  protected getResponseModelFileContent(ctx: Context, endpoint: ApiEndpoint): AppendValueGroup<Builder> {
-    const result = appendValueGroup<Builder>([]);
-    const statusCodes = this.getEndpointStatusCodes(ctx, endpoint);
-    let statusCodeType: ts.Reference<Builder>;
-
-    const statusCodesTypeName = toCasing(`${endpoint.name}_StatusCodes`, ctx.config.typeNameCasing);
-    result.values.push(ts.typeAlias(statusCodesTypeName, ts.unionType(Object.keys(statusCodes))));
-    if (ctx.config.strictResponseTypes) {
-      statusCodeType = ts.reference(statusCodesTypeName);
-    } else {
-      statusCodeType = ctx.refs.httpStatusCode();
-    }
-
-    result.values.push(
-      ts.typeAlias(
-        this.getResponseModelName(ctx, endpoint),
-        ts.intersectionType([
-          ts.unionType([
-            ...Object.entries(statusCodes).map(([key, value]) => {
-              return ts.intersectionType<Builder>([
-                ts.refs.omit([ts.refs.k6.response(), ts.string('json')]),
-                ts.objectType({
-                  members: [
-                    ts.property('status', { type: key }),
-                    ts.method('json', {
-                      returnType: value.type,
-                    }),
-                    ts.method('json', {
-                      parameters: [ts.parameter('selector', { type: ts.refs.string() })],
-                      returnType: ts.refs.k6.jsonValue(),
-                    }),
-                  ],
-                }),
-              ]);
-            }),
-            !ctx.config.strictResponseTypes
-              ? ts.intersectionType([
-                ts.refs.k6.response(),
-                ts.objectType({
-                  members: [
-                    ts.property('status', {
-                      type: ts.refs.exclude([ctx.refs.httpStatusCode(), ts.reference(statusCodesTypeName)]),
-                    }),
-                  ],
-                }),
-              ])
-              : null,
-          ]),
-          ts.objectType({ members: [ts.property('status', { type: 'TStatus' })] }),
-        ]),
-        {
-          doc: ts.doc({
-            description: `Response model for operation ${this.getEndpointMethodName(ctx, endpoint)}`,
-            tags: [endpoint.deprecated ? ts.docTag('deprecated') : null],
-          }),
-          export: true,
-          generics: [
-            ts.genericParameter('TStatus', {
-              constraint: statusCodeType,
-              default: statusCodeType,
-            }),
-          ],
-        },
-      ),
-    );
-
-    return result;
-  }
-
-  protected getEndpointStatusCodes(ctx: Context, endpoint: ApiEndpoint): Record<number, { type: ts.Type<Builder> }> {
-    return Object.fromEntries([
-      ...Object.entries(ctx.config.defaultStatusCodeResponseTypes).map(([key, value]) => [
-        key,
-        {
-          parser: value?.parser ?? 'text',
-          type: typeof value?.type === 'function'
-            ? this.getSchemaType(ctx, value.type(ctx.data.schemas))
-            : value ?? ts.refs.never(),
-        },
-      ]),
-      ...endpoint.responses
-        .filter((x) => x.statusCode)
-        .map((x) => [
-          x.statusCode,
-          {
-            type: this.getSchemaType(ctx, x.contentOptions[0]?.schema, { fallback: ts.refs.never() }),
-          },
-        ]),
-    ]);
-  }
-  // #endregion
-
-  protected getClientFileContent(ctx: Context): AppendValueGroup<Builder> {
-    const code = appendValueGroup<Builder>([], '\n');
-    for (const endpoint of ctx.service.endpoints) {
-      if (endpoint.parameters.length > 0 || endpoint.requestBody !== undefined) {
-        code.values.push(this.getEndpointParamsType(ctx, endpoint));
-      }
-    }
-    code.values.push(
-      appendValueGroup<Builder>(
-        ctx.service.endpoints.map((e) =>
-          ts.variable(this.getEndpointPathPropertyName(ctx, e), {
-            readonly: true,
-            value: ts.string(e.path),
-          })
-        ),
-      ),
-    );
-    code.values.push(this.getClass(ctx));
-    return code;
-  }
-
-  protected getEndpointParamsType(ctx: Context, endpoint: ApiEndpoint): ts.Doc<Builder> | ts.TypeAlias<Builder> {
-    const importOptions: TypeScriptImportOptions = ctx.config.language === 'javascript' ? { type: 'js-doc' } : {};
-    const description = `Parameters for operation ${this.getEndpointMethodName(ctx, endpoint)}`;
-    const typeName = this.getEndpointParamsTypeName(ctx, endpoint);
-    const properties: { name: string; type: ts.Type<Builder>; description: string | undefined; required: boolean }[] =
-      endpoint.parameters.map((parameter) => {
-        const schema = parameter.schema;
-        return {
-          name: toCasing(parameter.name, ctx.config.propertyNameCasing),
-          type: schema
-            ? (b) => b.appendModelUsage(ctx.input.typescript.models[schema.id], importOptions)
-            : this.getAnyType(ctx),
-          description: (parameter.deprecated ? 'Deprecated: ' : '') + parameter.description,
-          required: parameter.required,
-        };
-      });
-
-    if (endpoint.requestBody !== undefined) {
-      const body = endpoint.requestBody;
-      const schema = body.content[0].schema;
-      properties.push({
-        name: 'body',
-        type: schema
-          ? (b) => b.appendModelUsage(ctx.input.typescript.models[schema.id], importOptions)
-          : this.getAnyType(ctx),
-        description: body.description,
-        required: body.required,
-      });
-    }
-
-    if (ctx.config.language === 'javascript') {
-      return ts.doc<Builder>({
-        description,
-        tags: [
-          ts.docTag('typedef', typeName),
-          ...properties.map((p) =>
-            ts.docTag<'property', Builder>('property', p.required ? p.name : `[${p.name}]`, {
-              type: p.type,
-              text: p.description,
-            })
-          ),
-        ],
-      });
-    } else {
-      return ts.typeAlias<Builder>(
-        typeName,
-        ts.objectType({
-          members: properties.map((p) =>
-            ts.property(p.name, {
-              type: p.type,
-              optional: !p.required,
-              doc: p.description ? ts.doc({ description: p.description }) : undefined,
-            })
-          ),
-        }),
-      );
-    }
-  }
-
-  protected getClass(ctx: Context): ts.Class<Builder> {
-    const isJs = ctx.config.language === 'javascript';
-    const rootUrlType = ts.refs.string();
-    const paramType = ts.functionType({
-      returnType: ts.refs.k6.params({ importType: isJs ? 'js-doc' : 'type-import' }),
-    });
-    return ts.class<Builder>(this.getClassName(ctx), {
-      doc: ts.doc({
-        description: ctx.service.description,
-        tags: [
-          isJs ? ts.docTag('property', 'rootUrl', 'The root URL for this client.', { type: ts.refs.string() }) : null,
-          ctx.service.endpoints.length === 0 || ctx.service.endpoints.some((x) => !x.deprecated)
-            ? null
-            : ts.docTag('deprecated'),
-        ],
-      }),
-      export: true,
-      members: [
-        ...(isJs ? [] : [
-          ts.property('rootUrl', {
-            type: rootUrlType,
-            readonly: true,
-            accessModifier: 'public',
-            doc: ts.doc({ description: 'The root URL for this client.' }),
-          }),
-          ts.property('_defaultK6ParamsFactory', {
-            type: paramType,
-            optional: true,
-            readonly: true,
-            accessModifier: 'private',
-            doc: ts.doc({ description: 'A factory function that returns the default K6 parameters.' }),
-          }),
-        ]),
-        ts.constructor({
-          doc: ts.doc({
-            description: 'Creates a new instance of the client.',
-            tags: [
-              ts.docTag('param', 'rootUrl', 'The root URL for this client.', { type: isJs ? rootUrlType : undefined }),
-              ts.docTag(
-                'param',
-                '[defaultK6ParamsFactory]',
-                'A factory function that returns the default K6 parameters.',
-                { type: isJs ? paramType : undefined },
-              ),
-            ],
-          }),
-          parameters: [
-            ts.constructorParameter('rootUrl', { type: isJs ? undefined : rootUrlType }),
-            ts.constructorParameter('defaultK6ParamsFactory', { type: isJs ? undefined : paramType, optional: true }),
-          ],
-          body: s`this.rootUrl = rootUrl;
-                  this._defaultK6ParamsFactory = defaultK6ParamsFactory;`,
-        }),
-        ...ctx.service.endpoints.map((e) => this.getEndpointMethod(ctx, e)),
-        this.getGetK6ParamsMethod(ctx),
-      ],
-    });
-  }
-
-  protected getEndpointMethod(ctx: Context, endpoint: ApiEndpoint): ts.Method<Builder> {
-    const isJs = ctx.config.language === 'javascript';
-    const hasParams = this.hasEndpointParams(ctx, endpoint);
-    const paramsOptional = !endpoint.parameters.some((p) => p.required) && !endpoint.requestBody?.required;
-    const responseModelType = ts.reference(
-      this.getResponseModelName(ctx, endpoint),
-      this.getResponseModelFilePath(ctx),
-      { importType: ctx.config.language === 'javascript' ? 'js-doc' : 'type-import' },
-    );
-    const returnType = responseModelType;
-    const accept = this.getEndpointSuccessResponse(ctx, endpoint)?.contentOptions[0]?.type ?? '*/*';
-    const paramsType = hasParams ? ts.reference(this.getEndpointParamsTypeName(ctx, endpoint)) : null;
-    const returnTypeWithPromise = ctx.config.async ? ts.refs.promise([returnType]) : returnType;
-
-    return ts.method<Builder>(this.getEndpointMethodName(ctx, endpoint), {
-      async: ctx.config.async,
-      parameters: [
-        hasParams ? ts.parameter('params', { type: isJs ? null : paramsType }) : null,
-        ts.parameter('k6Params', { type: isJs ? null : ts.refs.k6.params({ importType: 'type-import' }) }),
-      ],
-      returnType: isJs ? null : returnTypeWithPromise,
-      doc: ts.doc({
-        description: endpoint.description,
-        tags: isJs
-          ? [
-            hasParams ? ts.docTag('param', paramsOptional ? '[params]' : 'params', { type: paramsType }) : null,
-            ts.docTag('param', '[k6Params]', { type: ts.refs.k6.params({ importType: 'js-doc' }) }),
-            ts.docTag('returns', { type: returnTypeWithPromise }),
-            endpoint.deprecated ? ts.docTag('deprecated') : null,
-          ]
-          : [],
-      }),
-      accessModifier: isJs ? null : 'public',
-      body: appendValueGroup(
-        [
-          s`const rb = new ${ctx.refs.requestBuilder()}(this.rootUrl, ${
-            this.getEndpointPathPropertyName(ctx, endpoint)
-          }, '${endpoint.method}');`,
-          hasParams
-            ? (b) =>
-              b.appendIf(paramsOptional, 'if (params) ').parenthesizeIf(
-                paramsOptional,
-                '{}',
-                appendValueGroup(
-                  [
-                    ...endpoint.parameters
-                      .filter((p) => p.target === 'path' || p.target === 'query' || p.target === 'header')
-                      .map((p) => {
-                        const options = ts.object({
-                          members: [
-                            p.style !== undefined ? ts.property('style', { value: ts.string(p.style) }) : null,
-                            p.explode !== undefined ? ts.property('explode', { value: ts.toNode(p.explode) }) : null,
-                          ],
-                        });
-                        return s<Builder>`rb.${p.target}(${ts.string(p.name)}, params.${
-                          toCasing(
-                            p.name,
-                            ctx.config.propertyNameCasing,
-                          )
-                        }, ${options});`;
-                      }),
-                    endpoint.requestBody
-                      ? s`rb.body(params.body, ${
-                        ts.string(endpoint.requestBody.content[0].type ?? 'application/json')
-                      });`
-                      : null,
-                  ],
-                  '\n',
-                ),
-                { multiline: true },
-              )
-            : null,
-          '',
-          ctx.config.language === 'javascript'
-            ? s`return /** @type {${returnType}} */ (${s.indent`
-                ${ctx.config.async ? 'await rb.buildAsync' : 'rb.build'}({${s.indent`
-                  accept: ${ts.string(accept)},
-                  params: this.getK6Params(k6Params),`}
-                })`}
-              );`
-            : s`return (${s.indent`
-                ${ctx.config.async ? 'await rb.buildAsync' : 'rb.build'}({${s.indent`
-                  accept: ${ts.string(accept)},
-                  params: this.getK6Params(k6Params),`}
-                })`}
-              ) as unknown as ${returnType};`,
-        ],
-        '\n',
-      ),
-    });
-  }
-
-  protected getGetK6ParamsMethod(ctx: Context): ts.Method<Builder> {
-    const isJs = ctx.config.language === 'javascript';
-    return ts.method('getK6Params', {
-      accessModifier: isJs ? null : 'private',
-      doc: isJs
-        ? ts.doc({
-          tags: [
-            ts.docTag('private'),
-            ts.docTag('param', '[k6Params]', { type: ts.refs.k6.params({ importType: 'js-doc' }) }),
-          ],
-        })
-        : null,
-      parameters: [ts.parameter('k6Params', { type: isJs ? null : ts.refs.k6.params({ importType: 'type-import' }) })],
-      body: s`return Object.assign({}, this._defaultK6ParamsFactory ? this._defaultK6ParamsFactory() : {}, k6Params);`,
-    });
-  }
-
-  protected getEndpointSuccessResponse(_ctx: Context, endpoint: ApiEndpoint): ApiResponse | undefined {
-    return (
-      endpoint.responses.find((x) => x.statusCode && x.statusCode >= 200 && x.statusCode < 300) ??
-        endpoint.responses.find((x) => x.statusCode === undefined)
-    );
-  }
-
-  protected getSchemaType(
-    ctx: Context,
-    schema: ApiSchema | undefined,
-    options?: TypeScriptImportOptions & { fallback?: ts.Type<Builder> },
-  ): ts.Type<Builder> {
-    const output = schema && ctx.input.typescript.models[schema.id];
-    if (!output) return options?.fallback ?? this.getAnyType(ctx);
-    return (b) => b.appendModelUsage(output, options);
-  }
-
-  protected getClassName(ctx: Context): string {
-    return toCasing(ctx.service.name, ctx.config.clientNameCasing ?? ctx.config.typeNameCasing);
-  }
-
-  protected getResponseModelName(ctx: Context, endpoint: ApiEndpoint): string {
-    return toCasing(`${this.getEndpointMethodName(ctx, endpoint)}ApiResponse`, ctx.config.typeNameCasing);
-  }
-
-  protected getEndpointParamsTypeName(ctx: Context, endpoint: ApiEndpoint): string {
-    return toCasing(this.getEndpointMethodName(ctx, endpoint) + '_Params', ctx.config.typeNameCasing);
-  }
-
-  protected getEndpointPathPropertyName(ctx: Context, endpoint: ApiEndpoint): string {
-    return toCasing(this.getEndpointMethodName(ctx, endpoint) + '_Path', ctx.config.constantNameCasing);
-  }
-
-  protected getEndpointMethodName(ctx: Context, endpoint: ApiEndpoint): string {
-    return toCasing(endpoint.name, ctx.config.functionNameCasing);
-  }
-
-  protected getFilePath(ctx: Context): string {
-    return resolve(
-      ctx.config.outputDir,
-      ctx.config.clientDir,
-      `${toCasing(ctx.service.name, ctx.config.clientFileNameCasing ?? ctx.config.fileNameCasing)}.${
-        ctx.config.language === 'typescript' ? 'ts' : 'js'
-      }`,
-    );
-  }
-
-  protected getResponseModelFilePath(ctx: Context): string {
-    return resolve(
-      ctx.config.outputDir,
-      ctx.config.responseModelsDir,
-      `${toCasing(ctx.service.name, ctx.config.responseModelFileNameCasing ?? ctx.config.fileNameCasing)}.ts`,
-    );
-  }
-
-  protected hasEndpointParams(_ctx: Context, endpoint: ApiEndpoint): boolean {
-    return endpoint.parameters.length > 0 || endpoint.requestBody !== undefined;
-  }
-}

package/src/src/generators/services/k6-clients/k6-clients-generator.ts

@@ -1,171 +0,0 @@
-import { resolve } from 'node:path';
-
-
-import fs from 'fs-extra';
-
-import {
-  type ApiService,
-  type AppendValueGroup,
-  appendValueGroup,
-  Factory,
-  type MaybePromise,
-  type OpenApiGeneratorContext,
-  OpenApiServicesGenerationProviderBase,
-} from '@goast/core';
-
-import { copyAssetFile } from '../../../assets.js';
-import { ts } from '../../../ast/index.js';
-import { TypeScriptFileBuilder } from '../../../file-builder.js';
-import { DefaultTypeScriptK6ClientGenerator, type TypeScriptK6ClientGenerator } from './k6-client-generator.js';
-import {
-  defaultTypeScriptK6ClientsGeneratorConfig,
-  type TypeScriptK6ClientGeneratorOutput,
-  type TypeScriptK6ClientsGeneratorConfig,
-  type TypeScriptK6ClientsGeneratorContext,
-  type TypeScriptK6ClientsGeneratorInput,
-  type TypeScriptK6ClientsGeneratorOutput,
-} from './models.js';
-import { getReferenceFactories } from './refs.js';
-
-type Input = TypeScriptK6ClientsGeneratorInput;
-type Output = TypeScriptK6ClientsGeneratorOutput;
-type Config = TypeScriptK6ClientsGeneratorConfig;
-type ServiceOutput = TypeScriptK6ClientGeneratorOutput;
-type Context = TypeScriptK6ClientsGeneratorContext;
-
-export class TypeScriptK6ClientsGenerator extends OpenApiServicesGenerationProviderBase<
-  Input,
-  Output,
-  Config,
-  ServiceOutput,
-  Context
-> {
-  private readonly _clientGeneratorFactory: Factory<TypeScriptK6ClientGenerator, []>;
-
-  constructor(clientGeneratorFactory?: Factory<TypeScriptK6ClientGenerator, []>) {
-    super();
-    this._clientGeneratorFactory = clientGeneratorFactory ??
-      Factory.fromValue(new DefaultTypeScriptK6ClientGenerator());
-  }
-
-  protected override initResult(): Output {
-    return {
-      typescript: {
-        k6Clients: {},
-        indexFiles: {
-          k6Clients: undefined,
-          k6ResponseModels: undefined,
-        },
-      },
-    };
-  }
-
-  protected override buildContext(
-    context: OpenApiGeneratorContext<Input>,
-    config?: Partial<Config> | undefined,
-  ): Context {
-    const providerContext = this.getProviderContext(context, config, defaultTypeScriptK6ClientsGeneratorConfig);
-    return Object.assign(providerContext, {
-      refs: getReferenceFactories(providerContext.config),
-    });
-  }
-
-  protected override async generateAdditionalFiles(ctx: TypeScriptK6ClientsGeneratorContext): Promise<void> {
-    await this.generateUtilsFiles(ctx);
-    ctx.output.typescript.indexFiles = this.generateIndexFiles(ctx);
-  }
-
-  protected override generateService(ctx: Context, service: ApiService): MaybePromise<ServiceOutput> {
-    const clientGenerator = this._clientGeneratorFactory.create();
-    return clientGenerator.generate({
-      ...ctx,
-      service,
-    });
-  }
-
-  protected override addServiceResult(ctx: Context, service: ApiService, result: ServiceOutput): void {
-    ctx.output.typescript.k6Clients[service.id] = result;
-  }
-
-  protected async generateUtilsFiles(ctx: Context): Promise<void> {
-    const targetDir = resolve(ctx.config.outputDir, ctx.config.utilsDir);
-    await fs.ensureDir(targetDir);
-
-    const ext = ctx.config.language === 'javascript' ? '.js' : '.ts';
-    await copyAssetFile(`client/k6/request-builder${ext}`, targetDir, 'Request Builder');
-
-    if (!ctx.config.strictResponseTypes) {
-      TypeScriptFileBuilder.generate({
-        logName: 'http status codes',
-        filePath: resolve(targetDir, 'http-status-code.ts'),
-        options: ctx.config,
-        generator: (b) => b.append(this.getHttpStatusCodeFileContent(ctx)),
-      });
-    }
-  }
-
-  protected getHttpStatusCodeFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder> {
-    return appendValueGroup(
-      [
-        ts.typeAlias('HttpStatusCode', ts.unionType(ctx.config.possibleStatusCodes), {
-          doc: ts.doc({ description: 'The possible status codes that any API endpoint can return.' }),
-          export: true,
-        }),
-      ],
-      '\n',
-    );
-  }
-
-  protected generateIndexFiles(ctx: Context): Output['typescript']['indexFiles'] {
-    const clientsIndexFilePath = this.getIndexFilePath(ctx);
-    const responseModelsIndexFilePath = this.getResponseModelsIndexFilePath(ctx);
-
-    TypeScriptFileBuilder.tryGenerate({
-      logName: 'clients index file',
-      filePath: clientsIndexFilePath,
-      options: ctx.config,
-      generator: (b) => b.append(this.getIndexFileContent(ctx)),
-    });
-
-    TypeScriptFileBuilder.tryGenerate({
-      logName: 'response models index file',
-      filePath: responseModelsIndexFilePath,
-      options: ctx.config,
-      generator: (b) => b.append(this.getResponseModelsIndexFileContent(ctx)),
-    });
-
-    return {
-      k6Clients: clientsIndexFilePath,
-      k6ResponseModels: responseModelsIndexFilePath,
-    };
-  }
-
-  protected getIndexFilePath(ctx: Context): string | null {
-    return ctx.config.clientsIndexFile
-      ? resolve(
-        ctx.config.outputDir,
-        ctx.config.clientsIndexFile.replace(/\.[jt]s$/, ctx.config.language === 'javascript' ? '.js' : '.ts'),
-      )
-      : null;
-  }
-
-  protected getResponseModelsIndexFilePath(ctx: Context): string | null {
-    return ctx.config.responseModelsIndexFile
-      ? resolve(ctx.config.outputDir, ctx.config.responseModelsIndexFile)
-      : null;
-  }
-
-  protected getIndexFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder> {
-    return appendValueGroup(
-      Object.values(ctx.output.typescript.k6Clients).map((x) => ts.export(x.component, x.filePath)),
-    );
-  }
-
-  protected getResponseModelsIndexFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder> {
-    return appendValueGroup(
-      Object.values(ctx.output.typescript.k6Clients)
-        .flatMap((x) => Object.values(x.responseModels))
-        .map((x) => ts.export(x.component, x.filePath)),
-    );
-  }
-}