@tstdl/base 0.93.123 → 0.93.126

package/examples/document-management/ai-provider.js

@@ -0,0 +1,74 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectModel } from '../../ai/genkit/index.js';
+import { fewShotPrompt, stylePrompt } from '../../ai/prompts/index.js';
+import { DocumentManagementAiProviderService } from '../../document-management/server/index.js';
+import { Singleton } from '../../injector/index.js';
+let ExampleAiProviderService = class ExampleAiProviderService extends DocumentManagementAiProviderService {
+    /**
+     * Providing global defaults for the entire Document Management module.
+     */
+    getGlobalConfiguration() {
+        return {
+            defaults: {
+                language: 'German', // Steer all AI outputs to German
+                model: injectModel('gemini-2.5-flash'),
+                prompt: {
+                    systemAddition: 'Additional global instructions for all AI steps.',
+                },
+            },
+        };
+    }
+    getContentExtractionConfiguration() {
+        return {};
+    }
+    /**
+     * Providing specific overrides for the Classification step.
+     */
+    getClassificationConfiguration() {
+        return {
+            // Use a faster/cheaper model for classification
+            model: injectModel('gemini-2.5-flash-lite'),
+            prompt: {
+                systemAddition: 'For classification, focus strictly on the layout.',
+            },
+        };
+    }
+    /**
+     * Providing specific overrides for the Data Extraction step,
+     * potentially specific to a Document Type Key.
+     */
+    getDataExtractionConfiguration(_tenantId, data) {
+        if (data.type.key == 'invoice') {
+            return {
+                prompt: {
+                    // Use prompt factories for standardized steering
+                    systemAddition: [
+                        stylePrompt('Titles must always start with "INV-" followed by the invoice number.'),
+                        fewShotPrompt([
+                            {
+                                input: 'Invoice from 2023-10-05, No. 12345',
+                                output: 'INV-12345',
+                            },
+                        ]),
+                    ],
+                },
+            };
+        }
+        return {};
+    }
+    getAssignmentConfiguration() {
+        return {};
+    }
+    getValidationConfiguration() {
+        return {};
+    }
+};
+ExampleAiProviderService = __decorate([
+    Singleton()
+], ExampleAiProviderService);
+export { ExampleAiProviderService };

package/examples/document-management/main.js

@@ -6,7 +6,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import '../../polyfills.js';
 import { configureGenkit } from '../../ai/genkit/module.js';
-import { configureAiService } from '../../ai/index.js';
 import { MockApiRequestTokenProvider } from '../../api/server/api-request-token.provider.js';
 import { configureApiServer } from '../../api/server/module.js';
 import { Application } from '../../application/application.js';
@@ -28,6 +27,7 @@ import { configureOrm } from '../../orm/server/index.js';
 import { configureDefaultSignalsImplementation } from '../../signals/implementation/configure.js';
 import { configurePostgresTaskQueue, migratePostgresTaskQueueSchema } from '../../task-queue/postgres/index.js';
 import { boolean, positiveInteger, string } from '../../utils/config-parser.js';
+import { ExampleAiProviderService } from './ai-provider.js';
 import { TstdlCategoryParents, TstdlDocumentCategoryLabels, TstdlDocumentPropertyConfiguration, TstdlDocumentTypeCategories, TstdlDocumentTypeLabels, TstdlDocumentTypeProperties } from './categories-and-types.js';
 const config = {
     database: {
@@ -42,8 +42,8 @@ const config = {
         apiKey: string('AI_API_KEY', undefined),
         keyFile: string('AI_API_KEY_FILE', undefined),
         vertex: {
-            project: string('AI_VERTEX_PROJECT', undefined),
-            location: string('AI_VERTEX_LOCATION', undefined),
+            project: string('AI_VERTEX_PROJECT', 'tstdl-dev'),
+            location: string('AI_VERTEX_LOCATION', 'tstdl-dev'),
         },
     },
     s3: {
@@ -108,6 +108,7 @@ async function bootstrap() {
     configureDocumentManagement({
         ancillaryService: ExampleDocumentManagementAncillaryService,
         authorizationService: AllowAllDocumentManagementAuthorizationService,
+        aiProvider: ExampleAiProviderService,
         fileObjectStorageModule: 'documents',
         fileUploadObjectStorageModule: 'document-uploads',
         filePreviewObjectStorageModule: 'document-previews',
@@ -132,9 +133,11 @@ async function bootstrap() {
             },
         },
     });
-    configureAiService({
-        apiKey: config.ai.apiKey,
-        keyFile: config.ai.keyFile,
+    configureGenkit({
+        vertex: {
+            projectId: config.ai.vertex.project,
+            location: config.ai.vertex.location,
+        },
     });
     await runInInjectionContext(injector, migrateDocumentManagementSchema);
     await runInInjectionContext(injector, migratePostgresCircuitBreaker);

package/examples/injector/graph-example.d.ts

@@ -0,0 +1 @@
+import '../../polyfills.js';

package/examples/injector/graph-example.js

@@ -0,0 +1,340 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import '../../polyfills.js';
+import { Application, provideModule } from '../../application/index.js';
+import { Injectable, Injector, ReplaceClass, Scoped, Singleton, afterResolve, forwardRef, generateApplicationDependencyGraph, generateApplicationDependencyGraphD2, inject, injectAll, injectArgument, injectManyAsync, injectionToken, provide, resolveArgumentType, runInInjectionContext, } from '../../injector/index.js';
+import { LogLevel, Logger, PrettyPrintLogFormatter, provideConsoleLogTransport } from '../../logger/index.js';
+import { Module } from '../../module/index.js';
+// --- 1. System Tokens & Interfaces ---
+const APP_NAME = injectionToken('APP_NAME');
+const API_URL = injectionToken('API_URL');
+const PLUGIN = injectionToken('PLUGIN');
+const FEATURE_FLAGS = injectionToken('FEATURE_FLAGS');
+const CONFIG = injectionToken('CONFIG');
+const LOCAL_SECRET = injectionToken('LOCAL_SECRET');
+const BASE_TOKEN = injectionToken('BASE_TOKEN');
+// --- 2. Shared Infrastructure ---
+let Metrics = class Metrics {
+    logger = inject(Logger);
+    track(event) { this.logger.info(`Metric: ${event}`); }
+};
+Metrics = __decorate([
+    Singleton()
+], Metrics);
+// --- 3. Factory & Manual Providers ---
+let ConfigService = class ConfigService {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+};
+ConfigService = __decorate([
+    Singleton(),
+    __metadata("design:paramtypes", [Object])
+], ConfigService);
+// --- 4. Async & Resource Management ---
+let ConnectionPool = class ConnectionPool {
+    logger = inject(Logger);
+    active = false;
+    async [afterResolve](_arg, { addDisposeHandler }) {
+        this.logger.info('Pool connecting...');
+        await new Promise(r => setTimeout(r, 10));
+        this.active = true;
+        addDisposeHandler(async () => this.logger.info('Pool disconnected.'));
+    }
+    async [Symbol.asyncDispose]() { }
+};
+ConnectionPool = __decorate([
+    Singleton()
+], ConnectionPool);
+// --- 5. Scoped Resources ---
+let ModuleCache = class ModuleCache {
+    id = Math.random().toString(36).substring(7);
+};
+ModuleCache = __decorate([
+    Scoped('injector')
+], ModuleCache);
+let RequestContext = class RequestContext {
+    requestId = Math.random().toString(36).substring(7);
+};
+RequestContext = __decorate([
+    Scoped('resolution')
+], RequestContext);
+let TransientTask = class TransientTask {
+    id = Math.random().toString(36).substring(7);
+};
+TransientTask = __decorate([
+    Injectable() // Defaults to transient
+], TransientTask);
+// --- 6. Argument Handling & Advanced Forwarding ---
+let Validator = class Validator {
+    // Map partial argument from parent resolve
+    userRole = injectArgument(this, { optional: true })?.role;
+    logger = inject(Logger);
+    validate() {
+        this.logger.info(`Validating role: ${this.userRole}`);
+        return this.userRole === 'ADMIN';
+    }
+};
+Validator = __decorate([
+    Injectable({
+        // Default argument provider if none provided during resolve
+        defaultArgumentProvider: () => ({ id: 'GUEST-' + Math.random().toString(36).substring(7), role: 'GUEST' }),
+        // Custom identity provider for resolution/singleton scoping
+        argumentIdentityProvider: (arg) => arg.id,
+    })
+], Validator);
+let ActionWorker = class ActionWorker {
+    logger = inject(Logger);
+    user = injectArgument(this, { optional: true });
+    subValidator = inject(Validator, { ...this.user, role: 'SUB-' + (this.user?.role ?? 'NONE') }, { optional: true });
+    // Forward our argument to validator manually
+    validator = inject(Validator, injectArgument(this, { optional: true }));
+    execute(action) {
+        const u = this.user ? `${this.user.role}:${this.user.id}` : 'anon';
+        this.subValidator?.validate();
+        if (this.validator.validate()) {
+            this.logger.info(`Action "${action}" by ${u} (AUTHORIZED)`);
+        }
+    }
+};
+ActionWorker = __decorate([
+    Injectable()
+], ActionWorker);
+// --- 7. Hierarchy Control (skipSelf / onlySelf) ---
+let HierarchyDemo = class HierarchyDemo {
+    // Specifically want the logger from the parent, ignoring any local overrides
+    parentLogger = inject(Logger, undefined, { skipSelf: true });
+    // Only want local metrics, fail if not found locally
+    localMetrics = inject(Metrics, undefined, { onlySelf: true, optional: true });
+};
+HierarchyDemo = __decorate([
+    Singleton()
+], HierarchyDemo);
+// --- 8. Diamond Dependency Shape ---
+let DiamondTop = class DiamondTop {
+    l = inject(Logger);
+};
+DiamondTop = __decorate([
+    Singleton()
+], DiamondTop);
+let DiamondLeft = class DiamondLeft {
+    t = inject(DiamondTop);
+};
+DiamondLeft = __decorate([
+    Singleton()
+], DiamondLeft);
+let DiamondRight = class DiamondRight {
+    t = inject(DiamondTop);
+};
+DiamondRight = __decorate([
+    Singleton()
+], DiamondRight);
+let DiamondBottom = class DiamondBottom {
+    l = inject(DiamondLeft);
+    r = inject(DiamondRight);
+    m = inject(Metrics);
+};
+DiamondBottom = __decorate([
+    Singleton()
+], DiamondBottom);
+// --- 9. Circular Hub ---
+let ServiceAlpha = class ServiceAlpha {
+    beta = inject(forwardRef(() => ServiceBeta));
+    name = 'Alpha';
+};
+ServiceAlpha = __decorate([
+    Singleton()
+], ServiceAlpha);
+let ServiceBeta = class ServiceBeta {
+    gamma = inject(forwardRef(() => ServiceGamma));
+    name = 'Beta';
+};
+ServiceBeta = __decorate([
+    Singleton()
+], ServiceBeta);
+let ServiceGamma = class ServiceGamma {
+    alpha = inject(ServiceAlpha);
+    metrics = inject(Metrics);
+    name = 'Gamma';
+};
+ServiceGamma = __decorate([
+    Singleton()
+], ServiceGamma);
+// --- 10. Multi-providers & Bridge ---
+const ADAPTER = injectionToken('ADAPTER');
+let MyAdapter = class MyAdapter {
+    name = 'Postgres';
+};
+MyAdapter = __decorate([
+    Singleton({ alias: ADAPTER })
+], MyAdapter);
+let Plugin1 = class Plugin1 {
+    name = 'P1';
+    run() { }
+};
+Plugin1 = __decorate([
+    Singleton({ alias: PLUGIN, multi: true })
+], Plugin1);
+let Plugin2 = class Plugin2 {
+    name = 'P2';
+    run() { }
+};
+Plugin2 = __decorate([
+    Singleton({ alias: PLUGIN, multi: true })
+], Plugin2);
+// --- 11. Class Local Providers ---
+// This feature allows a class to define providers that are only available to its own dependencies
+let SecureVault = class SecureVault {
+    secret = inject(LOCAL_SECRET);
+    logger = inject(Logger);
+    open() {
+        this.logger.info(`Vault opened with secret: ${this.secret}`);
+    }
+};
+SecureVault = __decorate([
+    Singleton({
+        providers: [
+            provide(LOCAL_SECRET, { useValue: 'SuperSecret42' }),
+        ],
+    })
+], SecureVault);
+// --- 12. Decorator Inheritance ---
+let BaseService = class BaseService {
+    logger = inject(Logger);
+};
+BaseService = __decorate([
+    Singleton({ alias: BASE_TOKEN })
+], BaseService);
+// Inherits 'singleton' lifecycle and 'BASE_TOKEN' alias from BaseService
+let ExtendedService = class ExtendedService extends BaseService {
+    doWork() { this.logger.info('Work done in ExtendedService'); }
+};
+ExtendedService = __decorate([
+    Injectable()
+], ExtendedService);
+// --- 13. ReplaceClass ---
+// Used to wrap or type external classes
+let ExternalService = class ExternalService {
+};
+ExternalService = __decorate([
+    Injectable()
+], ExternalService);
+let TypedExternalService = class TypedExternalService {
+};
+TypedExternalService = __decorate([
+    ReplaceClass(ExternalService)
+], TypedExternalService);
+// --- 14. Delayed Injection Demo ---
+let LateService = class LateService {
+    id = Math.random().toString(36).substring(7);
+};
+LateService = __decorate([
+    Singleton()
+], LateService);
+let AnotherLateService = class AnotherLateService {
+    id = Math.random().toString(36).substring(7);
+};
+AnotherLateService = __decorate([
+    Singleton()
+], AnotherLateService);
+let LateConsumer = class LateConsumer {
+    injector = inject(Injector);
+    logger = inject(Logger);
+    async doLateResolve() {
+        this.logger.info('Performing late resolve...');
+        // This resolve happens AFTER the initial app startup graph is captured
+        // But since we are in dev mode, the injector will record it!
+        // And because we capture the ownerToken in the child injector,
+        // this will be linked to LateConsumer in the graph!
+        const late = this.injector.resolve(LateService);
+        const another = this.injector.resolve(AnotherLateService);
+        this.logger.info(`Late resolve finished: ${late.id}, ${another.id}`);
+    }
+};
+LateConsumer = __decorate([
+    Singleton()
+], LateConsumer);
+let DynamicService = class DynamicService {
+    id = Math.random().toString(36).substring(7);
+};
+DynamicService = __decorate([
+    Singleton()
+], DynamicService);
+// --- 15. The Ultimate Orchestrator (as a Module) ---
+let UltimateApp = class UltimateApp extends Module {
+    injector = inject(Injector);
+    logger = inject(Logger);
+    diamond = inject(DiamondBottom);
+    circ = inject(ServiceAlpha);
+    workflow = inject(ActionWorker);
+    pool = inject(ConnectionPool);
+    cache = inject(ModuleCache);
+    ctx = inject(RequestContext);
+    adapter = inject(ADAPTER);
+    config = inject(ConfigService);
+    hierarchy = inject(HierarchyDemo);
+    vault = inject(SecureVault);
+    task1 = inject(TransientTask);
+    task2 = inject(TransientTask);
+    extended = inject(ExtendedService);
+    baseViaAlias = inject(BASE_TOKEN);
+    typedExternal = inject(TypedExternalService);
+    lateConsumer = inject(LateConsumer);
+    dynamic = this.injector.resolve(DynamicService);
+    constructor() {
+        super('UltimateApp');
+    }
+    async _run() {
+        this.logger.info(`UltimateApp starting. Cache: ${this.cache.id}, Request: ${this.ctx.requestId}`);
+        this.vault.open();
+        // Showcase synchronous and asynchronous multiple injection
+        const [adapter] = this.injector.resolveMany(ADAPTER);
+        this.logger.info(`Resolved via resolveMany: ${adapter.name}`);
+        await runInInjectionContext(this.injector, async () => {
+            const logger = inject(Logger);
+            const plugins = injectAll(PLUGIN);
+            logger.info(`Plugins via injectAll: ${plugins.map(p => p.name).join(', ')}`);
+            const [name, url] = await injectManyAsync(APP_NAME, API_URL);
+            this.logger.info(`Resolved via injectManyAsync: ${name} @ ${url}`);
+            this.workflow.execute('STARTUP');
+        });
+        await this.lateConsumer.doLateResolve();
+    }
+};
+UltimateApp = __decorate([
+    Singleton(),
+    __metadata("design:paramtypes", [])
+], UltimateApp);
+// --- 16. Execution & Visualization ---
+const app = Application.create('TheEnterpriseSystem', [
+    provideModule(UltimateApp),
+    provideConsoleLogTransport(PrettyPrintLogFormatter, { level: LogLevel.Trace, stderrOnly: true }),
+    { provide: ExternalService, useClass: ExternalService },
+    { provide: APP_NAME, useValue: 'TheEnterpriseSystem' },
+    { provide: API_URL, useValue: 'https://api.enterprise.tld' },
+    { provide: FEATURE_FLAGS, useValue: { debug: true } },
+    { provide: CONFIG, useValue: { timeout: 5000 } },
+    { provide: PLUGIN, useValue: { name: 'P3', run: () => { } }, multi: true },
+    {
+        provide: ConfigService,
+        useFactory: (_arg, ctx) => new ConfigService(ctx.resolve(CONFIG)),
+    },
+]);
+// Register formatters needed by logger
+app.injector.registerSingleton(PrettyPrintLogFormatter, { useClass: PrettyPrintLogFormatter });
+// Resolve some things before run to show they are captured
+app.injector.resolve(Metrics).track('PRE-RUN');
+await app.runAndWait();
+const useD2 = process.argv.includes('--d2');
+const output = useD2
+    ? generateApplicationDependencyGraphD2(app)
+    : generateApplicationDependencyGraph(app);
+console.log(output);

package/injector/decorators.d.ts

@@ -1,9 +1,9 @@
 import { type Decorator } from '../reflection/index.js';
 import type { Constructor, OneOrMany, Record, Simplify, TypedOmit } from '../types/index.js';
+import { type ForwardRefToken } from './forward-ref.js';
 import type { Provider } from './provider.js';
 import type { InjectionToken } from './token.js';
-import type { InjectMetadata } from './type-info.js';
-import type { ArgumentProvider, ForwardRefInjectionToken, Mapper, RegistrationOptions } from './types.js';
+import type { ArgumentProvider, Mapper, RegistrationOptions } from './types.js';
 export type InjectDecorator = Decorator<'accessor' | 'constructorParameter'>;
 export type InjectableOptions<T, A, C extends Record = Record> = RegistrationOptions<T, A, C> & {
     /** Aliases (tokens) for the class. Useful for example for circular dependencies when you can't use the class itself as a token */
@@ -84,7 +84,7 @@ export declare function ForwardArg<T, U>(mapper: Mapper<T, U>): InjectDecorator;
 export declare function Optional(): InjectDecorator;
 /**
  * Resolve using ForwardRef to handle circular dependencies. Resolve logic derefs all ForwardRefs which are direct properties of resolved instances automatically
- * @param token token to resolve
+ * @param tokenFactory factory function that returns the token
  * @param argument resolve argument
  */
-export declare function ForwardRef<T extends object, A>(token?: ForwardRefInjectionToken<T>, argument?: A, options?: Pick<InjectMetadata, 'forwardRefTypeHint'>): InjectDecorator;
+export declare function ForwardRef<T extends object, A>(tokenFactory: () => InjectionToken<T, A>, argument?: A, options?: Pick<ForwardRefToken, 'typeHint'>): InjectDecorator;

package/injector/decorators.js

@@ -1,8 +1,8 @@
-/* eslint-disable @typescript-eslint/naming-convention */
 import { createClassDecorator, createDecorator, reflectionRegistry } from '../reflection/index.js';
 import { toArray } from '../utils/array/array.js';
 import { filterObject } from '../utils/object/object.js';
 import { isArray, isDefined, isFunction, isNotNull, isPromise } from '../utils/type-guards.js';
+import { forwardRef } from './forward-ref.js';
 import { Injector } from './injector.js';
 import { injectMetadataSymbol, injectableMetadataSymbol, injectableOptionsSymbol } from './symbols.js';
 /**
@@ -63,7 +63,7 @@ export function Injectable(options = {}) {
             Injector.register(token, targetProvider, mergedRegistationOptions);
             if (isDefined(aliases)) {
                 for (const alias of toArray(aliases)) {
-                    Injector.register(alias, { useToken: token });
+                    Injector.register(alias, { useToken: token }, { multi: mergedRegistationOptions.multi });
                 }
             }
         },
@@ -161,13 +161,12 @@ export function Optional() {
 }
 /**
  * Resolve using ForwardRef to handle circular dependencies. Resolve logic derefs all ForwardRefs which are direct properties of resolved instances automatically
- * @param token token to resolve
+ * @param tokenFactory factory function that returns the token
  * @param argument resolve argument
  */
-export function ForwardRef(token, argument, options) {
+export function ForwardRef(tokenFactory, argument, options) {
     const injectMetadata = {
-        forwardRef: token ?? true,
-        forwardRefTypeHint: options?.forwardRefTypeHint,
+        injectToken: forwardRef(tokenFactory, options?.typeHint),
     };
     if (isDefined(argument)) {
         injectMetadata.resolveArgumentProvider = () => argument;

package/injector/forward-ref.d.ts

@@ -0,0 +1,15 @@
+import type { ForwardRefTypeHint } from '../utils/object/forward-ref.js';
+import type { InjectionToken } from './token.js';
+export declare class ForwardRefToken<T = any, A = any> {
+    readonly tokenFactory: () => InjectionToken<T, A>;
+    readonly typeHint?: ForwardRefTypeHint;
+    constructor(tokenFactory: () => InjectionToken<T, A>, typeHint?: ForwardRefTypeHint);
+}
+/**
+ * Creates a forward reference to a token. Useful for circular dependencies.
+ * @param tokenFactory factory function that returns the token
+ * @param typeHint optional type hint for the forward reference proxy
+ * @returns a ForwardRefToken
+ */
+export declare function forwardRef<T, A>(tokenFactory: () => InjectionToken<T, A>, typeHint?: ForwardRefTypeHint): ForwardRefToken<T, A>;
+export declare function isForwardRefToken(value: any): value is ForwardRefToken;

package/injector/forward-ref.js

@@ -0,0 +1,20 @@
+export class ForwardRefToken {
+    tokenFactory;
+    typeHint;
+    constructor(tokenFactory, typeHint) {
+        this.tokenFactory = tokenFactory;
+        this.typeHint = typeHint;
+    }
+}
+/**
+ * Creates a forward reference to a token. Useful for circular dependencies.
+ * @param tokenFactory factory function that returns the token
+ * @param typeHint optional type hint for the forward reference proxy
+ * @returns a ForwardRefToken
+ */
+export function forwardRef(tokenFactory, typeHint) {
+    return new ForwardRefToken(tokenFactory, typeHint);
+}
+export function isForwardRefToken(value) {
+    return value instanceof ForwardRefToken;
+}

package/injector/graph.d.ts

@@ -0,0 +1,113 @@
+import type { Application } from '../application/application.js';
+import { Injector } from './injector.js';
+import type { ResolveChain } from './resolve-chain.js';
+import { type InjectionToken } from './token.js';
+export type GenerateDependencyGraphOptions = {
+    /** Accesses captured during resolution. Used to show real dependency links. */
+    accesses?: {
+        chain: ResolveChain;
+    }[];
+    /** Whether to group nodes by their injector. Defaults to false. */
+    groupByInjector?: boolean;
+    /** Whether to highlight circular dependencies. Defaults to true. */
+    highlightCycles?: boolean;
+    /** Whether to show a legend. Defaults to true. */
+    showLegend?: boolean;
+    /** Whether to show metadata like lifecycle and provider type. Defaults to true. */
+    showMetadata?: boolean;
+    /** Orientation of the graph. Defaults to 'LR'. */
+    rankdir?: 'LR' | 'TB' | 'BT' | 'RL';
+    /** Background color of the graph. */
+    bgcolor?: string;
+    /** Vertical distance between nodes. */
+    nodesep?: number;
+    /** Horizontal distance between ranks. */
+    ranksep?: number;
+    /** Font name for nodes and edges. Defaults to 'Helvetica'. */
+    fontname?: string;
+    /** Font size for nodes. Defaults to 11. */
+    fontsize?: number;
+    /** Tokens to include. If provided, only these tokens and their dependencies are shown. */
+    includeTokens?: InjectionToken[];
+    /** Tokens to exclude from the graph. */
+    excludeTokens?: InjectionToken[];
+    /** Max depth to traverse for dependencies. Only used if includeTokens is specified. */
+    maxDepth?: number;
+    /** Whether to exclude tokens named 'Logger' or 'LogManager' by default. Defaults to true. */
+    excludeLoggers?: boolean;
+};
+export type DependencyGraphNodeMetadata = {
+    lifecycle: string;
+    type: string;
+    hasAfterResolve: boolean;
+};
+export type DependencyGraphEdge = {
+    from: InjectionToken;
+    to: InjectionToken;
+    label: string;
+    isCycle: boolean;
+    color?: string;
+    style?: string;
+    penwidth?: number;
+};
+export type DependencyGraphNode = {
+    token: InjectionToken;
+    name: string;
+    injectorId: number;
+    metadata: DependencyGraphNodeMetadata;
+};
+export type DependencyGraph = {
+    nodes: Map<InjectionToken, DependencyGraphNode>;
+    edges: DependencyGraphEdge[];
+    injectorNames: Map<number, string>;
+    dynamicResolutions: Map<number, Map<InjectionToken, Set<InjectionToken>>>;
+};
+/**
+ * Extracts the dependency graph structure from an injector and optional resolution accesses.
+ * @param injector The injector to analyze.
+ * @param options Options for graph extraction.
+ * @returns A structured representation of the dependency graph.
+ */
+export declare function getDependencyGraph(injector: Injector, options?: GenerateDependencyGraphOptions): DependencyGraph;
+/**
+ * Renders a dependency graph structure into a Graphviz DOT representation.
+ * @param graph The dependency graph to render.
+ * @param options Rendering options.
+ * @returns A string in DOT format.
+ */
+export declare function renderDependencyGraphToDot(graph: DependencyGraph, options?: GenerateDependencyGraphOptions): string;
+/**
+ * Renders a dependency graph structure into a D2 representation.
+ * @param graph The dependency graph to render.
+ * @param options Rendering options.
+ * @returns A string in D2 format.
+ */
+export declare function renderDependencyGraphToD2(graph: DependencyGraph, options?: GenerateDependencyGraphOptions): string;
+/**
+ * Generates a Graphviz DOT representation of the dependency injection graph.
+ * @param injector The injector to analyze.
+ * @param options Options for graph generation.
+ * @returns A string in DOT format.
+ */
+export declare function generateDependencyGraph(injector: Injector, options?: GenerateDependencyGraphOptions): string;
+/**
+ * Generates a D2 representation of the dependency injection graph.
+ * @param injector The injector to analyze.
+ * @param options Options for graph generation.
+ * @returns A string in D2 format.
+ */
+export declare function generateDependencyGraphD2(injector: Injector, options?: GenerateDependencyGraphOptions): string;
+/**
+ * Generates a Graphviz DOT representation of the application's dependency injection graph.
+ * @param application The application to analyze.
+ * @param options Options for graph generation.
+ * @returns A string in DOT format.
+ */
+export declare function generateApplicationDependencyGraph(application: Application, options?: GenerateDependencyGraphOptions): string;
+/**
+ * Generates a D2 representation of the application's dependency injection graph.
+ * @param application The application to analyze.
+ * @param options Options for graph generation.
+ * @returns A string in D2 format.
+ */
+export declare function generateApplicationDependencyGraphD2(application: Application, options?: GenerateDependencyGraphOptions): string;