@goast/typescript 0.5.3 → 0.6.0-beta.2

package/src/src/generators/services/easy-network-stub/easy-network-stubs-generator.ts

@@ -1,211 +0,0 @@
-import { resolve } from 'node:path';
-
-
-import fs from 'fs-extra';
-
-import {
-  adjustCasing,
-  type ApiService,
-  type AppendValueGroup,
-  appendValueGroup,
-  builderTemplate as s,
-  Factory,
-  type MaybePromise,
-  type OpenApiGeneratorContext,
-  OpenApiServicesGenerationProviderBase,
-  toCasing,
-} from '@goast/core';
-
-import { copyAssetFile } from '../../../assets.js';
-import { ts } from '../../../ast/index.js';
-import type { TypeScriptExportOutput } from '../../../common-results.js';
-import { TypeScriptFileBuilder } from '../../../file-builder.js';
-import {
-  DefaultTypeScriptEasyNetworkStubGenerator,
-  type TypeScriptEasyNetworkStubGenerator,
-} from './easy-network-stub-generator.js';
-import {
-  defaultTypeScriptEasyNetworkStubsGeneratorConfig,
-  type TypeScriptEasyNetworkStubGeneratorOutput,
-  type TypeScriptEasyNetworkStubsGeneratorConfig,
-  type TypeScriptEasyNetworkStubsGeneratorContext,
-  type TypeScriptEasyNetworkStubsGeneratorInput,
-  type TypeScriptEasyNetworkStubsGeneratorOutput,
-} from './models.js';
-import { getReferenceFactories } from './refs.js';
-
-type Input = TypeScriptEasyNetworkStubsGeneratorInput;
-type Output = TypeScriptEasyNetworkStubsGeneratorOutput;
-type Config = TypeScriptEasyNetworkStubsGeneratorConfig;
-type ServiceOutput = TypeScriptEasyNetworkStubGeneratorOutput;
-type Context = TypeScriptEasyNetworkStubsGeneratorContext;
-
-export class TypeScriptEasyNetworkStubsGenerator extends OpenApiServicesGenerationProviderBase<
-  Input,
-  Output,
-  Config,
-  ServiceOutput,
-  Context
-> {
-  private readonly _generatorFactory: Factory<TypeScriptEasyNetworkStubGenerator, []>;
-
-  constructor(generatorFactory?: Factory<TypeScriptEasyNetworkStubGenerator, []>) {
-    super();
-    this._generatorFactory = generatorFactory ?? Factory.fromValue(new DefaultTypeScriptEasyNetworkStubGenerator());
-  }
-
-  protected override initResult(): Output {
-    return {
-      typescript: {
-        stubs: {},
-        indexFiles: { stubs: undefined },
-      },
-    };
-  }
-
-  protected override buildContext(
-    context: OpenApiGeneratorContext<Input>,
-    config?: Partial<Config> | undefined,
-  ): Context {
-    const providerContext = this.getProviderContext(context, config, defaultTypeScriptEasyNetworkStubsGeneratorConfig);
-    return Object.assign(providerContext, {
-      refs: getReferenceFactories(providerContext.config),
-    });
-  }
-
-  protected override async generateAdditionalFiles(ctx: TypeScriptEasyNetworkStubsGeneratorContext): Promise<void> {
-    await this.generateUtilsFiles(ctx);
-    ctx.output.typescript.indexFiles = this.generateIndexFiles(ctx);
-  }
-
-  protected override generateService(ctx: Context, service: ApiService): MaybePromise<TypeScriptExportOutput> {
-    const clientGenerator = this._generatorFactory.create();
-    return clientGenerator.generate({
-      ...ctx,
-      service,
-    });
-  }
-
-  protected override addServiceResult(ctx: Context, service: ApiService, result: TypeScriptExportOutput): void {
-    ctx.output.typescript.stubs[service.id] = result;
-  }
-
-  protected async generateUtilsFiles(ctx: Context): Promise<void> {
-    const targetDir = resolve(ctx.config.outputDir, ctx.config.utilsDir);
-    await fs.ensureDir(targetDir);
-
-    await copyAssetFile('stubs/easy-network-stub/easy-network-stub.utils.ts', targetDir, 'easy-network-stub utils');
-  }
-
-  protected generateIndexFiles(ctx: Context): Output['typescript']['indexFiles'] {
-    const stubsIndexFilePath = this.getStubsIndexFilePath(ctx);
-
-    TypeScriptFileBuilder.tryGenerate({
-      logName: 'stubs index file',
-      filePath: stubsIndexFilePath,
-      options: ctx.config,
-      generator: (b) => b.append(this.getStubsIndexFileContent(ctx)),
-    });
-
-    return {
-      stubs: stubsIndexFilePath,
-    };
-  }
-
-  protected getStubsIndexFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder> {
-    return appendValueGroup(
-      [
-        appendValueGroup(Object.values(ctx.output.typescript.stubs).map((x) => ts.export(x.component, x.filePath))),
-        this.getStubsClass(ctx),
-      ],
-      '\n',
-    );
-  }
-
-  protected getStubsClass(ctx: Context): ts.Class<TypeScriptFileBuilder> {
-    const fieldCasing = adjustCasing(ctx.config.propertyNameCasing, { prefix: '_' });
-    const serviceNames = Object.fromEntries(ctx.data.services.map((x) => [x.id, x.name]));
-    return ts.class(this.getStubsClassName(ctx), {
-      export: true,
-      members: [
-        ts.property('_stubWrapper', {
-          accessModifier: 'private',
-          readonly: true,
-          type: ctx.refs.easyNetworkStubWrapper(),
-        }),
-        ...Object.entries(ctx.output.typescript.stubs).map(([id, x]) =>
-          ts.property<TypeScriptFileBuilder>(toCasing(serviceNames[id], fieldCasing), {
-            accessModifier: 'private',
-            optional: true,
-            type: ctx.refs.easyNetworkStubGroup([ts.reference(x.component, x.filePath), 'this']),
-          })
-        ),
-        ts.constructor({
-          parameters: [
-            ts.constructorParameter('stub', { type: ts.refs.easyNetworkStub.easyNetworkStub() }),
-            ts.constructorParameter('options', {
-              type: ts.refs.partial([ctx.refs.easyNetworkStubWrapperOptions()]),
-              optional: true,
-            }),
-          ],
-          body: appendValueGroup(
-            [s`this._stubWrapper = new ${ctx.refs.easyNetworkStubWrapper()}(stub, options);`],
-            '\n',
-          ),
-        }),
-        ts.property('requests', {
-          accessModifier: 'public',
-          type: ts.arrayType(ctx.refs.stubRequestItem(), { readonly: true }),
-          get: ts.property.getter({
-            body: appendValueGroup(['return this._stubWrapper.requests;'], '\n'),
-          }),
-        }),
-        ...Object.entries(ctx.output.typescript.stubs).map(([id, x]) =>
-          ts.property<TypeScriptFileBuilder>(toCasing(serviceNames[id], ctx.config.propertyNameCasing), {
-            accessModifier: 'public',
-            type: ctx.refs.easyNetworkStubGroup([ts.reference(x.component, x.filePath), 'this']),
-            get: ts.property.getter({
-              body: appendValueGroup(
-                [
-                  s`return this.${
-                    toCasing(
-                      serviceNames[id],
-                      fieldCasing,
-                    )
-                  } ??= ${ctx.refs.createEasyNetworkStubGroup.infer()}(this, this._stubWrapper, ${
-                    ts.reference(
-                      x.component,
-                      x.filePath,
-                    )
-                  });`,
-                ],
-                '\n',
-              ),
-            }),
-          })
-        ),
-        ts.method('resetStubs', {
-          accessModifier: 'public',
-          returnType: 'this',
-          body: appendValueGroup(
-            [
-              ...Object.keys(ctx.output.typescript.stubs).map((id) =>
-                `this.${toCasing(serviceNames[id], fieldCasing)}?.reset();`
-              ),
-              'return this;',
-            ],
-            '\n',
-          ),
-        }),
-      ],
-    });
-  }
-
-  protected getStubsIndexFilePath(ctx: Context): string | null {
-    return ctx.config.stubsIndexFile ? resolve(ctx.config.outputDir, ctx.config.stubsIndexFile) : null;
-  }
-
-  protected getStubsClassName(ctx: Context): string {
-    return toCasing(`${ctx.config.domainName ?? ''}_ApiStubs`, ctx.config.typeNameCasing);
-  }
-}

package/src/src/generators/services/easy-network-stub/index.ts

@@ -1,3 +0,0 @@
-export * from './easy-network-stub-generator.js';
-export * from './easy-network-stubs-generator.js';
-export * from './models.js';

package/src/src/generators/services/easy-network-stub/models.ts

@@ -1,124 +0,0 @@
-import type {
-  ApiSchema,
-  ApiService,
-  DefaultGenerationProviderConfig,
-  ExtendedStringCasing,
-  Nullable,
-  OpenApiServicesGenerationProviderContext,
-} from '@goast/core';
-
-import { ts } from '../../../ast/index.js';
-import type { TypeScriptExportOutput } from '../../../common-results.js';
-import { defaultTypeScriptGeneratorConfig, type TypeScriptGeneratorConfig } from '../../../config.js';
-import type { TypeScriptFileBuilder } from '../../../file-builder.js';
-import type { TypeScriptModelGeneratorOutput } from '../../models/index.js';
-import type { getReferenceFactories } from './refs.js';
-
-export type TypeScriptEasyNetworkStubsGeneratorConfig = TypeScriptGeneratorConfig & {
-  /**
-   * The domain name of the API. Used as a prefix for exported components (e.g. `ApiStubs`).
-   * @default undefined
-   */
-  domainName: Nullable<string>;
-
-  /**
-   * The default response types for status codes that are not defined in the OpenAPI specification.
-   * @example
-   * {
-   *   400: schemas =>
-   *     schemas.find(s => s.name === 'BadRequestResponse')
-   *       ?? throwExp('BadRequestResponse not found'),
-   *   404: 'never',
-   *   500: ts.refs.any(),
-   * }
-   * @default
-   * {
-   *   401: ts.refs.never(),
-   *   403: ts.refs.never(),
-   *   500: ts.refs.never(),
-   * }
-   */
-  defaultStatusCodeResponseTypes: Record<
-    number,
-    // deno-lint-ignore ban-types
-    Exclude<ts.Type<TypeScriptFileBuilder>, Function> | ((schemas: readonly ApiSchema[]) => ApiSchema)
-  >;
-
-  /**
-   * The directory where the stubs should be saved. The path is relative to the output directory.
-   * @default 'stubs'
-   */
-  stubsDir: string;
-
-  /**
-   * The casing of the stub file names. If nullish, the `fileNameCasing` is used.
-   * @default { casing: 'kebab', suffix: '.stubs' }
-   */
-  stubFileNameCasing: Nullable<ExtendedStringCasing>;
-
-  /**
-   * The index file where all stubs should be exported. The path is relative to the output directory. If nullish, no index file will be generated.
-   * @default 'stubs.ts'
-   */
-  stubsIndexFile: Nullable<string>;
-
-  /**
-   * The directory where the utilies should be saved. The path is relative to the output directory.
-   * @default 'utils'
-   */
-  utilsDir: string;
-};
-
-export const defaultTypeScriptEasyNetworkStubsGeneratorConfig: DefaultGenerationProviderConfig<
-  TypeScriptEasyNetworkStubsGeneratorConfig
-> = {
-  ...defaultTypeScriptGeneratorConfig,
-
-  domainName: undefined,
-  defaultStatusCodeResponseTypes: {
-    401: ts.refs.never(),
-    403: ts.refs.never(),
-    500: ts.refs.never(),
-  },
-
-  stubsDir: 'stubs',
-  stubFileNameCasing: { casing: 'kebab', suffix: '.stubs' },
-  stubsIndexFile: 'stubs.ts',
-  utilsDir: 'utils',
-};
-
-export type TypeScriptEasyNetworkStubsGeneratorInput = {
-  typescript: {
-    models: {
-      [schemaId: string]: TypeScriptModelGeneratorOutput;
-    };
-  };
-};
-
-export type TypeScriptEasyNetworkStubsGeneratorOutput = {
-  typescript: {
-    stubs: {
-      [serviceId: string]: TypeScriptEasyNetworkStubGeneratorOutput;
-    };
-    indexFiles: {
-      stubs: Nullable<string>;
-    };
-  };
-};
-
-export type TypeScriptEasyNetworkStubGeneratorOutput = TypeScriptExportOutput;
-
-export type TypeScriptEasyNetworkStubsGeneratorContext =
-  & OpenApiServicesGenerationProviderContext<
-    TypeScriptEasyNetworkStubsGeneratorInput,
-    TypeScriptEasyNetworkStubsGeneratorOutput,
-    TypeScriptEasyNetworkStubsGeneratorConfig,
-    TypeScriptEasyNetworkStubGeneratorOutput
-  >
-  & {
-    refs: ReturnType<typeof getReferenceFactories>;
-  };
-
-export type TypeScriptEasyNetworkStubGeneratorContext = TypeScriptEasyNetworkStubsGeneratorContext & {
-  readonly service: ApiService;
-};

package/src/src/generators/services/easy-network-stub/refs.ts

@@ -1,45 +0,0 @@
-import { join, resolve } from 'node:path';
-
-import { ts } from '../../../ast/index.js';
-import type { TypeScriptEasyNetworkStubsGeneratorConfig } from './models.js';
-
-// See packages/typescript/assets/stubs/easy-network-stub for reference
-export function getReferenceFactories(options: TypeScriptEasyNetworkStubsGeneratorConfig): {
-  easyNetworkStubWrapperOptions: ts.ModuleReferenceFactory;
-  stubRequestItem: ts.ModuleReferenceFactory;
-  stubRequestInfo: ts.GenericModuleReferenceFactory<2>;
-  strictRouteResponseCallback: ts.GenericModuleReferenceFactory<3>;
-  getStubResponder: ts.GenericModuleReferenceFactory<1>;
-  easyNetworkStubWrapper: ts.ModuleReferenceFactory;
-  easyNetworkStubBase: ts.ModuleReferenceFactory;
-  easyNetworkStubGroup: ts.GenericModuleReferenceFactory<2>;
-  createEasyNetworkStubGroup: ts.GenericModuleReferenceFactory<2>;
-} {
-  const utilsDirPath = resolve(options.outputDir, options.utilsDir);
-  const easyNetworkStubUtilsPath = join(utilsDirPath, 'easy-network-stub.utils.ts');
-
-  return {
-    // easy-network-stub.utils.ts
-    easyNetworkStubWrapperOptions: ts.reference.factory('EasyNetworkStubWrapperOptions', easyNetworkStubUtilsPath, {
-      importType: 'type-import',
-    }),
-    stubRequestItem: ts.reference.factory('StubRequestItem', easyNetworkStubUtilsPath, { importType: 'type-import' }),
-    stubRequestInfo: ts.reference.genericFactory<2>('StubRequestInfo', easyNetworkStubUtilsPath, {
-      importType: 'type-import',
-    }),
-    strictRouteResponseCallback: ts.reference.genericFactory<3>(
-      'StrictRouteResponseCallback',
-      easyNetworkStubUtilsPath,
-      {
-        importType: 'type-import',
-      },
-    ),
-    getStubResponder: ts.reference.genericFactory<1>('getStubResponder', easyNetworkStubUtilsPath),
-    easyNetworkStubWrapper: ts.reference.factory('EasyNetworkStubWrapper', easyNetworkStubUtilsPath),
-    easyNetworkStubBase: ts.reference.factory('EasyNetworkStubBase', easyNetworkStubUtilsPath),
-    easyNetworkStubGroup: ts.reference.genericFactory<2>('EasyNetworkStubGroup', easyNetworkStubUtilsPath, {
-      importType: 'type-import',
-    }),
-    createEasyNetworkStubGroup: ts.reference.genericFactory<2>('createEasyNetworkStubGroup', easyNetworkStubUtilsPath),
-  };
-}

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

@@ -1,275 +0,0 @@
-import { resolve } from 'node:path';
-
-import {
-  type ApiEndpoint,
-  type ApiSchema,
-  type AppendValueGroup,
-  appendValueGroup,
-  builderTemplate as s,
-  type MaybePromise,
-  toCasing,
-} from '@goast/core';
-
-import { ts } from '../../../ast/index.js';
-import { TypeScriptFileBuilder } from '../../../file-builder.js';
-import { TypeScriptFileGenerator } from '../../file-generator.js';
-import type { TypeScriptFetchClientGeneratorContext, TypeScriptFetchClientGeneratorOutput } from './models.js';
-
-type Context = TypeScriptFetchClientGeneratorContext;
-type Output = TypeScriptFetchClientGeneratorOutput;
-type Builder = TypeScriptFileBuilder;
-
-export interface TypeScriptFetchClientGenerator<TOutput extends Output = Output> {
-  generate(ctx: Context): MaybePromise<TOutput>;
-}
-
-export class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerator<Context, Output>
-  implements TypeScriptFetchClientGenerator {
-  public generate(ctx: Context): MaybePromise<Output> {
-    const result: Output = {};
-
-    if (this.shouldGenerateInterface(ctx)) {
-      const filePath = this.getInterfaceFilePath(ctx);
-      const name = this.getInterfaceName(ctx);
-
-      TypeScriptFileBuilder.generate({
-        logName: `interface ${name}`,
-        filePath,
-        options: ctx.config,
-        generator: (b) => b.append(this.getInterfaceFileContent(ctx)),
-      });
-
-      result.clientInterface = { filePath, component: name };
-    }
-
-    if (this.shouldGenerateClass(ctx)) {
-      const filePath = this.getClassFilePath(ctx);
-      const name = this.getClassName(ctx);
-
-      TypeScriptFileBuilder.generate({
-        logName: `class ${name}`,
-        filePath,
-        options: ctx.config,
-        generator: (b) => b.append(this.getClassFileContent(ctx)),
-      });
-
-      result.client = { filePath, component: name };
-    }
-
-    return result;
-  }
-
-  // #region Interface
-  protected getInterfaceFileContent(ctx: Context): AppendValueGroup<Builder> {
-    return appendValueGroup([this.getInterface(ctx)], '\n');
-  }
-
-  protected getInterface(ctx: Context): ts.Interface<Builder> {
-    return ts.interface(this.getInterfaceName(ctx), {
-      doc: ts.doc({
-        description: ctx.service.description,
-        tags: [
-          ctx.service.endpoints.length === 0 || ctx.service.endpoints.some((x) => !x.deprecated)
-            ? null
-            : ts.docTag('deprecated'),
-        ],
-      }),
-      export: true,
-      members: ctx.service.endpoints.map((endpoint) => this.getInterfaceEndpointMethod(ctx, endpoint)),
-    });
-  }
-
-  protected getInterfaceEndpointMethod(ctx: Context, endpoint: ApiEndpoint): ts.Method<Builder> {
-    const params = endpoint.parameters.filter((x) =>
-      x.target === 'path' || x.target === 'query' || x.target === 'header'
-    );
-    const bodySchema = endpoint.requestBody?.content[0]?.schema;
-    const responseSchema = this.getResponseSchema(ctx, endpoint);
-    return ts.method(toCasing(endpoint.name, ctx.config.functionNameCasing), {
-      doc: ts.doc({ description: endpoint.description, tags: [endpoint.deprecated ? ts.docTag('deprecated') : null] }),
-      parameters: [
-        params.length > 0
-          ? ts.parameter('params', {
-            description: 'Parameters for the endpoint.',
-            type: ts.objectType({
-              members: params.map((x) =>
-                ts.property(toCasing(x.name, ctx.config.propertyNameCasing), {
-                  doc: ts.doc({ tags: [x.deprecated ? ts.docTag('deprecated') : null] }),
-                  type: this.getSchemaType(ctx, x.schema),
-                  optional: !x.required,
-                })
-              ),
-            }),
-          })
-          : null,
-        bodySchema &&
-        ts.parameter('body', {
-          description: 'Body for the endpoint.',
-          type: this.getSchemaType(ctx, bodySchema),
-        }),
-      ],
-      returnType: ts.refs.promise([ctx.refs.typedResponse([this.getSchemaType(ctx, responseSchema, ts.refs.void_())])]),
-    });
-  }
-  // #endregion
-
-  // #region Class
-  protected getClassFileContent(ctx: Context): AppendValueGroup<Builder> {
-    return appendValueGroup([this.getDefaultOptionsConstant(ctx), this.getClass(ctx)], '\n');
-  }
-
-  protected getDefaultOptionsConstant(ctx: Context): ts.Variable<Builder> {
-    const baseUrl = ctx.service.endpoints.map((x) => x.$src?.document.servers?.find((x) => x.url)?.url).find((x) =>
-      !!x
-    );
-    return ts.variable(this.getDefaultOptionsConstantName(ctx), {
-      export: true,
-      readonly: true,
-      type: ctx.refs.fetchClientOptions(),
-      value: ts.object({
-        members: [baseUrl && ts.property('baseUrl', { value: ts.string(baseUrl) })],
-      }),
-    });
-  }
-
-  protected getClass(ctx: Context): ts.Class<Builder> {
-    return ts.class(this.getClassName(ctx), {
-      doc: ts.doc({
-        description: ctx.service.description,
-        tags: [
-          ctx.service.endpoints.length === 0 || ctx.service.endpoints.some((x) => !x.deprecated)
-            ? null
-            : ts.docTag('deprecated'),
-        ],
-      }),
-      export: true,
-      implements: this.shouldGenerateInterface(ctx)
-        ? [ts.reference(this.getInterfaceName(ctx), this.getInterfaceFilePath(ctx))]
-        : undefined,
-      members: [
-        ts.property('options', {
-          doc: ts.doc({ description: 'Options for the fetch client.' }),
-          accessModifier: 'public',
-          type: ctx.refs.fetchClientOptions(),
-        }),
-        ts.constructor({
-          parameters: [
-            ts.constructorParameter('options', {
-              type: ts.refs.partial([ctx.refs.fetchClientOptions()]),
-              optional: true,
-            }),
-          ],
-          body: appendValueGroup(
-            [s`this.options = { ...${this.getDefaultOptionsConstantName(ctx)}, ...options };`],
-            '\n',
-          ),
-        }),
-        ...ctx.service.endpoints.map((endpoint) => this.getServiceMethod(ctx, endpoint)),
-      ],
-    });
-  }
-
-  protected getServiceMethod(ctx: Context, endpoint: ApiEndpoint): ts.Method<Builder> {
-    const method = this.getInterfaceEndpointMethod(ctx, endpoint);
-    method.accessModifier = 'public';
-    method.body = appendValueGroup(
-      [
-        s`const url = new ${ctx.refs.urlBuilder()}(this.options.baseUrl)${s.indent`
-          .withPath(${ts.string(endpoint.path)})${(b) =>
-          b.forEach(endpoint.parameters, (b, p) => {
-            switch (p.target) {
-              case 'path':
-                b.append(
-                  s<Builder>`\n.withPathParam(${ts.string(p.name)}, params.${
-                    toCasing(p.name, ctx.config.paramNameCasing)
-                  })`,
-                );
-                break;
-              case 'query':
-                b.append(
-                  s<Builder>`\n.withQueryParam(${ts.string(p.name)}, params.${
-                    toCasing(p.name, ctx.config.paramNameCasing)
-                  })`,
-                );
-                break;
-            }
-          })}
-          .build();`}`,
-        'const headers = { ...this.options.headers };',
-        ...endpoint.parameters.filter((x) => x.target === 'header').map((p) =>
-          s<Builder>`if (params && params.${toCasing(p.name, ctx.config.paramNameCasing)} !== undefined) {${s.indent`
-            headers[${ts.string(p.name)}] = String(params.${toCasing(p.name, ctx.config.paramNameCasing)});`}
-          }`
-        ),
-        s`const response = (this.options.fetch ?? fetch)(url, ${
-          ts.object({
-            members: [
-              ts.property('method', { value: ts.string(toCasing(endpoint.method, 'all-upper')) }),
-              ts.property('headers', { value: 'headers' }),
-              endpoint.requestBody?.content[0]?.schema ? ts.property('body', { value: 'JSON.stringify(body)' }) : null,
-            ],
-          })
-        });`,
-        s`Object.defineProperty(response, 'isVoidResponse', { value: ${
-          this.getResponseSchema(ctx, endpoint) ? 'false' : 'true'
-        } });`,
-        s`return response as unknown as ${method.returnType ?? 'unknown'};`,
-      ],
-      '\n',
-    );
-    return method;
-  }
-  // #endregion
-
-  protected getSchemaType(ctx: Context, schema: ApiSchema | undefined, fallback?: ts.Type<Builder>): ts.Type<Builder> {
-    const output = schema && ctx.input.typescript.models[schema.id];
-    if (!output) return fallback ?? this.getAnyType(ctx);
-    return (b) => b.appendModelUsage(output);
-  }
-
-  protected shouldGenerateInterface(ctx: Context): boolean {
-    return ctx.config.clientFileKind === 'interface' || ctx.config.clientFileKind === 'class-and-interface';
-  }
-
-  protected shouldGenerateClass(ctx: Context): boolean {
-    return ctx.config.clientFileKind === 'class' || ctx.config.clientFileKind === 'class-and-interface';
-  }
-
-  protected getInterfaceName(ctx: Context): string {
-    return toCasing(ctx.service.name, ctx.config.clientInterfaceNameCasing ?? ctx.config.typeNameCasing);
-  }
-
-  protected getClassName(ctx: Context): string {
-    return toCasing(ctx.service.name, ctx.config.clientNameCasing ?? ctx.config.typeNameCasing);
-  }
-
-  protected getDefaultOptionsConstantName(ctx: Context): string {
-    return toCasing(this.getClassName(ctx) + '-default-options', ctx.config.constantNameCasing);
-  }
-
-  protected getInterfaceFilePath(ctx: Context): string {
-    return resolve(
-      ctx.config.outputDir,
-      ctx.config.clientInterfaceDir ?? ctx.config.clientDir,
-      `${toCasing(ctx.service.name, ctx.config.clientInterfaceFileNameCasing ?? ctx.config.fileNameCasing)}.ts`,
-    );
-  }
-
-  protected getClassFilePath(ctx: Context): string {
-    return resolve(
-      ctx.config.outputDir,
-      ctx.config.clientDir,
-      `${toCasing(ctx.service.name, ctx.config.clientFileNameCasing ?? ctx.config.fileNameCasing)}.ts`,
-    );
-  }
-
-  protected getUtilPath(ctx: Context, fileName: string): string {
-    return resolve(ctx.config.outputDir, ctx.config.utilsDir, fileName);
-  }
-
-  private getResponseSchema(_ctx: Context, endpoint: ApiEndpoint) {
-    const successResponse = endpoint.responses.find((x) => x.statusCode === 200) ??
-      endpoint.responses.find((x) => x.statusCode && x.statusCode > 200 && x.statusCode < 300);
-    return successResponse?.contentOptions?.find((x) => x.schema !== undefined)?.schema;
-  }
-}