@conduit-client/generator-ts 3.16.0 → 3.17.1

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;
@@ -2176,9 +2249,9 @@ class CommandGenerator {
   }
   get commandConstructorArgs() {
     if (this.commandModel.invalidationConfigs.length > 0) {
-      return code`private config: Config, private typeRegistry: ${this.services.typeRegistryGenerator.build()}`;
+      return code`public config: Config, public typeRegistry: ${this.services.typeRegistryGenerator.build()}`;
     }
-    return code`private config: Config`;
+    return code`public config: Config`;
   }
   get exposeSubscribeAndRefresh() {
     if (this.commandModel.exposeRefresh && this.commandModel.cacheStrategy.type === "none") {
@@ -2259,7 +2332,8 @@ class CommandGenerator {
     file.pushTo(this.commandClassBodySymbol, ...this.classBody);
     const generatedClass = this.commandGeneratedClass;
     if (generatedClass) {
-      const constructorSignature = code`new (${this.getBuildCommandClassConstructorParams()}) => ${generatedClass}<${this.getBuildCommandClassReturnTypeGenerics()}>`;
+      const fieldGenerics = this.getBuildCommandClassConstructorFieldGenerics();
+      const constructorSignature = code`new (${this.getBuildCommandClassConstructorParams()}) => ${generatedClass}<${this.getBuildCommandClassReturnTypeGenerics()}, ${fieldGenerics}>`;
       file.pushTo(this.commandBuildCommandClassReturnTypeSymbol, constructorSignature);
       file.pushTo(
         this.commandBuildCommandClassReturnAssertionSymbol,
@@ -2296,6 +2370,16 @@ class CommandGenerator {
   getBuildCommandClassConstructorParams() {
     return code`${this.commandTypeConstructorArgs}, ...args: CommandConstructorParams`;
   }
+  /**
+   * Additional generic type args for the Generated declare class that surface
+   * public constructor fields (config, typeRegistry, etc.) on InstanceType<>.
+   */
+  getBuildCommandClassConstructorFieldGenerics() {
+    if (this.commandModel.invalidationConfigs.length > 0) {
+      return code`Config, ${this.services.typeRegistryGenerator.build()}`;
+    }
+    return code`Config`;
+  }
   buildCommandTypeGenerics() {
     var _a;
     const extraServicesCode = this.buildExtraServices();
@@ -2892,7 +2976,7 @@ class ImperativeAdapterBindingGenerator {
     };
   }
   buildDeclaration() {
-    return code`export let ${this.binding.identifier}:${this.bindingTypeCode};`;
+    return code`let ${this.binding.identifier}:${this.bindingTypeCode};`;
   }
   get bindingTypeCode() {
     return code`(config:${this.commandConfigTypeImport}, options?: ${this.commandOptionsTypeImport})=>${this.returnShape}<${this.responseTypeCode}>`;
@@ -2943,7 +3027,7 @@ class ImperativeAdapterBindingGenerator {
     const requiresTypeRegistry = this.commandModel.cacheStrategy.type === "normalized" || this.commandModel.invalidationConfigs.length > 0;
     const typeRegistry = requiresTypeRegistry ? "typeRegistry," : "";
     return code`const ${this.localCommandConstructorName} = services.instrumentCommand(${this.classBuilderImport}(${servicesName}.${this.commandModel.serviceDependencies.baseClass.localName}), '${this.commandModel.className}');
-            ${this.binding.identifier}=${this.invoker}<Parameters<typeof ${this.binding.identifier}>,${this.responseTypeCode}>(
+            const ${this.binding.identifier}=${this.invoker}<Parameters<typeof ${this.binding.identifier}>,${this.responseTypeCode}>(
             ({params,assertIsValid})=>{
             const config=params[0];
             const options=params[1];
@@ -2994,7 +3078,7 @@ class ImperativeAdapterLegacyBindingGenerator {
     );
   }
   buildDeclaration() {
-    return code`export let ${this.binding.identifier}:${LEGACY_IMPERATIVE_RETURN_SHAPE}<${this.commandConfigTypeImport},${this.responseTypeCode}>;`;
+    return code`let ${this.binding.identifier}:${LEGACY_IMPERATIVE_RETURN_SHAPE}<${this.commandConfigTypeImport},${this.responseTypeCode}>;`;
   }
   get localCommandConstructorName() {
     return `${this.binding.identifier}_ctor`;
@@ -3005,7 +3089,7 @@ class ImperativeAdapterLegacyBindingGenerator {
   buildInvocation(servicesName = "services") {
     const requiresTypeRegistry = this.commandModel.cacheStrategy.type === "normalized" || this.commandModel.invalidationConfigs.length > 0;
     return code`const ${this.localCommandConstructorName} = services.instrumentCommand(${this.classBuilderImport}(${servicesName}.${this.commandModel.serviceDependencies.baseClass.localName}), '${this.commandModel.className}');
-            ${this.binding.identifier}=services.${LEGACY_IMPERATIVE_BINDINGS}.bind<${this.commandConfigTypeImport},${this.responseTypeCode}>(
+            const ${this.binding.identifier}=services.${LEGACY_IMPERATIVE_BINDINGS}.bind<${this.commandConfigTypeImport},${this.responseTypeCode}>(
             ({config,assertIsValid})=>{
             const _:<T>(data:unknown,_:${JSON_SCHEMA_TYPE$3})=>asserts data is T=assertIsValid;
             _<${this.commandConfigTypeImport}>(config,${this.commandConfigSchemaImport});
@@ -3054,7 +3138,7 @@ class GraphQLImperativeAdapterLegacyBindingGenerator {
     );
   }
   buildDeclaration() {
-    return code`export let ${this.binding.identifier}:${LEGACY_GRAPHQL_IMPERATIVE_RETURN_SHAPE}<${this.commandConfigTypeImport}>;`;
+    return code`let ${this.binding.identifier}:${LEGACY_GRAPHQL_IMPERATIVE_RETURN_SHAPE}<${this.commandConfigTypeImport}>;`;
   }
   get localCommandConstructorName() {
     return `${this.binding.identifier}_ctor`;
@@ -3064,7 +3148,7 @@ class GraphQLImperativeAdapterLegacyBindingGenerator {
   }
   buildInvocation(servicesName = "services") {
     return code`const ${this.localCommandConstructorName} = services.instrumentCommand(${this.classBuilderImport}(${servicesName}.${this.commandModel.serviceDependencies.baseClass.localName}), '${this.commandModel.className}');
-            ${this.binding.identifier}=services.${GRAPHQL_LEGACY_IMPERATIVE_BINDINGS}.bind<${this.commandConfigTypeImport}>(
+            const ${this.binding.identifier}=services.${GRAPHQL_LEGACY_IMPERATIVE_BINDINGS}.bind<${this.commandConfigTypeImport}>(
             ({config,assertIsValid})=>{
             const _:<T>(data:unknown,_:${JSON_SCHEMA_TYPE$2})=>asserts data is T=assertIsValid;
             _<${this.commandConfigTypeImport}>(config,${this.commandConfigSchemaImport});
@@ -3111,7 +3195,7 @@ class WireAdapterBindingGenerator {
     );
   }
   buildDeclaration() {
-    return code`export let ${this.binding.identifier}:${WIRE_ADAPTER_CONSTRUCTOR$1}<${this.commandConfigTypeImport}, ${WIRE_ADAPTER_RESULT}<${this.responseTypeCode}>, {}>;`;
+    return code`let ${this.binding.identifier}:${WIRE_ADAPTER_CONSTRUCTOR$1}<${this.commandConfigTypeImport}, ${WIRE_ADAPTER_RESULT}<${this.responseTypeCode}>, {}>;`;
   }
   get localCommandConstructorName() {
     return `${this.binding.identifier}_ctor`;
@@ -3121,7 +3205,7 @@ class WireAdapterBindingGenerator {
   }
   buildInvocation(servicesName = "services") {
     return code`const ${this.localCommandConstructorName} = services.instrumentCommand(${this.classBuilderImport}(${servicesName}.${this.commandModel.serviceDependencies.baseClass.localName}), '${this.commandModel.className}');
-            ${this.binding.identifier}=services.${LWC_WIRE_BINDINGS}.bind<${this.responseTypeCode}, ${this.commandConfigTypeImport}>(
+            const ${this.binding.identifier}=services.${LWC_WIRE_BINDINGS}.bind<${this.responseTypeCode}, ${this.commandConfigTypeImport}>(
                 (config: ${this.commandConfigTypeImport}) => new ${this.localCommandConstructorName}(config!,${this.getTypeRegistryArgument()}${servicesName}),${this.commandConfigSchemaImport},${this.commandModel.exposeRefresh});`;
   }
   getTypeRegistryArgument() {
@@ -3174,7 +3258,7 @@ class GraphQLImperativeAdapterBindingGenerator {
     };
   }
   buildDeclaration() {
-    return code`export let ${this.binding.identifier}:${this.bindingTypeCode};`;
+    return code`let ${this.binding.identifier}:${this.bindingTypeCode};`;
   }
   get bindingTypeCode() {
     return code`(config:${this.commandConfigTypeImport}, options?: ${this.commandOptionsTypeImport})=>${this.returnShape}`;
@@ -3202,7 +3286,7 @@ class GraphQLImperativeAdapterBindingGenerator {
   }
   buildInvocation(servicesName = "services") {
     return code`const ${this.localCommandConstructorName} = services.instrumentCommand(${this.classBuilderImport}(${servicesName}.${this.commandModel.serviceDependencies.baseClass.localName}), '${this.commandModel.className}');
-            ${this.binding.identifier}=${this.invoker}<Parameters<typeof ${this.binding.identifier}>>(
+            const ${this.binding.identifier}=${this.invoker}<Parameters<typeof ${this.binding.identifier}>>(
             ({params,assertIsValid})=>{
             const config=params[0];
             const options=params[1];
@@ -3253,7 +3337,7 @@ class GraphQLWireAdapterBindingGenerator {
     );
   }
   buildDeclaration() {
-    return code`export let ${this.binding.identifier}:${WIRE_ADAPTER_CONSTRUCTOR}<${this.commandConfigTypeImport}, ${GRAPHQL_WIRE_ADAPTER_RESULT}, {}>;`;
+    return code`let ${this.binding.identifier}:${WIRE_ADAPTER_CONSTRUCTOR}<${this.commandConfigTypeImport}, ${GRAPHQL_WIRE_ADAPTER_RESULT}, {}>;`;
   }
   get localCommandConstructorName() {
     return `${this.binding.identifier}_ctor`;
@@ -3263,7 +3347,7 @@ class GraphQLWireAdapterBindingGenerator {
   }
   buildInvocation(servicesName = "services") {
     return code`const ${this.localCommandConstructorName} = services.instrumentCommand(${this.classBuilderImport}(${servicesName}.${this.commandModel.serviceDependencies.baseClass.localName}), '${this.commandModel.className}');
-            ${this.binding.identifier}=services.${GRAPHQL_WIRE_BINDINGS}.bind<${this.commandConfigTypeImport}>((config: ${this.commandConfigTypeImport}) => new ${this.localCommandConstructorName}(config,${QUERY_TYPE_VARIABLE_NAME},${servicesName}), ${this.commandConfigSchemaImport}, ${this.commandModel.exposeRefresh});`;
+            const ${this.binding.identifier}=services.${GRAPHQL_WIRE_BINDINGS}.bind<${this.commandConfigTypeImport}>((config: ${this.commandConfigTypeImport}) => new ${this.localCommandConstructorName}(config,${QUERY_TYPE_VARIABLE_NAME},${servicesName}), ${this.commandConfigSchemaImport}, ${this.commandModel.exposeRefresh});`;
   }
 }
 const GRAPHQL_MUTATION_RESULT = {
@@ -3309,7 +3393,7 @@ class GraphQLMutationAdapterBindingGenerator {
     };
   }
   buildDeclaration() {
-    return code`export let ${this.binding.identifier}:${this.bindingTypeCode};`;
+    return code`let ${this.binding.identifier}:${this.bindingTypeCode};`;
   }
   get bindingTypeCode() {
     return code`(config:${this.commandConfigTypeImport}, options?: ${this.commandOptionsTypeImport})=>${this.returnShape}`;
@@ -3328,7 +3412,7 @@ class GraphQLMutationAdapterBindingGenerator {
   }
   buildInvocation(servicesName = "services") {
     return code`const ${this.localCommandConstructorName} = services.instrumentCommand(${this.classBuilderImport}(${servicesName}.${this.commandModel.serviceDependencies.baseClass.localName}), '${this.commandModel.className}');
-            ${this.binding.identifier}=${this.invoker}<Parameters<typeof ${this.binding.identifier}>>(
+            const ${this.binding.identifier}=${this.invoker}<Parameters<typeof ${this.binding.identifier}>>(
             ({params,assertIsValid})=>{
             const config=params[0];
             const options=params[1];
@@ -3529,7 +3613,12 @@ class BindingsGenerator {
     this.typeInvalidationDefinitionSymbol = Symbol.for("typeInvalidationDefinition");
     this.rootTypesInstantiationSymbol = Symbol.for("rootTypesInstantiation");
     this.exportsTypeMembersSymbol = Symbol.for("exportsTypeMembers");
-    this.exportsAssignmentsSymbol = Symbol.for("exportsAssignments");
+    this.initGeneratedBindingsExtraParamsSymbol = Symbol.for(
+      "initGeneratedBindingsExtraParams"
+    );
+    this.returnStatementSymbol = Symbol.for("returnStatement");
+    this.wrapperDeclarationsSymbol = Symbol.for("wrapperDeclarations");
+    this.wrapperAssignmentsSymbol = Symbol.for("wrapperAssignments");
   }
   /**
    * Template for generating the binding structure in the output file.
@@ -3551,25 +3640,31 @@ class BindingsGenerator {
       code`export type BindingsExports = {`,
       this.exportsTypeMembersSymbol,
       code`};`,
-      code`export const exports = {} as BindingsExports;`,
       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`,
+      this.initGeneratedBindingsExtraParamsSymbol,
+      code`): BindingsExports {`,
       this.typeRegistryInstantiationSymbol,
       this.rootTypesInstantiationSymbol,
       this.typeInvalidationDefinitionSymbol,
       this.adapterInvocationSymbol,
-      this.exportsAssignmentsSymbol,
+      this.returnStatementSymbol,
       code`}`
     ];
   }
   get wrapperTemplate() {
     return [
-      code`export * from './bindings-core';`,
-      code`import { exports, serviceRequirements, initGeneratedBindings } from './bindings-core';`,
-      code`export const ready = ${INIT_BINDINGS_EXPORTS}({ serviceRequirements, exports, init: initGeneratedBindings }).ready;`,
-      code`export default exports;`
+      code`import { serviceRequirements, initGeneratedBindings, type BindingsExports } from './bindings-core';`,
+      this.wrapperDeclarationsSymbol,
+      code`${INIT_BINDINGS_EXPORTS}({`,
+      code`serviceRequirements,`,
+      code`init: (services) => {`,
+      code`const result = initGeneratedBindings(services);`,
+      this.wrapperAssignmentsSymbol,
+      code`},`,
+      code`});`
     ];
   }
   get serviceDependencies() {
@@ -3703,11 +3798,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 +3819,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 +3843,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) {
@@ -3795,22 +3901,132 @@ class BindingsGenerator {
       )
     );
     coreFile.pushTo(
-      this.exportsAssignmentsSymbol,
+      this.returnStatementSymbol,
+      code`return {${Code.join(
+        uniqueExportNames.map((name) => code`${name},`),
+        " "
+      )}};`
+    );
+    wrapperFile.pushTo(
+      this.wrapperDeclarationsSymbol,
       Code.join(
-        uniqueExportNames.map((name) => code`exports.${code`${name}`} = ${code`${name}`};`),
+        uniqueExportNames.map(
+          (name) => code`export let ${code`${name}`}: BindingsExports['${name}'];`
+        ),
         "\n"
       )
     );
+    wrapperFile.pushTo(
+      this.wrapperAssignmentsSymbol,
+      Code.join(
+        uniqueExportNames.map((name) => code`${code`${name}`} = result.${code`${name}`};`),
+        "\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(
       (acc, { propertyName, typeClassRef }) => {
         const invalidateFunctionName = code`invalidate${toTypeScriptSafeIdentifier(propertyName)}`;
         acc.declarations.push(
-          code`export let ${invalidateFunctionName}: ${typeClassRef}["invalidate"];`
+          code`let ${invalidateFunctionName}: ${typeClassRef}["invalidate"];`
         );
         acc.definitions.push(
-          code`${invalidateFunctionName} = (configs) => typeRegistry.${toTypeScriptSafeIdentifier(propertyName)}.invalidate(configs);`
+          code`const ${invalidateFunctionName}: ${typeClassRef}["invalidate"] = (configs) => typeRegistry.${toTypeScriptSafeIdentifier(propertyName)}.invalidate(configs);`
         );
         return acc;
       },
@@ -4110,7 +4326,10 @@ function NormalizedCacheControlGeneratorMixin(Base, commandBaseClass, commandGen
       return code`config: Config, typeRegistry: ${this.services.typeRegistryGenerator.build()}`;
     }
     get commandConstructorArgs() {
-      return code`private config: Config, private typeRegistry: ${this.services.typeRegistryGenerator.build()}`;
+      return code`public config: Config, public typeRegistry: ${this.services.typeRegistryGenerator.build()}`;
+    }
+    getBuildCommandClassConstructorFieldGenerics() {
+      return code`Config, ${this.services.typeRegistryGenerator.build()}`;
     }
     buildCommandTypeGenerics() {
       const extraServicesCode = this.buildExtraServices();
@@ -4310,8 +4529,11 @@ function GraphQLNormalizedCacheControlGeneratorMixin(Base, commandBaseClass, com
     getBuildCommandClassReturnTypeGenerics() {
       return this.buildCommandTypeGenerics();
     }
+    getBuildCommandClassConstructorFieldGenerics() {
+      return code`CommandConfig, DocumentRootType, ${NAMED_CACHE_CONTROLLER_SERVICE} & ${NAMED_PUBSUB_SERVICE$3} & ${this.buildNetworkServicesCode()} & object`;
+    }
     get commandConstructorArgs() {
-      return code`protected config: CommandConfig, protected documentRootType: DocumentRootType, protected services: ${NAMED_CACHE_CONTROLLER_SERVICE} & ${NAMED_PUBSUB_SERVICE$3} & ${this.buildNetworkServicesCode()} & object`;
+      return code`public config: CommandConfig, public documentRootType: DocumentRootType, public services: ${NAMED_CACHE_CONTROLLER_SERVICE} & ${NAMED_PUBSUB_SERVICE$3} & ${this.buildNetworkServicesCode()} & object`;
     }
     get commandConstructorBody() {
       return code`super(config, documentRootType, services);`;
@@ -13653,6 +13875,8 @@ export {
   NormalizedTypeGenerator,
   SINGLE_FILE,
   SINGLE_FILE_NORMALIZED,
+  TYPES_INDEX_PATH,
+  TYPES_SINGLE_FILE_PATH,
   TYPE_REGISTRY_FILE,
   TypeDefinitionService,
   TypeRegistryGenerator,