@conduit-client/generator-ts 3.16.0 → 3.17.0

package/dist/types/v1/files/file.d.ts

@@ -1,5 +1,6 @@
 import { type NamedService, type ServiceDescriptor } from '@conduit-client/utils';
 import { Code } from './code';
+import type { ImportableTypeReference, ImportableValueReference } from './code';
 /**
  * Service that builds TypeScript source files.
  */
@@ -66,6 +67,19 @@ export declare class File {
      * @returns this
      */
     pushTo(block: Symbol, ...chunks: any[]): this;
+    private reExports;
+    /** Registers a value re-export: `export { symbol [as alias] } from "…";` */
+    reExport(ref: ImportableValueReference & {
+        filename: string;
+        exportedSymbol: string;
+    }, alias?: string): void;
+    /** Registers a type re-export: `export type { symbol [as alias] } from "…";` */
+    reExportType(ref: ImportableTypeReference & {
+        filename: string;
+        exportedSymbol: string;
+    }, alias?: string): void;
+    /** Registers a wildcard type re-export: `export type * from "…";` */
+    reExportTypeAll(targetFilename: string): void;
     /**
      * Returns the code for this File, with ImportableReferences resolved.
      *

package/dist/types/v1/generators/bindings-generator.d.ts

@@ -7,6 +7,7 @@ import { WireAdapterBindingGenerator } from './wire-binding-generator';
 import { GraphQLImperativeAdapterBindingGenerator } from './graphql-imperative-binding-generator';
 import { GraphQLWireAdapterBindingGenerator } from './graphql-wire-binding-generator';
 import { GraphQLMutationAdapterBindingGenerator } from './graphql-mutation-binding-generator';
+import type { File, ImportableValueReference } from '../files';
 import type { ICommandModel, ServiceDependency } from '../model/base-command-model';
 import type { NamedTypeRegistryGeneratorService, TypeRegistryGenerator } from '../normalization/type-registry-generator';
 import type { NamedGraphQLTypeRegistryGeneratorService } from '../normalization/graphql-type-registry-generator';
@@ -42,6 +43,7 @@ export declare class BindingsGenerator {
     protected rootTypesInstantiationSymbol: symbol;
     protected exportsTypeMembersSymbol: symbol;
     protected exportsAssignmentsSymbol: symbol;
+    protected initGeneratedBindingsExtraParamsSymbol: symbol;
     /**
      * Template for generating the binding structure in the output file.
      * Includes placeholders for adapter declarations, service requirements, and adapter invocations.
@@ -62,6 +64,60 @@ export declare class BindingsGenerator {
      * This method coordinates with individual binding generators to compile the necessary elements into a single file.
      */
     build(): void;
+    /**
+     * Emits re-export statements from bindings-core so that custom bindings modules
+     * can import generated internals from a single stable entry point.
+     */
+    protected buildReExports(coreFile: File, refs: {
+        typeRegistryRef?: ImportableValueReference & {
+            filename: string;
+            exportedSymbol: string;
+        };
+        graphqlTypeRegistryRef?: ImportableValueReference & {
+            filename: string;
+            exportedSymbol: string;
+        };
+    }): void;
+    /**
+     * Re-exports per-command symbols: `buildCommandClass` (aliased to `build<Capitalized>CommandClass`),
+     * `CONFIG_SCHEMA` (aliased to `<UPPER>_CONFIG_SCHEMA`), and the `Config` type
+     * (aliased to `<Capitalized>Config`).
+     *
+     * The CONFIG_SCHEMA alias uses a simple uppercase of the commandName (e.g. `getItemsByIds`
+     * becomes `GETITEMSBYIDS_CONFIG_SCHEMA`) to avoid ambiguity from word-boundary heuristics.
+     */
+    protected buildCommandReExports(coreFile: File): void;
+    /**
+     * Re-exports the `TypeRegistry` (REST) and/or `GraphQLTypeRegistry` (GraphQL) classes
+     * so custom bindings can construct or extend them.
+     */
+    protected buildTypeRegistryReExports(coreFile: File, refs: {
+        typeRegistryRef?: ImportableValueReference & {
+            filename: string;
+            exportedSymbol: string;
+        };
+        graphqlTypeRegistryRef?: ImportableValueReference & {
+            filename: string;
+            exportedSymbol: string;
+        };
+    }): void;
+    /**
+     * Re-exports individual generated type repository classes (e.g. `RecordRepresentationRepository`)
+     * so custom bindings can extend or reference them without importing from internal paths.
+     *
+     * If both REST and GraphQL registries produce a repository with the same exported symbol,
+     * the GraphQL version is aliased with a `GraphQL_` prefix to avoid collisions.
+     */
+    protected buildTypeRepositoryReExports(coreFile: File): void;
+    /**
+     * Re-exports all generated entity types so custom bindings can reference
+     * domain models (e.g. `api_Item`) without importing from internal paths.
+     *
+     * The barrel `types/index.ts` is built incrementally by TypeDefinitionService
+     * as types are generated; we just re-export it from bindings-core.
+     * GraphQL-only specs produce no REST types so the barrel is never created.
+     */
+    protected buildEntityTypeReExports(coreFile: File): void;
     buildTypeInvalidation(typesWithNormalization: TypeRegistryGenerator['invalidatableTypes']): {
         definitions: Code[];
         declarations: Code[];

package/dist/types/v1/normalization/graphql-type-registry-generator.d.ts

@@ -4,7 +4,7 @@ import type { NamedFileService, File, ImportableValueReference, ImportableRefere
 import type { NamedService } from '@conduit-client/utils';
 import type { GraphQLSchemaModel } from '../model/graphql-schema-model';
 import type { GraphQLObjectType } from './graphql-type-generator';
-type GraphQLTypeRepositoryReference = {
+export type GraphQLTypeRepositoryReference = {
     propertyName: string;
     typeClassRef: ImportableValueReference;
     typeName: string;
@@ -16,6 +16,7 @@ type Options = {
 export type IGraphQLTypeRegistryGeneratorService = {
     build(): ImportableValueReference;
     buildGraphQLType(options: Options): GraphQLTypeRepositoryReference;
+    readonly registeredTypes: ReadonlyMap<string, GraphQLTypeRepositoryReference>;
 };
 export type NamedGraphQLTypeRegistryGeneratorService<Name extends string = 'graphqlTypeRegistryGenerator'> = NamedService<Name, IGraphQLTypeRegistryGeneratorService>;
 export declare const NAMED_CACHE_CONTROLLER_SERVICE: ImportableReference;
@@ -35,6 +36,7 @@ export declare class GraphQLTypeRegistryGenerator implements IGraphQLTypeRegistr
     protected typeInstantiationsSymbol: symbol;
     protected typeGettersSymbol: symbol;
     cache: Map<string, GraphQLTypeRepositoryReference>;
+    get registeredTypes(): ReadonlyMap<string, GraphQLTypeRepositoryReference>;
     private get file();
     private buildFile;
     get template(): (symbol | import("..").Code)[];

package/dist/types/v1/normalization/type-registry-generator.d.ts

@@ -6,7 +6,7 @@ import type { INormalizedTypeGenerator } from './normalized-type-generator';
 import type { NamedService } from '@conduit-client/utils';
 import type { File, ImportableValueReference, NamedFileService } from '../files';
 import type { NamedNormalizeGeneratorService } from './normalize-code-gen/normalize-generator-service';
-type TypeRepositoryReference = {
+export type TypeRepositoryReference = {
     propertyName: string;
     typeClassRef: ImportableValueReference;
 };
@@ -20,6 +20,7 @@ export type ITypeRegistryGeneratorService = {
     build(): ImportableValueReference;
     buildType(type: Type, options: Options): TypeRepositoryReference;
     invalidatableTypes: TypeRepositoryReference[];
+    readonly registeredTypes: ReadonlyMap<string, TypeRepositoryReference>;
 };
 export type NamedTypeRegistryGeneratorService<Name extends string = 'typeRegistryGenerator'> = NamedService<Name, ITypeRegistryGeneratorService>;
 /**
@@ -40,6 +41,7 @@ export declare class TypeRegistryGenerator implements ITypeRegistryGeneratorServ
      * after all operations precessing is complete.
      */
     invalidatableTypes: TypeRepositoryReference[];
+    get registeredTypes(): ReadonlyMap<string, TypeRepositoryReference>;
     private get file();
     private buildFile;
     get template(): (symbol | Code)[];

package/dist/types/v1/types/type-definition.d.ts

@@ -9,6 +9,7 @@ export type TypeDefinitionForOptions = {
 };
 export type ITypeDefinitionService = {
     build(type: Type | undefined): Code;
+    readonly hasTypes: boolean;
 };
 export type NamedTypeDefinitionService = NamedService<'typeDefinition', ITypeDefinitionService>;
 export declare class TypeDefinitionService implements ITypeDefinitionService {
@@ -16,6 +17,7 @@ export declare class TypeDefinitionService implements ITypeDefinitionService {
     private fileFor;
     constructor(services: NamedAPIService & NamedFileService, fileFor?: (typename: string) => string);
     cache: Map<string, ImportableReference>;
+    get hasTypes(): boolean;
     build(type: Type | undefined, useReferences?: boolean): Code;
     buildTypeCode(t: Type, options: TypeDefinitionForOptions): Code;
     buildReferenceCode(refType: RefType, options: TypeDefinitionForOptions): Code;
@@ -32,4 +34,6 @@ export declare function typeDefinitions(services: NamedAPIService & NamedFileSer
     fileFor?: (typename: string) => string;
 }): TypeDefinitionService;
 export declare const FILE_PER_TYPE: (typename: string) => string;
+export declare const TYPES_SINGLE_FILE_PATH = "types/types.ts";
 export declare const SINGLE_FILE: (_: string) => string;
+export declare const TYPES_INDEX_PATH = "types/index.ts";

package/dist/v1/index.js

@@ -6,7 +6,7 @@
 import * as path from "path";
 import { resolve } from "path";
 import * as prettier from "prettier";
-import { toTypeScriptSafeIdentifier, JSONStringify, ok, err, stringIsVersion, stableJSONStringify } from "@conduit-client/utils";
+import { toTypeScriptSafeIdentifier, JSONStringify, ok, err, capitalizeFirst, stringIsVersion, stableJSONStringify } from "@conduit-client/utils";
 import * as fs from "fs";
 import { readFileSync } from "fs";
 import { isAnyType, isRefType, isAllOfType, isOneOfType, isNotType, isObjectType as isObjectType$2, isDiscriminatedObjectType, isArrayType, isScalar, isEnumType as isEnumType$1, isNilType, isCanonicalStringType, isCanonicalNumberType, isBooleanType, typesEqual, isIdentifiableType as isIdentifiableType$1, canonicalizeType } from "@conduit-client/model/v1";
@@ -116,6 +116,10 @@ class Files {
 function fileService() {
   return new Files();
 }
+function resolveRelativeImportPath(fromFile, toFile) {
+  const rel = path.relative(path.dirname(fromFile), toFile).replace(/\.(js|ts)$/, "");
+  return rel.startsWith(".") ? rel : "./" + rel;
+}
 class Imports {
   /**
    * Constructor
@@ -156,10 +160,7 @@ class Imports {
     }
     let from;
     if ("filename" in ref) {
-      from = path.relative(path.dirname(this.filename), ref.filename).replace(/\.(js|ts)$/, "");
-      if (!from.startsWith(".")) {
-        from = "./" + from;
-      }
+      from = resolveRelativeImportPath(this.filename, ref.filename);
     } else {
       from = ref.module;
     }
@@ -224,11 +225,59 @@ class Imports {
     ].join("");
   }
 }
+class ReExports {
+  constructor(filename) {
+    this.filename = filename;
+    this.entries = {};
+    this.typeAllPaths = /* @__PURE__ */ new Set();
+  }
+  resolveFrom(targetFilename) {
+    return resolveRelativeImportPath(this.filename, targetFilename);
+  }
+  /**
+   * Registers a value or type re-export: `export { symbol [as alias] } from "…";`
+   * @param targetFilename the filename of the target file to re-export
+   * @param exportedSymbol the symbol to export
+   * @param alias an optional alias for the symbol
+   * @param isType true if the re-export is for a type; false if it is for a value
+   */
+  add(targetFilename, exportedSymbol, alias, isType2) {
+    const from = this.resolveFrom(targetFilename);
+    if (!this.entries[from]) {
+      this.entries[from] = [];
+    }
+    this.entries[from].push({ exportedSymbol, alias, isType: isType2 });
+  }
+  /**
+   * Registers a wildcard type re-export: `export type * from "…";`
+   * @param targetFilename the filename of the target file to re-export
+   */
+  addTypeAll(targetFilename) {
+    this.typeAllPaths.add(this.resolveFrom(targetFilename));
+  }
+  toString() {
+    const statements = [];
+    for (const from of Object.keys(this.entries)) {
+      const entries = this.entries[from];
+      for (const isType2 of [false, true]) {
+        const clauses = entries.filter((e) => e.isType === isType2).map((e) => e.alias ? `${e.exportedSymbol} as ${e.alias}` : e.exportedSymbol).join(",");
+        if (clauses) {
+          statements.push(`export ${isType2 ? "type " : ""}{${clauses}} from '${from}';`);
+        }
+      }
+    }
+    for (const from of this.typeAllPaths) {
+      statements.push(`export type * from '${from}';`);
+    }
+    return statements.length > 0 ? statements.join("") : "";
+  }
+}
 const _File = class _File {
   constructor(filename) {
     this.filename = filename;
     this.blocks = /* @__PURE__ */ new Map();
     this.template = [_File.DEFAULT_BLOCK];
+    this.reExports = new ReExports(this.filename);
   }
   /**
    * Appends new chunks of code to the default code block. Chunks are handled
@@ -256,6 +305,18 @@ const _File = class _File {
     code2.push(...chunks);
     return this;
   }
+  /** Registers a value re-export: `export { symbol [as alias] } from "…";` */
+  reExport(ref, alias) {
+    this.reExports.add(ref.filename, ref.exportedSymbol, alias, false);
+  }
+  /** Registers a type re-export: `export type { symbol [as alias] } from "…";` */
+  reExportType(ref, alias) {
+    this.reExports.add(ref.filename, ref.exportedSymbol, alias, true);
+  }
+  /** Registers a wildcard type re-export: `export type * from "…";` */
+  reExportTypeAll(targetFilename) {
+    this.reExports.addTypeAll(targetFilename);
+  }
   /**
    * Returns the code for this File, with ImportableReferences resolved.
    *
@@ -272,7 +333,7 @@ const _File = class _File {
     const executableCode = finalCode.toString({
       importStringifier: (ir) => imports.localSymbolFor(ir)
     });
-    const code2 = imports.toString() + executableCode;
+    const code2 = imports.toString() + executableCode + this.reExports.toString();
     if (options.prettified) {
       try {
         return prettier.format(code2, { parser: "typescript" });
@@ -395,6 +456,9 @@ class TypeDefinitionService {
     this.fileFor = fileFor;
     this.cache = /* @__PURE__ */ new Map();
   }
+  get hasTypes() {
+    return this.cache.size > 0;
+  }
   build(type, useReferences = true) {
     return type ? this.buildTypeCode(type, {
       referenceFor: (t) => {
@@ -581,6 +645,7 @@ class TypeDefinitionService {
     this.cache.set(typename, result);
     const declaration = code`export type ${exportedSymbol}=${this.build(type, false)};`;
     this.services.file.build(filename).push(declaration);
+    this.services.file.build(TYPES_INDEX_PATH).reExportTypeAll(filename);
     return result;
   }
 }
@@ -588,7 +653,9 @@ function typeDefinitions(services, options = {}) {
   return new TypeDefinitionService(services, options.fileFor || SINGLE_FILE);
 }
 const FILE_PER_TYPE = (typename) => `types/${typename}.ts`;
-const SINGLE_FILE = (_) => "types/types.ts";
+const TYPES_SINGLE_FILE_PATH = "types/types.ts";
+const SINGLE_FILE = (_) => TYPES_SINGLE_FILE_PATH;
+const TYPES_INDEX_PATH = "types/index.ts";
 const SCHEMA_FILE_PATH = "json-schema/index.ts";
 const COMBINED_SCHEMA = {
   filename: SCHEMA_FILE_PATH,
@@ -1453,6 +1520,9 @@ class TypeRegistryGenerator {
     this.cache = /* @__PURE__ */ new Map();
     this.invalidatableTypes = [];
   }
+  get registeredTypes() {
+    return this.cache;
+  }
   get file() {
     return this.buildFile();
   }
@@ -2048,6 +2118,9 @@ class GraphQLTypeRegistryGenerator {
   setGraphQLTypeGenerator(generator) {
     this.graphqlTypeGenerator = generator;
   }
+  get registeredTypes() {
+    return this.cache;
+  }
   get file() {
     if (this._file) {
       return this._file;
@@ -3530,6 +3603,9 @@ class BindingsGenerator {
     this.rootTypesInstantiationSymbol = Symbol.for("rootTypesInstantiation");
     this.exportsTypeMembersSymbol = Symbol.for("exportsTypeMembers");
     this.exportsAssignmentsSymbol = Symbol.for("exportsAssignments");
+    this.initGeneratedBindingsExtraParamsSymbol = Symbol.for(
+      "initGeneratedBindingsExtraParams"
+    );
   }
   /**
    * Template for generating the binding structure in the output file.
@@ -3555,7 +3631,9 @@ class BindingsGenerator {
       code`export const serviceRequirements=`,
       this.serviceRequirementsSymbol,
       code` as const;`,
-      code`export function initGeneratedBindings(services: ${REQUESTED_SERVICES_TYPE}<typeof serviceRequirements>, exports: BindingsExports) {`,
+      code`export function initGeneratedBindings<S extends ${REQUESTED_SERVICES_TYPE}<typeof serviceRequirements>>(services: S, exports: BindingsExports`,
+      this.initGeneratedBindingsExtraParamsSymbol,
+      code`) {`,
       this.typeRegistryInstantiationSymbol,
       this.rootTypesInstantiationSymbol,
       this.typeInvalidationDefinitionSymbol,
@@ -3703,11 +3781,18 @@ class BindingsGenerator {
     const wrapperFilename = "artifacts/bindings.ts";
     const wrapperFile = this.services.file.build(wrapperFilename);
     wrapperFile.template = this.wrapperTemplate;
+    let typeRegistryRef;
+    let graphqlTypeRegistryRef;
     if (this.hasRESTNormalization) {
       const { typeRegistryGenerator } = this.services;
+      typeRegistryRef = typeRegistryGenerator.build();
+      coreFile.pushTo(
+        this.initGeneratedBindingsExtraParamsSymbol,
+        code`, typeRegistry?: ${typeRegistryRef}`
+      );
       coreFile.pushTo(
         this.typeRegistryInstantiationSymbol,
-        code`const typeRegistry = new ${typeRegistryGenerator.build()}(services);`
+        code`typeRegistry ??= new ${typeRegistryRef}(services);`
       );
       const { declarations, definitions } = this.buildTypeInvalidation(
         typeRegistryGenerator.invalidatableTypes
@@ -3717,7 +3802,11 @@ class BindingsGenerator {
     }
     if (this.hasGraphQL) {
       const { graphqlTypeRegistryGenerator } = this.services;
-      const graphqlTypeRegistry = graphqlTypeRegistryGenerator.build();
+      graphqlTypeRegistryRef = graphqlTypeRegistryGenerator.build();
+      coreFile.pushTo(
+        this.initGeneratedBindingsExtraParamsSymbol,
+        code`, graphqlTypeRegistry?: ${graphqlTypeRegistryRef}`
+      );
       const firstGraphQLCommand = this.commandModels.find(
         (model) => model.operationType === "graphql"
       );
@@ -3737,7 +3826,7 @@ class BindingsGenerator {
       }) : void 0;
       coreFile.pushTo(
         this.rootTypesInstantiationSymbol,
-        code`const graphqlTypeRegistry = new ${graphqlTypeRegistry}(services);
+        code`graphqlTypeRegistry ??= new ${graphqlTypeRegistryRef}(services);
                 const ${QUERY_TYPE_VARIABLE_NAME} = graphqlTypeRegistry.${queryType.propertyName};`
       );
       if (mutationType) {
@@ -3801,6 +3890,100 @@ class BindingsGenerator {
         "\n"
       )
     );
+    this.buildReExports(coreFile, { typeRegistryRef, graphqlTypeRegistryRef });
+  }
+  /**
+   * Emits re-export statements from bindings-core so that custom bindings modules
+   * can import generated internals from a single stable entry point.
+   */
+  buildReExports(coreFile, refs) {
+    this.buildCommandReExports(coreFile);
+    this.buildTypeRegistryReExports(coreFile, refs);
+    this.buildTypeRepositoryReExports(coreFile);
+    this.buildEntityTypeReExports(coreFile);
+  }
+  /**
+   * Re-exports per-command symbols: `buildCommandClass` (aliased to `build<Capitalized>CommandClass`),
+   * `CONFIG_SCHEMA` (aliased to `<UPPER>_CONFIG_SCHEMA`), and the `Config` type
+   * (aliased to `<Capitalized>Config`).
+   *
+   * The CONFIG_SCHEMA alias uses a simple uppercase of the commandName (e.g. `getItemsByIds`
+   * becomes `GETITEMSBYIDS_CONFIG_SCHEMA`) to avoid ambiguity from word-boundary heuristics.
+   */
+  buildCommandReExports(coreFile) {
+    for (const model of this.commandModels) {
+      const capitalized = capitalizeFirst(model.commandName);
+      const upper = model.commandName.toUpperCase();
+      const buildRef = {
+        filename: model.filePath,
+        exportedSymbol: "buildCommandClass",
+        isType: false
+      };
+      const schemaRef = {
+        filename: model.filePath,
+        exportedSymbol: "CONFIG_SCHEMA",
+        isType: false
+      };
+      const configRef = {
+        filename: model.filePath,
+        exportedSymbol: "Config",
+        isType: true
+      };
+      coreFile.reExport(buildRef, `build${capitalized}CommandClass`);
+      coreFile.reExport(schemaRef, `${upper}_CONFIG_SCHEMA`);
+      coreFile.reExportType(configRef, `${capitalized}Config`);
+    }
+  }
+  /**
+   * Re-exports the `TypeRegistry` (REST) and/or `GraphQLTypeRegistry` (GraphQL) classes
+   * so custom bindings can construct or extend them.
+   */
+  buildTypeRegistryReExports(coreFile, refs) {
+    if (refs.typeRegistryRef) {
+      coreFile.reExport(refs.typeRegistryRef);
+    }
+    if (refs.graphqlTypeRegistryRef) {
+      coreFile.reExport(refs.graphqlTypeRegistryRef);
+    }
+  }
+  /**
+   * Re-exports individual generated type repository classes (e.g. `RecordRepresentationRepository`)
+   * so custom bindings can extend or reference them without importing from internal paths.
+   *
+   * If both REST and GraphQL registries produce a repository with the same exported symbol,
+   * the GraphQL version is aliased with a `GraphQL_` prefix to avoid collisions.
+   */
+  buildTypeRepositoryReExports(coreFile) {
+    const restRepos = this.hasRESTNormalization ? [...this.services.typeRegistryGenerator.registeredTypes.values()] : [];
+    const graphqlRepos = this.hasGraphQL ? [...this.services.graphqlTypeRegistryGenerator.registeredTypes.values()] : [];
+    const restNames = new Set(restRepos.map((r) => r.typeClassRef.exportedSymbol));
+    const graphqlNames = new Set(graphqlRepos.map((r) => r.typeClassRef.exportedSymbol));
+    const conflicts = new Set([...restNames].filter((n) => graphqlNames.has(n)));
+    for (const { typeClassRef } of restRepos) {
+      if (!("filename" in typeClassRef) || !typeClassRef.exportedSymbol) continue;
+      coreFile.reExport(typeClassRef);
+    }
+    for (const { typeClassRef } of graphqlRepos) {
+      if (!("filename" in typeClassRef) || !typeClassRef.exportedSymbol) continue;
+      const alias = conflicts.has(typeClassRef.exportedSymbol) ? `GraphQL_${typeClassRef.exportedSymbol}` : void 0;
+      coreFile.reExport(
+        typeClassRef,
+        alias
+      );
+    }
+  }
+  /**
+   * Re-exports all generated entity types so custom bindings can reference
+   * domain models (e.g. `api_Item`) without importing from internal paths.
+   *
+   * The barrel `types/index.ts` is built incrementally by TypeDefinitionService
+   * as types are generated; we just re-export it from bindings-core.
+   * GraphQL-only specs produce no REST types so the barrel is never created.
+   */
+  buildEntityTypeReExports(coreFile) {
+    if (this.services.typeDefinition.hasTypes) {
+      coreFile.reExportTypeAll(TYPES_INDEX_PATH);
+    }
   }
   buildTypeInvalidation(typesWithNormalization) {
     return typesWithNormalization.reduce(
@@ -13653,6 +13836,8 @@ export {
   NormalizedTypeGenerator,
   SINGLE_FILE,
   SINGLE_FILE_NORMALIZED,
+  TYPES_INDEX_PATH,
+  TYPES_SINGLE_FILE_PATH,
   TYPE_REGISTRY_FILE,
   TypeDefinitionService,
   TypeRegistryGenerator,