@devcraft-ts/diadem 0.1.0

package/dist/index.cjs

@@ -0,0 +1,145 @@
+'use strict';
+
+var chunk72YY5X6T_cjs = require('./chunk-72YY5X6T.cjs');
+var chunkFHQRDO5C_cjs = require('./chunk-FHQRDO5C.cjs');
+
+// src/core/index.ts
+var decorators = {
+  singleton: chunkFHQRDO5C_cjs.singleton,
+  factory: chunkFHQRDO5C_cjs.factory,
+  lazy: chunkFHQRDO5C_cjs.lazy,
+  lazySingleton: chunkFHQRDO5C_cjs.lazySingleton
+};
+function createContainerBuilder() {
+  const container = new chunk72YY5X6T_cjs.DiademContainer();
+  const builder = {
+    register: (token, implementation) => {
+      container.register(token, implementation);
+      return builder;
+    },
+    registerSingleton: (token, factory2) => {
+      container.registerSingleton(token, factory2);
+      return builder;
+    },
+    registerFactory: (token, factory2) => {
+      container.registerFactory(token, factory2);
+      return builder;
+    },
+    build: () => container
+  };
+  return builder;
+}
+function createMockContainer(mocks = /* @__PURE__ */ new Map()) {
+  const container = new chunk72YY5X6T_cjs.DiademContainer();
+  mocks.forEach((implementation, token) => {
+    container.register(token, implementation);
+  });
+  container.setReady();
+  return container;
+}
+function isDIContainer(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return false;
+  }
+  const c = obj;
+  return typeof c.register === "function" && typeof c.resolve === "function" && typeof c.isReady === "function";
+}
+function isDiademContainer(obj) {
+  if (!isDIContainer(obj)) {
+    return false;
+  }
+  const c = obj;
+  return typeof c.autoRegisterDiscovered === "function" && typeof c.getDiagnostics === "function";
+}
+
+// src/index.ts
+var DI_VERSION = "0.1.0";
+var DI_FEATURES = [
+  "type-safe",
+  "ssr-safe",
+  "decorator-driven",
+  "auto-registration",
+  "environment-aware",
+  "server-safe",
+  "no-global-state",
+  "metadata-based",
+  "zero-dependencies"
+];
+
+Object.defineProperty(exports, "DiademContainer", {
+  enumerable: true,
+  get: function () { return chunk72YY5X6T_cjs.DiademContainer; }
+});
+Object.defineProperty(exports, "configureManifest", {
+  enumerable: true,
+  get: function () { return chunkFHQRDO5C_cjs.configureManifest; }
+});
+Object.defineProperty(exports, "consoleLogger", {
+  enumerable: true,
+  get: function () { return chunkFHQRDO5C_cjs.consoleLogger; }
+});
+Object.defineProperty(exports, "factory", {
+  enumerable: true,
+  get: function () { return chunkFHQRDO5C_cjs.factory; }
+});
+Object.defineProperty(exports, "getDIMetadata", {
+  enumerable: true,
+  get: function () { return chunkFHQRDO5C_cjs.getDIMetadata; }
+});
+Object.defineProperty(exports, "getDIRegistrationStats", {
+  enumerable: true,
+  get: function () { return chunkFHQRDO5C_cjs.getDIRegistrationStats; }
+});
+Object.defineProperty(exports, "getLogger", {
+  enumerable: true,
+  get: function () { return chunkFHQRDO5C_cjs.getLogger; }
+});
+Object.defineProperty(exports, "getManifest", {
+  enumerable: true,
+  get: function () { return chunkFHQRDO5C_cjs.getManifest; }
+});
+Object.defineProperty(exports, "hasDIMetadata", {
+  enumerable: true,
+  get: function () { return chunkFHQRDO5C_cjs.hasDIMetadata; }
+});
+Object.defineProperty(exports, "hasManifest", {
+  enumerable: true,
+  get: function () { return chunkFHQRDO5C_cjs.hasManifest; }
+});
+Object.defineProperty(exports, "isClassRegisteredForEnvironment", {
+  enumerable: true,
+  get: function () { return chunkFHQRDO5C_cjs.isClassRegisteredForEnvironment; }
+});
+Object.defineProperty(exports, "lazy", {
+  enumerable: true,
+  get: function () { return chunkFHQRDO5C_cjs.lazy; }
+});
+Object.defineProperty(exports, "lazySingleton", {
+  enumerable: true,
+  get: function () { return chunkFHQRDO5C_cjs.lazySingleton; }
+});
+Object.defineProperty(exports, "noopLogger", {
+  enumerable: true,
+  get: function () { return chunkFHQRDO5C_cjs.noopLogger; }
+});
+Object.defineProperty(exports, "resetManifest", {
+  enumerable: true,
+  get: function () { return chunkFHQRDO5C_cjs.resetManifest; }
+});
+Object.defineProperty(exports, "setLogger", {
+  enumerable: true,
+  get: function () { return chunkFHQRDO5C_cjs.setLogger; }
+});
+Object.defineProperty(exports, "singleton", {
+  enumerable: true,
+  get: function () { return chunkFHQRDO5C_cjs.singleton; }
+});
+exports.DI_FEATURES = DI_FEATURES;
+exports.DI_VERSION = DI_VERSION;
+exports.createContainerBuilder = createContainerBuilder;
+exports.createMockContainer = createMockContainer;
+exports.decorators = decorators;
+exports.isDIContainer = isDIContainer;
+exports.isDiademContainer = isDiademContainer;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/index.ts","../src/index.ts"],"names":["singleton","factory","lazy","lazySingleton","DiademContainer"],"mappings":";;;;;;AAmEO,IAAM,UAAA,GAAa;AAAA,aACxBA,2BAAA;AAAA,WACAC,yBAAA;AAAA,QACAC,sBAAA;AAAA,iBACAC;AACF;AA0CO,SAAS,sBAAA,GAA2C;AACzD,EAAA,MAAM,SAAA,GAAY,IAAIC,iCAAA,EAAgB;AAEtC,EAAA,MAAM,OAAA,GAA4B;AAAA,IAChC,QAAA,EAAU,CAAI,KAAA,EAAuB,cAAA,KAAsB;AACzD,MAAA,SAAA,CAAU,QAAA,CAAS,OAAO,cAAc,CAAA;AACxC,MAAA,OAAO,OAAA;AAAA,IACT,CAAA;AAAA,IACA,iBAAA,EAAmB,CACjB,KAAA,EACAH,QAAAA,KACG;AACH,MAAA,SAAA,CAAU,iBAAA,CAAkB,OAAOA,QAAO,CAAA;AAC1C,MAAA,OAAO,OAAA;AAAA,IACT,CAAA;AAAA,IACA,eAAA,EAAiB,CAAI,KAAA,EAAuBA,QAAAA,KAA+B;AACzE,MAAA,SAAA,CAAU,eAAA,CAAgB,OAAOA,QAAO,CAAA;AACxC,MAAA,OAAO,OAAA;AAAA,IACT,CAAA;AAAA,IAEA,OAAO,MAAM;AAAA,GACf;AAEA,EAAA,OAAO,OAAA;AACT;AAGO,SAAS,mBAAA,CACd,KAAA,mBAAQ,IAAI,GAAA,EAAmC,EAC9B;AACjB,EAAA,MAAM,SAAA,GAAY,IAAIG,iCAAA,EAAgB;AAGtC,EAAA,KAAA,CAAM,OAAA,CAAQ,CAAC,cAAA,EAAgB,KAAA,KAAU;AACvC,IAAA,SAAA,CAAU,QAAA,CAAS,OAAO,cAAc,CAAA;AAAA,EAC1C,CAAC,CAAA;AAED,EAAA,SAAA,CAAU,QAAA,EAAS;AACnB,EAAA,OAAO,SAAA;AACT;AAKO,SAAS,cAAc,GAAA,EAAkC;AAC9D,EAAA,IAAI,OAAO,GAAA,KAAQ,QAAA,IAAY,GAAA,KAAQ,IAAA,EAAM;AAC3C,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,MAAM,CAAA,GAAI,GAAA;AACV,EAAA,OACE,OAAO,CAAA,CAAE,QAAA,KAAa,UAAA,IACtB,OAAO,EAAE,OAAA,KAAY,UAAA,IACrB,OAAO,CAAA,CAAE,OAAA,KAAY,UAAA;AAEzB;AAEO,SAAS,kBAAkB,GAAA,EAAsC;AACtE,EAAA,IAAI,CAAC,aAAA,CAAc,GAAG,CAAA,EAAG;AACvB,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,MAAM,CAAA,GAAI,GAAA;AACV,EAAA,OACE,OAAO,CAAA,CAAE,sBAAA,KAA2B,UAAA,IACpC,OAAO,EAAE,cAAA,KAAmB,UAAA;AAEhC;;;ACtJO,IAAM,UAAA,GAAa;AAEnB,IAAM,WAAA,GAAc;AAAA,EACzB,WAAA;AAAA,EACA,UAAA;AAAA,EACA,kBAAA;AAAA,EACA,mBAAA;AAAA,EACA,mBAAA;AAAA,EACA,aAAA;AAAA,EACA,iBAAA;AAAA,EACA,gBAAA;AAAA,EACA;AACF","file":"index.cjs","sourcesContent":["/**\n * Core DI System - Core Module Exports\n *\n * This module exports the fundamental building blocks of the dependency injection system:\n * - Container implementation\n * - Decorators for service registration\n * - Type definitions\n *\n * @example\n * ```typescript\n * import { DiademContainer, singleton, factory } from 'app/infrastructure/di/core'\n * ```\n */\n\n// Import for local usage\nimport type { Constructor, DIContainer } from './container'\nimport { DiademContainer } from './container'\nimport { factory, lazy, lazySingleton, singleton } from './decorators'\n\n// Container and types\nexport {\n  DiademContainer,\n  type Constructor,\n  type DIContainer,\n  type Disposable,\n  type LifecycleType,\n  type Token\n} from './container'\n\n// Decorators for auto-registration\nexport {\n  factory,\n  getDIMetadata,\n  getDIRegistrationStats,\n  hasDIMetadata,\n  isClassRegisteredForEnvironment,\n  lazy,\n  lazySingleton,\n  singleton,\n  type LifecycleType as DecoratorLifecycleType,\n  type DIMetadata\n} from './decorators'\n\n// Type definitions\nexport type { AbstractConstructor } from './types'\n\n// Pluggable logging (silent by default)\nexport { consoleLogger, getLogger, noopLogger, setLogger } from './logger'\nexport type { Logger } from './logger'\n\n// Service manifest contract + injection seam\nexport {\n  configureManifest,\n  getManifest,\n  hasManifest,\n  resetManifest\n} from './manifest'\nexport type {\n  ImportedService,\n  ServiceDependency,\n  ServiceManifestEntry,\n  ServiceManifestModule\n} from './manifest'\n\n/**\n * Common decorator combinations for convenience\n */\nexport const decorators = {\n  singleton,\n  factory,\n  lazy,\n  lazySingleton\n} as const\n\n/**\n * Type helpers for better developer experience\n */\n\n// Helper type to extract the implementation type from a constructor token\nexport type ResolvedType<T> = T extends Constructor<infer U> ? U : never\n\n// Helper type for multiple dependency resolution\nexport type ResolvedTypes<T extends ReadonlyArray<Constructor<unknown>>> = {\n  [K in keyof T]: T[K] extends Constructor<infer U> ? U : never\n}\n\n// Helper type for service factory functions\nexport type ServiceFactory<T> = () => T\n\n// Helper type for environment-aware service registration\nexport interface EnvironmentConfig {\n  environment?: string\n  modules: Array<Record<string, unknown>>\n}\n\n/**\n * Utility functions for advanced usage\n */\n\n/** Fluent builder returned by {@link createContainerBuilder}. */\nexport interface ContainerBuilder {\n  register: <T>(token: Constructor<T>, implementation: T) => ContainerBuilder\n  registerSingleton: <T>(\n    token: Constructor<T>,\n    factory: ServiceFactory<T>\n  ) => ContainerBuilder\n  registerFactory: <T>(\n    token: Constructor<T>,\n    factory: ServiceFactory<T>\n  ) => ContainerBuilder\n  build: () => DiademContainer\n}\n\n// Create a type-safe container builder\nexport function createContainerBuilder(): ContainerBuilder {\n  const container = new DiademContainer()\n\n  const builder: ContainerBuilder = {\n    register: <T>(token: Constructor<T>, implementation: T) => {\n      container.register(token, implementation)\n      return builder\n    },\n    registerSingleton: <T>(\n      token: Constructor<T>,\n      factory: ServiceFactory<T>\n    ) => {\n      container.registerSingleton(token, factory)\n      return builder\n    },\n    registerFactory: <T>(token: Constructor<T>, factory: ServiceFactory<T>) => {\n      container.registerFactory(token, factory)\n      return builder\n    },\n\n    build: () => container\n  }\n\n  return builder\n}\n\n// Create a mock container for testing\nexport function createMockContainer(\n  mocks = new Map<Constructor<unknown>, unknown>()\n): DiademContainer {\n  const container = new DiademContainer()\n\n  // Register all mocks\n  mocks.forEach((implementation, token) => {\n    container.register(token, implementation)\n  })\n\n  container.setReady()\n  return container\n}\n\n/**\n * Type guards for runtime type checking\n */\nexport function isDIContainer(obj: unknown): obj is DIContainer {\n  if (typeof obj !== 'object' || obj === null) {\n    return false\n  }\n  const c = obj as Record<string, unknown>\n  return (\n    typeof c.register === 'function' &&\n    typeof c.resolve === 'function' &&\n    typeof c.isReady === 'function'\n  )\n}\n\nexport function isDiademContainer(obj: unknown): obj is DiademContainer {\n  if (!isDIContainer(obj)) {\n    return false\n  }\n  const c = obj as unknown as Record<string, unknown>\n  return (\n    typeof c.autoRegisterDiscovered === 'function' &&\n    typeof c.getDiagnostics === 'function'\n  )\n}\n","/**\n * Diadem — main entry point.\n *\n * A build-time, manifest-driven DI container. SSR-safe and framework-agnostic:\n * registration metadata lives on classes, never in global state.\n *\n * ```typescript\n * import {\n *   DiademContainer,\n *   configureManifest,\n *   singleton,\n *   factory\n * } from '@devcraft-ts/diadem'\n * import * as manifest from './generated/service-manifest'\n *\n * configureManifest(manifest)\n * const container = new DiademContainer()\n * await container.autoRegisterDiscovered(process.env.NODE_ENV)\n * const service = container.resolve(IMyService)\n * ```\n */\n\n// Core DI functionality (container, decorators, manifest contract, logging).\n// Setup helpers live at 'diadem/setup'.\nexport * from './core'\n\n/**\n * Version and metadata\n */\nexport const DI_VERSION = '0.1.0'\n\nexport const DI_FEATURES = [\n  'type-safe',\n  'ssr-safe',\n  'decorator-driven',\n  'auto-registration',\n  'environment-aware',\n  'server-safe',\n  'no-global-state',\n  'metadata-based',\n  'zero-dependencies'\n] as const\n"]}

package/dist/index.d.cts

@@ -0,0 +1,304 @@
+import { A as AbstractConstructor, C as ConcreteConstructor, a as Constructor, D as DiademContainer, b as DIContainer } from './container-C1FFn9_4.cjs';
+export { c as Disposable, L as LifecycleType, T as Token } from './container-C1FFn9_4.cjs';
+
+/**
+ * Decorator-driven DI registration using class metadata instead of global state.
+ * This approach is SSR-safe and avoids global state issues.
+ */
+
+type LifecycleType = 'singleton' | 'factory' | 'lazy' | 'lazySingleton';
+interface DIMetadata {
+    token: AbstractConstructor;
+    lifecycle: LifecycleType;
+    environment?: string;
+}
+/**
+ * Get DI metadata from a class constructor
+ */
+declare function getDIMetadata(target: ConcreteConstructor): DIMetadata | null;
+/**
+ * Check if a class has DI metadata
+ */
+declare function hasDIMetadata(target: ConcreteConstructor): boolean;
+/**
+ * Decorator to register a class as a singleton.
+ * The class will be instantiated once per container and reused.
+ *
+ * @param token The interface/abstract class token to register the implementation against
+ * @param env Optional environment filter. If provided, the class will only be registered in that environment.
+ *
+ * @example
+ * ```typescript
+ * @singleton(IMyService)
+ * class MyService implements IMyService {
+ *   // implementation
+ * }
+ *
+ * @singleton(IService, 'production')
+ * class ProductionOnlyService implements IService {
+ *   // only registered in production environment
+ * }
+ * ```
+ */
+declare function singleton<T>(token: AbstractConstructor<T>, env?: string): <U extends ConcreteConstructor<T>>(target: U) => U;
+/**
+ * Decorator to register a class as a factory.
+ * A new instance will be created each time the dependency is resolved.
+ *
+ * @param token The interface/abstract class token to register the implementation against
+ * @param env Optional environment filter. If provided, the class will only be registered in that environment.
+ *
+ * @example
+ * ```typescript
+ * @factory(ITransientService)
+ * class TransientService implements ITransientService {
+ *   // new instance created on each resolve
+ * }
+ * ```
+ */
+declare function factory<T>(token: AbstractConstructor<T>, env?: string): <U extends ConcreteConstructor<T>>(target: U) => U;
+/**
+ * Decorator to register a class as lazy.
+ * The class will be instantiated only when first resolved, then a new instance on each subsequent resolve.
+ *
+ * @param token The interface/abstract class token to register the implementation against
+ * @param env Optional environment filter. If provided, the class will only be registered in that environment.
+ *
+ * @example
+ * ```typescript
+ * @lazy(IExpensiveService)
+ * class ExpensiveService implements IExpensiveService {
+ *   // only instantiated when first needed
+ * }
+ * ```
+ */
+declare function lazy<T>(token: AbstractConstructor<T>, env?: string): <U extends ConcreteConstructor<T>>(target: U) => U;
+/**
+ * Decorator to register a class as a lazy singleton.
+ * The class will be instantiated only when first resolved, then reused.
+ *
+ * @param token The interface/abstract class token to register the implementation against
+ * @param env Optional environment filter. If provided, the class will only be registered in that environment.
+ *
+ * @example
+ * ```typescript
+ * @lazySingleton(IDatabaseConnection)
+ * class DatabaseConnection implements IDatabaseConnection {
+ *   // instantiated only when first needed, then reused
+ * }
+ * ```
+ */
+declare function lazySingleton<T>(token: AbstractConstructor<T>, env?: string): <U extends ConcreteConstructor<T>>(target: U) => U;
+/**
+ * Auto-discovery helper that scans for decorated classes in the current context.
+ * This can be used to automatically find all decorated classes without manual imports.
+ *
+ * @param modules Array of module objects to scan
+ * @returns Combined array of all decorated classes found
+ // Auto-discovery from modules removed - use manifest-based auto-discovery instead
+
+/**
+ * Get registration statistics for debugging
+ */
+declare function getDIRegistrationStats(classes: ConcreteConstructor[]): {
+    total: number;
+    singletons: number;
+    factories: number;
+    lazy: number;
+    lazySingletons: number;
+    environments: string[];
+};
+/**
+ * Check if a class is registered for a specific environment.
+ */
+declare function isClassRegisteredForEnvironment(ClassConstructor: ConcreteConstructor, environment?: string): boolean;
+
+/**
+ * Pluggable logging for Diadem.
+ *
+ * A library must not write to stdout/stderr unless asked to. By default Diadem
+ * uses a no-op logger and stays completely silent. Opt into diagnostics by
+ * registering a logger (e.g. the built-in {@link consoleLogger}, or your own
+ * pino/winston adapter):
+ *
+ * ```ts
+ * import { setLogger, consoleLogger } from '@devcraft-ts/diadem'
+ * setLogger(consoleLogger)
+ * ```
+ */
+interface Logger {
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+}
+/** A logger that discards everything. The default. */
+declare const noopLogger: Logger;
+/** A logger that writes to the global `console`. Opt-in. */
+declare const consoleLogger: Logger;
+/**
+ * Set the active logger. Pass `null` to reset to the silent no-op logger.
+ */
+declare function setLogger(logger: Logger | null): void;
+/** Get the active logger. Internal call sites log through this. */
+declare function getLogger(): Logger;
+
+/**
+ * Service manifest contract + injection seam.
+ *
+ * Diadem is a *build-time* DI container: a generator scans the consumer's
+ * source, extracts each service's constructor dependencies, topologically
+ * sorts them, and emits a manifest module. That generated module is NOT part
+ * of this package — it lives in the consumer's project. This file defines the
+ * shape such a module must conform to, and the seam through which it is plugged
+ * in at runtime.
+ *
+ * Usage in a consuming app:
+ * ```ts
+ * import { configureManifest } from '@devcraft-ts/diadem'
+ * import * as manifest from './generated/service-manifest'
+ *
+ * configureManifest(manifest)
+ * ```
+ *
+ * See `examples/basic.ts` for a complete, runnable example.
+ */
+
+/** A single constructor parameter of a service, as analysed at build time. */
+interface ServiceDependency {
+    paramName: string;
+    paramIndex: number;
+    typeName: string;
+    isOptional: boolean;
+    isReadonly?: boolean;
+    isPrivate?: boolean;
+    /** Class name of the service that implements this dependency, if internal. */
+    implementingService?: string;
+    /** True when the dependency is not managed by the container. */
+    external?: boolean;
+}
+/** One service entry in the build-time manifest. */
+interface ServiceManifestEntry {
+    className: string;
+    importPath: string;
+    lifecycle: 'dependency' | 'singleton' | 'factory' | 'lazy' | 'lazySingleton';
+    environment?: string;
+    exported: boolean;
+    filePath: string;
+    registrationOrder: number;
+    dependencies: ServiceDependency[];
+    resolvedDependencies: ServiceDependency[];
+}
+/** A loaded service class, paired with the manifest entry it came from. */
+interface ImportedService {
+    entry: ServiceManifestEntry;
+    serviceClass: AbstractConstructor;
+}
+/**
+ * The shape of a generated manifest module. A consumer's build step emits a
+ * module exporting these members; pass that module to {@link configureManifest}.
+ */
+interface ServiceManifestModule {
+    SERVICE_MANIFEST: ServiceManifestEntry[];
+    SERVICE_CLASSES: Record<string, AbstractConstructor>;
+    SERVICES_BY_ENVIRONMENT?: Record<string, ServiceManifestEntry[]>;
+    MANIFEST_STATS?: unknown;
+    getServicesForEnvironment: (environment?: string) => ServiceManifestEntry[];
+    importService: (entry: ServiceManifestEntry) => Promise<AbstractConstructor>;
+    importAllServices: (entries: ServiceManifestEntry[]) => Promise<ImportedService[]>;
+}
+/**
+ * Register the generated manifest module so the container can discover and
+ * autowire services. Call once at application startup, before constructing a
+ * container that relies on auto-discovery.
+ */
+declare function configureManifest(manifest: ServiceManifestModule): void;
+/** Returns the configured manifest, or null if none has been registered. */
+declare function getManifest(): ServiceManifestModule | null;
+/** True when a manifest has been registered via {@link configureManifest}. */
+declare function hasManifest(): boolean;
+/** Clear the registered manifest. Primarily useful in tests. */
+declare function resetManifest(): void;
+
+/**
+ * Core DI System - Core Module Exports
+ *
+ * This module exports the fundamental building blocks of the dependency injection system:
+ * - Container implementation
+ * - Decorators for service registration
+ * - Type definitions
+ *
+ * @example
+ * ```typescript
+ * import { DiademContainer, singleton, factory } from 'app/infrastructure/di/core'
+ * ```
+ */
+
+/**
+ * Common decorator combinations for convenience
+ */
+declare const decorators: {
+    readonly singleton: typeof singleton;
+    readonly factory: typeof factory;
+    readonly lazy: typeof lazy;
+    readonly lazySingleton: typeof lazySingleton;
+};
+/**
+ * Type helpers for better developer experience
+ */
+type ResolvedType<T> = T extends Constructor<infer U> ? U : never;
+type ResolvedTypes<T extends ReadonlyArray<Constructor<unknown>>> = {
+    [K in keyof T]: T[K] extends Constructor<infer U> ? U : never;
+};
+type ServiceFactory<T> = () => T;
+interface EnvironmentConfig {
+    environment?: string;
+    modules: Array<Record<string, unknown>>;
+}
+/**
+ * Utility functions for advanced usage
+ */
+/** Fluent builder returned by {@link createContainerBuilder}. */
+interface ContainerBuilder {
+    register: <T>(token: Constructor<T>, implementation: T) => ContainerBuilder;
+    registerSingleton: <T>(token: Constructor<T>, factory: ServiceFactory<T>) => ContainerBuilder;
+    registerFactory: <T>(token: Constructor<T>, factory: ServiceFactory<T>) => ContainerBuilder;
+    build: () => DiademContainer;
+}
+declare function createContainerBuilder(): ContainerBuilder;
+declare function createMockContainer(mocks?: Map<Constructor<unknown>, unknown>): DiademContainer;
+/**
+ * Type guards for runtime type checking
+ */
+declare function isDIContainer(obj: unknown): obj is DIContainer;
+declare function isDiademContainer(obj: unknown): obj is DiademContainer;
+
+/**
+ * Diadem — main entry point.
+ *
+ * A build-time, manifest-driven DI container. SSR-safe and framework-agnostic:
+ * registration metadata lives on classes, never in global state.
+ *
+ * ```typescript
+ * import {
+ *   DiademContainer,
+ *   configureManifest,
+ *   singleton,
+ *   factory
+ * } from '@devcraft-ts/diadem'
+ * import * as manifest from './generated/service-manifest'
+ *
+ * configureManifest(manifest)
+ * const container = new DiademContainer()
+ * await container.autoRegisterDiscovered(process.env.NODE_ENV)
+ * const service = container.resolve(IMyService)
+ * ```
+ */
+
+/**
+ * Version and metadata
+ */
+declare const DI_VERSION = "0.1.0";
+declare const DI_FEATURES: readonly ["type-safe", "ssr-safe", "decorator-driven", "auto-registration", "environment-aware", "server-safe", "no-global-state", "metadata-based", "zero-dependencies"];
+
+export { AbstractConstructor, Constructor, type ContainerBuilder, DIContainer, type DIMetadata, DI_FEATURES, DI_VERSION, type LifecycleType as DecoratorLifecycleType, DiademContainer, type EnvironmentConfig, type ImportedService, type Logger, type ResolvedType, type ResolvedTypes, type ServiceDependency, type ServiceFactory, type ServiceManifestEntry, type ServiceManifestModule, configureManifest, consoleLogger, createContainerBuilder, createMockContainer, decorators, factory, getDIMetadata, getDIRegistrationStats, getLogger, getManifest, hasDIMetadata, hasManifest, isClassRegisteredForEnvironment, isDIContainer, isDiademContainer, lazy, lazySingleton, noopLogger, resetManifest, setLogger, singleton };