@goast/typescript 0.6.3-beta.1 → 0.7.1

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

@@ -0,0 +1,250 @@
+import { resolve } from 'node:path';
+
+import {
+  adjustCasing,
+  type ApiEndpoint,
+  type ApiSchema,
+  type AppendValueGroup,
+  appendValueGroup,
+  builderTemplate as s,
+  getSourceDisplayName,
+  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 { TypeScriptEasyNetworkStubGeneratorContext, TypeScriptEasyNetworkStubGeneratorOutput } from './models.js';
+
+type Context = TypeScriptEasyNetworkStubGeneratorContext;
+type Output = TypeScriptEasyNetworkStubGeneratorOutput;
+type Builder = TypeScriptFileBuilder;
+
+export interface TypeScriptEasyNetworkStubGenerator<TOutput extends Output = Output> {
+  generate(ctx: Context): MaybePromise<TOutput>;
+}
+
+export class DefaultTypeScriptEasyNetworkStubGenerator extends TypeScriptFileGenerator<Context, Output>
+  implements TypeScriptEasyNetworkStubGenerator {
+  public generate(ctx: Context): MaybePromise<Output> {
+    const filePath = this.getStubFilePath(ctx);
+    const name = this.getStubClassName(ctx);
+
+    TypeScriptFileBuilder.generate({
+      logName: `stub ${name}`,
+      filePath,
+      options: ctx.config,
+      generator: (b) => {
+        ctx.service.endpoints.forEach((endpoint) => {
+          console.log(
+            `  ${getSourceDisplayName(ctx.data, endpoint)} [${toCasing(endpoint.name, ctx.config.functionNameCasing)}]`,
+          );
+        });
+        b.append(this.getStubFileContent(ctx));
+      },
+    });
+
+    return {
+      filePath,
+      component: name,
+    };
+  }
+
+  protected getStubFileContent(ctx: Context): AppendValueGroup<Builder> {
+    return appendValueGroup(
+      [...ctx.service.endpoints.map((endpoint) => this.getResponderVariable(ctx, endpoint)), this.getStubClass(ctx)],
+      '\n',
+    );
+  }
+
+  protected getResponderVariable(ctx: Context, endpoint: ApiEndpoint): ts.Variable<Builder> {
+    return ts.variable(this.getResponderVariableName(ctx, endpoint), {
+      readonly: true,
+      value: ts.call(
+        ctx.refs.getStubResponder([
+          ts.objectType({
+            members: Object.entries(this.getEndpointStatusCodes(ctx, endpoint)).map(([statusCode, type]) =>
+              ts.property<Builder>(statusCode, { type })
+            ),
+          }),
+        ]),
+        [],
+      ),
+    });
+  }
+
+  protected getStubClass(ctx: Context): ts.Class<Builder> {
+    return ts.class(this.getStubClassName(ctx), {
+      export: true,
+      extends: ctx.refs.easyNetworkStubBase(),
+      members: [
+        ...ctx.service.endpoints.map((endpoint) =>
+          ts.property<Builder>(this.getEndpointPathPropertyName(ctx, endpoint), {
+            static: true,
+            readonly: true,
+            accessModifier: 'private',
+            value: s`${ts.string(this.getStubRoute(ctx, endpoint))} as const`,
+          })
+        ),
+        '\n',
+        ...ctx.service.endpoints.map((endpoint) =>
+          ts.property<Builder>(this.getEndpointRequestsFieldName(ctx, endpoint), {
+            readonly: true,
+            accessModifier: 'private',
+            type: this.getEndpointRequestsType(ctx, endpoint),
+            value: ts.tuple([]),
+          })
+        ),
+        '\n',
+        ...ctx.service.endpoints.map((endpoint) =>
+          ts.property<Builder>(this.getEndpointRequestsPropertyName(ctx, endpoint), {
+            readonly: true,
+            accessModifier: 'public',
+            type: this.getEndpointRequestsType(ctx, endpoint, { readonly: true }),
+            get: ts.property.getter({
+              body: appendValueGroup([`return this.${this.getEndpointRequestsFieldName(ctx, endpoint)};`], '\n'),
+            }),
+          })
+        ),
+        ...ctx.service.endpoints.map((endpoint) => this.getEndpointStubMethod(ctx, endpoint)),
+        ts.method('reset', {
+          accessModifier: 'public',
+          override: true,
+          returnType: ts.refs.void_(),
+          body: appendValueGroup(
+            [
+              ...ctx.service.endpoints.map((endpoint) =>
+                `this.${this.getEndpointRequestsFieldName(ctx, endpoint)}.length = 0;`
+              ),
+              'super.reset();',
+            ],
+            '\n',
+          ),
+        }),
+      ],
+    });
+  }
+
+  protected getEndpointRequestsType(
+    ctx: Context,
+    endpoint: ApiEndpoint,
+    options?: { readonly?: boolean },
+  ): ts.Type<Builder> {
+    return ts.arrayType(
+      ctx.refs.stubRequestInfo([
+        ts.typeof(ts.call([this.getStubClassName(ctx), this.getEndpointPathPropertyName(ctx, endpoint)])),
+        this.getSchemaType(ctx, endpoint.requestBody?.content[0].schema),
+      ]),
+      options,
+    );
+  }
+
+  protected getEndpointStubMethod(ctx: Context, endpoint: ApiEndpoint): ts.Method<Builder> {
+    const requestType = this.getSchemaType(ctx, endpoint.requestBody?.content[0].schema);
+    return ts.method(this.getEndpointStubMethodName(ctx, endpoint), {
+      accessModifier: 'public',
+      parameters: [
+        ts.parameter('response', {
+          type: ctx.refs.strictRouteResponseCallback([
+            requestType,
+            ts.typeof(ts.call([this.getStubClassName(ctx), this.getEndpointPathPropertyName(ctx, endpoint)])),
+            ts.typeof(this.getResponderVariableName(ctx, endpoint)),
+          ]),
+        }),
+      ],
+      returnType: 'this',
+      body: appendValueGroup(
+        [
+          s`this.stubWrapper.stub2<${requestType}>()(${s.indent`
+              ${ts.string(endpoint.method.toUpperCase())},
+              ${this.getStubClassName(ctx)}.${this.getEndpointPathPropertyName(ctx, endpoint)},
+              async (request) => {${s.indent`
+                if (this.stubWrapper.options.rememberRequests) {${s.indent`
+                  this.${this.getEndpointRequestsFieldName(ctx, endpoint)}.push(request);`}
+                }
+                throw await response(${this.getResponderVariableName(ctx, endpoint)}, request);`}
+              }`}
+            );`,
+          'return this;',
+        ],
+        '\n',
+      ),
+    });
+  }
+
+  protected getStubFilePath(ctx: Context): string {
+    return resolve(
+      ctx.config.outputDir,
+      ctx.config.stubsDir,
+      `${toCasing(ctx.service.name, ctx.config.stubFileNameCasing ?? ctx.config.fileNameCasing)}.ts`,
+    );
+  }
+
+  protected getResponderVariableName(ctx: Context, endpoint: ApiEndpoint): string {
+    return toCasing(endpoint.name + '_Responder', ctx.config.propertyNameCasing);
+  }
+
+  protected getStubClassName(ctx: Context): string {
+    return toCasing(ctx.service.name + '_Stubs', ctx.config.typeNameCasing);
+  }
+
+  protected getEndpointPathPropertyName(ctx: Context, endpoint: ApiEndpoint): string {
+    return toCasing(endpoint.name + '_Path', ctx.config.constantNameCasing);
+  }
+
+  protected getEndpointRequestsFieldName(ctx: Context, endpoint: ApiEndpoint): string {
+    return toCasing(endpoint.name + '_Requests', adjustCasing(ctx.config.propertyNameCasing, { prefix: '_' }));
+  }
+
+  protected getEndpointRequestsPropertyName(ctx: Context, endpoint: ApiEndpoint): string {
+    return toCasing(endpoint.name + '_Requests', ctx.config.propertyNameCasing);
+  }
+
+  protected getEndpointStubMethodName(ctx: Context, endpoint: ApiEndpoint): string {
+    return toCasing('stub_' + endpoint.name, ctx.config.functionNameCasing);
+  }
+
+  protected getStubRoute(ctx: Context, endpoint: ApiEndpoint): string {
+    let path = endpoint.path;
+    let isFirstQueryParam = true;
+    for (const param of endpoint.parameters) {
+      let type = ((param.schema && ctx.input.typescript.models[param.schema.id]?.component) ?? ts.refs.unknown.name)
+        .replace(
+          /^readonly /,
+          '',
+        );
+
+      const arrayMatch = /^\((.*)\)\[\]$/.exec(type);
+      if (arrayMatch !== null) {
+        type = `${arrayMatch[1]}[]`;
+      }
+
+      if (param.target === 'path') {
+        path = path.replace(`{${param.name}}`, `{${param.name}${param.required ? '' : '?'}:${type}}`);
+      } else if (param.target === 'query') {
+        path = path + (isFirstQueryParam ? '?' : '&') + `{${param.name}${param.required ? '' : '?'}:${type}}`;
+        isFirstQueryParam = false;
+      }
+    }
+    return path.replace(/^\/+/, '');
+  }
+
+  protected getEndpointStatusCodes(ctx: Context, endpoint: ApiEndpoint): Record<number, ts.Type<Builder>> {
+    return Object.fromEntries([
+      ...Object.entries(ctx.config.defaultStatusCodeResponseTypes).map(([key, value]) => [
+        key,
+        typeof value === 'function' ? this.getSchemaType(ctx, value(ctx.data.schemas)) : value,
+      ]),
+      ...endpoint.responses
+        .filter((x) => x.statusCode)
+        .map((x) => [x.statusCode, this.getSchemaType(ctx, x.contentOptions[0]?.schema, ts.refs.never())]),
+    ]);
+  }
+
+  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);
+  }
+}

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

@@ -0,0 +1,211 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,124 @@
+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

@@ -0,0 +1,47 @@
+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>;
+  stubHandle: ts.ModuleReferenceFactory;
+} {
+  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),
+    stubHandle: ts.reference.factory('StubHandle', 'easy-network-stub', { importType: 'type-import' }),
+  };
+}