@haskou/ddd-kernel 0.1.0 → 1.0.0

package/README.md

@@ -1,142 +1,71 @@
+# @haskou/ddd-kernel
 
 [![CI](https://github.com/haskou/ddd-kernel/actions/workflows/ci.yml/badge.svg)](https://github.com/haskou/ddd-kernel/actions/workflows/ci.yml)
 [![codecov](https://codecov.io/gh/haskou/ddd-kernel/branch/main/graph/badge.svg)](https://codecov.io/gh/haskou/ddd-kernel)
 [![npm](https://img.shields.io/npm/v/@haskou/ddd-kernel.svg)](https://www.npmjs.com/package/@haskou/ddd-kernel)
 [![license](https://img.shields.io/npm/l/@haskou/ddd-kernel.svg)](LICENSE)
-
-## Status
-
-This package is currently in early 0.x development. It is used to extract reusable DDD infrastructure from real TypeScript services, but public APIs may still change while the kernel is being hardened.
-
-# @haskou/ddd-kernel
+[![Renovate](https://img.shields.io/badge/renovate-enabled-brightgreen.svg)](https://renovatebot.com)
 
 Framework-agnostic DDD kernel for TypeScript applications and microservices.
 
-The expected startup pattern mirrors `pigeon-swarm-node`: application classes
-are exported as `default`, `node-dependency-injection` generates or loads
-`services.yaml`, and the kernel resolves consumers, schedulers, initializers and
-runtimes through the configured container. Constructor injection is the normal
-path for application services; `Kernel.di` and `this.get()` exist for framework
-boundaries and backwards compatibility.
-
-```ts
-import { applicationConsumers } from './apps/ApplicationConsumers.js';
-import { applicationInitializers } from './apps/ApplicationInitializers.js';
-import { applicationRuntimes } from './apps/ApplicationRuntimes.js';
-import { recurringSchedulers } from './apps/ApplicationSchedulers.js';
-import { Kernel } from '@haskou/ddd-kernel';
-
-const kernel = new Kernel();
-
-await kernel.dependencyInjection();
-
-kernel.registerConsumers(...applicationConsumers);
-await kernel.runInitializers(...applicationInitializers);
-await kernel.runConsumers();
-
-kernel.registerSchedulers(...recurringSchedulers);
-await kernel.runSchedulers();
-
-await kernel.runRuntimes(...applicationRuntimes);
-```
-
-Normal application code should not register factories manually. Application
-services, repositories, adapters, schedulers, runtimes and consumers should be
-default-exported classes so the autowire flow can resolve them.
+`@haskou/ddd-kernel` provides the runtime foundation shared by services that
+are built around aggregates, domain events, consumers, schedulers and explicit
+composition roots. The package keeps application bootstrapping consistent while
+leaving transport, persistence and logging choices behind replaceable adapters.
 
-## Imports
+## Scope
 
-```ts
-import { Kernel } from '@haskou/ddd-kernel';
-import { DependencyInjection } from '@haskou/ddd-kernel/dependency-injection';
-import { AggregateRoot, DomainEvent } from '@haskou/ddd-kernel/domain';
-import { Scheduler } from '@haskou/ddd-kernel/scheduler';
-```
+The core package is responsible for application lifecycle and dependency
+composition. It includes contracts and primitives for:
 
-Optional adapters:
+- dependency injection and service resolution
+- startup and graceful shutdown hooks
+- consumers and consumer middleware
+- schedulers and scheduler error policies
+- runtimes
+- domain events and aggregate roots
+- repositories and pub/sub contracts
+- logging contracts
 
-```ts
-import { InMemoryRepository } from '@haskou/ddd-kernel/adapters/db/in-memory';
-import { MongoRepository } from '@haskou/ddd-kernel/adapters/db/mongo';
-import { InMemoryPubSub } from '@haskou/ddd-kernel/adapters/pubsub/in-memory';
-import { ExpressKernelServer } from '@haskou/ddd-kernel/adapters/ui/express';
-```
+The kernel does not own HTTP, AMQP, MongoDB, WebSocket or logger implementation
+details. Those integrations are exposed as optional adapters, so applications
+only depend on the infrastructure they actually use.
 
-Contracts:
+## Architecture
 
-```ts
-import type { Repository, UnitOfWork } from '@haskou/ddd-kernel/contracts/db';
-import type { Consumer, PubSub } from '@haskou/ddd-kernel/contracts/pubsub';
-```
+The package separates stable contracts from concrete infrastructure:
 
-UI helpers:
+- `@haskou/ddd-kernel` contains the kernel, lifecycle, DI integration and domain
+  primitives.
+- `@haskou/ddd-kernel/adapters/*` contains optional adapter entrypoints.
+- Applications register their own consumers, schedulers, runtimes and adapters
+  at the composition root.
 
-```ts
-import Route from '@haskou/ddd-kernel/adapters/ui/routes';
-import { HttpRouteStatusEnum } from '@haskou/ddd-kernel/contracts/ui';
-```
+Constructor injection is the preferred application pattern. Direct service
+lookup remains available for compatibility and integration boundaries, but it is
+not the primary dependency model.
 
-## Dependency Injection
-
-Default setup:
-
-```ts
-const kernel = new Kernel();
-await kernel.dependencyInjection();
-```
-
-This uses:
-
-- `src` as the source directory.
-- `config/container/services.yaml` as the generated or loaded container file.
-- `CONTAINER_BUILD=true` to regenerate the YAML through autowire.
-
-Override paths when needed:
-
-```ts
-const kernel = new Kernel({
-  servicesYamlPath: 'config/container/services.yaml',
-  sourceDirectory: 'src',
-});
-```
-
-Prefer constructor injection for consumers, schedulers, routes, repositories and
-application services:
-
-```ts
-export default class RegisterUserWhenCreated {
-  constructor(private readonly finder: UserByIdFinder) {}
-}
-```
-
-Use `Kernel.di.getService(...)` only at the composition boundary or in legacy
-code that still extends a base class exposing `this.get()`.
-
-## Example
+## Documentation
 
-See `example/` for a small route/application/domain setup that imports the
-package through `file:..`.
+Usage guides, adapter authoring notes and API reference pages are published at:
 
-```bash
-cd example
-yarn install
-yarn typecheck
-yarn build
-```
+https://haskou.github.io/ddd-kernel/
 
-## Documentation
+The README is intentionally limited to project orientation. Installation,
+startup, DI, AMQP, routes and adapter examples live in the documentation site.
 
-Full documentation is available at **https://haskou.github.io/ddd-kernel/**
+## Release Branches
 
-The documentation includes installation, quick start, examples, error handling, serialization notes, and one reference page per exported class.
+CI publishes npm versions from pull requests merged into the default branch
+according to the source branch prefix:
 
-## Scripts
+| Branch prefix | npm version bump |
+| ------------- | ---------------- |
+| `fix/*`       | Patch            |
+| `feat/*`      | Minor            |
+| `break/*`     | Major            |
 
-```bash
-yarn lint
-yarn typecheck
-yarn build
-```
+Other branch names run validation only and do not publish.
 
 ## License
 

package/dist/DomainEventConsumer-Bg-bOwmh.d.cts

@@ -0,0 +1,11 @@
+import { D as DomainEvent } from './DomainEvent-mXWEtr_J.cjs';
+
+interface DomainEventConsumerContext {
+    readonly metadata: Readonly<Record<string, unknown>>;
+}
+
+declare abstract class DomainEventConsumer {
+    abstract consume(queueName: string, bindingKey: string, domainEvent: typeof DomainEvent, exchange: string, handler: (event: DomainEvent, context?: DomainEventConsumerContext) => Promise<void>): Promise<void>;
+}
+
+export { DomainEventConsumer as D, type DomainEventConsumerContext as a };

package/dist/DomainEventConsumer-BroJmVty.d.ts

@@ -0,0 +1,11 @@
+import { D as DomainEvent } from './DomainEvent-mXWEtr_J.js';
+
+interface DomainEventConsumerContext {
+    readonly metadata: Readonly<Record<string, unknown>>;
+}
+
+declare abstract class DomainEventConsumer {
+    abstract consume(queueName: string, bindingKey: string, domainEvent: typeof DomainEvent, exchange: string, handler: (event: DomainEvent, context?: DomainEventConsumerContext) => Promise<void>): Promise<void>;
+}
+
+export { DomainEventConsumer as D, type DomainEventConsumerContext as a };

package/dist/DomainMessageBus-3jYk7TPw.d.ts

@@ -0,0 +1,13 @@
+import { M as MessageBus } from './MessageBus-oQ9BnW84.js';
+import { D as DomainEventConsumer } from './DomainEventConsumer-BroJmVty.js';
+import { D as DomainEvent } from './DomainEvent-mXWEtr_J.js';
+
+declare abstract class DomainEventPublisher {
+    abstract publish(domainEvents: DomainEvent[]): Promise<void>;
+}
+
+interface DomainMessageBus extends DomainEventConsumer, DomainEventPublisher {
+    registerPublisherHooks: MessageBus['registerPublisherHooks'];
+}
+
+export { DomainEventPublisher as D, type DomainMessageBus as a };

package/dist/DomainMessageBus-OyliPu3Z.d.cts

@@ -0,0 +1,13 @@
+import { M as MessageBus } from './MessageBus-BtUXnd0Y.cjs';
+import { D as DomainEventConsumer } from './DomainEventConsumer-Bg-bOwmh.cjs';
+import { D as DomainEvent } from './DomainEvent-mXWEtr_J.cjs';
+
+declare abstract class DomainEventPublisher {
+    abstract publish(domainEvents: DomainEvent[]): Promise<void>;
+}
+
+interface DomainMessageBus extends DomainEventConsumer, DomainEventPublisher {
+    registerPublisherHooks: MessageBus['registerPublisherHooks'];
+}
+
+export { DomainEventPublisher as D, type DomainMessageBus as a };

package/dist/MessageBus-BtUXnd0Y.d.cts

@@ -0,0 +1,10 @@
+import { M as Message } from './HandlerContext-Lm89pSeG.cjs';
+import { a as PublisherHook, M as MessageHandler, S as Subscription } from './Subscription-4vuAAxax.cjs';
+
+interface MessageBus {
+    publish<TMessage extends Message>(topic: string, message: TMessage): Promise<void>;
+    registerPublisherHooks(...hooks: PublisherHook[]): void;
+    subscribe<TMessage extends Message>(topic: string, consumer: MessageHandler<TMessage, void>): Promise<Subscription>;
+}
+
+export type { MessageBus as M };

package/dist/MessageBus-oQ9BnW84.d.ts

@@ -0,0 +1,10 @@
+import { M as Message } from './HandlerContext-DUUExVo3.js';
+import { a as PublisherHook, M as MessageHandler, S as Subscription } from './Subscription-vtF0lEHP.js';
+
+interface MessageBus {
+    publish<TMessage extends Message>(topic: string, message: TMessage): Promise<void>;
+    registerPublisherHooks(...hooks: PublisherHook[]): void;
+    subscribe<TMessage extends Message>(topic: string, consumer: MessageHandler<TMessage, void>): Promise<Subscription>;
+}
+
+export type { MessageBus as M };

package/dist/{NoFailedMessagesError-0YJKRWPF.d.ts → NoFailedMessagesError-BLpGI-G4.d.ts}

@@ -1,7 +1,10 @@
+import { a as PublisherHook } from './Subscription-vtF0lEHP.js';
 import { L as Log } from './Log-36L3Z84a.js';
+import { P as PublisherHookErrorPolicy } from './PublisherHookErrorPolicy-DSsCNE6O.js';
 import { Channel } from 'amqplib';
 import { D as DomainEvent } from './DomainEvent-mXWEtr_J.js';
 import { C as Constructor } from './Constructor-fyZLLIh8.js';
+import { a as DomainEventConsumerContext } from './DomainEventConsumer-BroJmVty.js';
 
 type AmqpMessage = {
     readonly aggregate_id: string;
@@ -20,11 +23,13 @@ interface AmqpMessageBusAdapterOptions {
     readonly exchange?: string;
     readonly logger?: Log;
     readonly maxRetries?: number;
+    readonly publisherHookErrorPolicy?: PublisherHookErrorPolicy;
+    readonly publisherHooks?: PublisherHook[];
     readonly retryDelayInMilliseconds?: number;
     readonly serviceName?: string;
 }
 
-type DomainEventHandler = (event: DomainEvent) => Promise<void>;
+type DomainEventHandler = (event: DomainEvent, context?: DomainEventConsumerContext) => Promise<void>;
 
 type ConsumerContext = {
     readonly bindingKey: string;

package/dist/{NoFailedMessagesError-Kz7CYWpT.d.cts → NoFailedMessagesError-BjxYoKTR.d.cts}

@@ -1,7 +1,10 @@
+import { a as PublisherHook } from './Subscription-4vuAAxax.cjs';
 import { L as Log } from './Log-36L3Z84a.cjs';
+import { P as PublisherHookErrorPolicy } from './PublisherHookErrorPolicy-CjouTcSR.cjs';
 import { Channel } from 'amqplib';
 import { D as DomainEvent } from './DomainEvent-mXWEtr_J.cjs';
 import { C as Constructor } from './Constructor-fyZLLIh8.cjs';
+import { a as DomainEventConsumerContext } from './DomainEventConsumer-Bg-bOwmh.cjs';
 
 type AmqpMessage = {
     readonly aggregate_id: string;
@@ -20,11 +23,13 @@ interface AmqpMessageBusAdapterOptions {
     readonly exchange?: string;
     readonly logger?: Log;
     readonly maxRetries?: number;
+    readonly publisherHookErrorPolicy?: PublisherHookErrorPolicy;
+    readonly publisherHooks?: PublisherHook[];
     readonly retryDelayInMilliseconds?: number;
     readonly serviceName?: string;
 }
 
-type DomainEventHandler = (event: DomainEvent) => Promise<void>;
+type DomainEventHandler = (event: DomainEvent, context?: DomainEventConsumerContext) => Promise<void>;
 
 type ConsumerContext = {
     readonly bindingKey: string;

package/dist/PublisherHookErrorPolicy-CjouTcSR.d.cts

@@ -0,0 +1,8 @@
+import { P as PublishContext } from './Subscription-4vuAAxax.cjs';
+
+interface PublisherHookErrorPolicy {
+    handleAfterPublishError(error: unknown, context: PublishContext): Promise<void> | void;
+    shouldFailAfterPublish(error: unknown, context: PublishContext): boolean;
+}
+
+export type { PublisherHookErrorPolicy as P };

package/dist/PublisherHookErrorPolicy-DSsCNE6O.d.ts

@@ -0,0 +1,8 @@
+import { P as PublishContext } from './Subscription-vtF0lEHP.js';
+
+interface PublisherHookErrorPolicy {
+    handleAfterPublishError(error: unknown, context: PublishContext): Promise<void> | void;
+    shouldFailAfterPublish(error: unknown, context: PublishContext): boolean;
+}
+
+export type { PublisherHookErrorPolicy as P };

package/dist/RetryPredicate-U7dYnQ4N.d.ts

@@ -0,0 +1,15 @@
+import { a as ConsumerExecutionContext } from './ShutdownHook-CMWLsfu-.js';
+
+interface IdempotencyStore {
+    claim?(key: string): Promise<boolean> | boolean;
+    commit?(key: string): Promise<void> | void;
+    release?(key: string): Promise<void> | void;
+    has(key: string): Promise<boolean> | boolean;
+    mark(key: string): Promise<void> | void;
+}
+
+type RetryDelayResolver = (attempt: number, error: unknown, context: ConsumerExecutionContext) => number | Promise<number>;
+
+type RetryPredicate = (error: unknown, attempt: number, context: ConsumerExecutionContext) => boolean | Promise<boolean>;
+
+export type { IdempotencyStore as I, RetryDelayResolver as R, RetryPredicate as a };

package/dist/RetryPredicate-yT_z9zk1.d.cts

@@ -0,0 +1,15 @@
+import { a as ConsumerExecutionContext } from './ShutdownHook-BjbnCKzr.cjs';
+
+interface IdempotencyStore {
+    claim?(key: string): Promise<boolean> | boolean;
+    commit?(key: string): Promise<void> | void;
+    release?(key: string): Promise<void> | void;
+    has(key: string): Promise<boolean> | boolean;
+    mark(key: string): Promise<void> | void;
+}
+
+type RetryDelayResolver = (attempt: number, error: unknown, context: ConsumerExecutionContext) => number | Promise<number>;
+
+type RetryPredicate = (error: unknown, attempt: number, context: ConsumerExecutionContext) => boolean | Promise<boolean>;
+
+export type { IdempotencyStore as I, RetryDelayResolver as R, RetryPredicate as a };

package/dist/{Scheduler-oigqNOUJ.d.ts → Scheduler-BW-U5Ccg.d.cts}

@@ -24,4 +24,4 @@ declare abstract class Scheduler {
     init(): Promise<void>;
 }
 
-export { type CronExpression as C, Scheduler as S, type SchedulerErrorPolicy as a };
+export { type CronExpression as C, type SchedulerErrorPolicy as S, Scheduler as a };

package/dist/{Scheduler-oigqNOUJ.d.cts → Scheduler-BW-U5Ccg.d.ts}

@@ -24,4 +24,4 @@ declare abstract class Scheduler {
     init(): Promise<void>;
 }
 
-export { type CronExpression as C, Scheduler as S, type SchedulerErrorPolicy as a };
+export { type CronExpression as C, type SchedulerErrorPolicy as S, Scheduler as a };

package/dist/ServiceClass-BkEHcXDi.d.cts

@@ -0,0 +1,72 @@
+import { S as ServiceResolver } from './ServiceResolver-D2Jz-l_Z.cjs';
+
+type DependencyOverrideToken = unknown;
+
+interface ClassDependencyOverride {
+    readonly token: DependencyOverrideToken;
+    readonly useClass: new (...args: never[]) => unknown;
+}
+
+type DependencyOverrideFactory = (resolver: ServiceResolver) => unknown;
+
+interface FactoryDependencyOverride {
+    readonly token: DependencyOverrideToken;
+    readonly useFactory: DependencyOverrideFactory;
+}
+
+interface ValueDependencyOverride {
+    readonly token: DependencyOverrideToken;
+    readonly useValue: unknown;
+}
+
+type DependencyOverride = ClassDependencyOverride | FactoryDependencyOverride | ValueDependencyOverride;
+
+interface DependencyInjectionOptions {
+    readonly containerBuild?: boolean;
+    readonly overrides?: readonly DependencyOverride[];
+    readonly servicesYamlPath: string;
+    readonly sourceDirectory: string;
+}
+
+declare class DependencyInjection implements ServiceResolver {
+    private readonly options;
+    private static configuredInstance;
+    private autowire;
+    private loader;
+    private readonly container;
+    private readonly overrideTokenIds;
+    static configure(options: DependencyInjectionOptions): DependencyInjection;
+    static get instance(): DependencyInjection;
+    constructor(options?: DependencyInjectionOptions);
+    private get definitions();
+    private get aliases();
+    private ensureFolderExists;
+    private getServiceClassName;
+    private getOverrideId;
+    private ensureSyntheticService;
+    private parentMatchesService;
+    private serviceIdMatchesService;
+    private serviceIdReferencesService;
+    private getReferenceId;
+    private getDefinitionArgumentReferences;
+    private findConcreteChildServiceId;
+    private findRegisteredServiceId;
+    private findAliasServiceId;
+    private findReferencedServiceIds;
+    private getOverrideTokenIds;
+    private getOverrideClassServiceId;
+    private applyClassOverride;
+    private applyFactoryOverride;
+    private applyValueOverride;
+    private applyOverrides;
+    private registerParentAliases;
+    compile(): Promise<void>;
+    getService<T>(serviceName: unknown): T;
+}
+
+type ServiceClass<T> = {
+    readonly prototype: T;
+    new (...args: never[]): T;
+};
+
+export { type ClassDependencyOverride as C, DependencyInjection as D, type FactoryDependencyOverride as F, type ServiceClass as S, type ValueDependencyOverride as V, type DependencyInjectionOptions as a, type DependencyOverride as b, type DependencyOverrideFactory as c, type DependencyOverrideToken as d };

package/dist/ServiceClass-Bq_fBC5R.d.ts

@@ -0,0 +1,72 @@
+import { S as ServiceResolver } from './ServiceResolver-D2Jz-l_Z.js';
+
+type DependencyOverrideToken = unknown;
+
+interface ClassDependencyOverride {
+    readonly token: DependencyOverrideToken;
+    readonly useClass: new (...args: never[]) => unknown;
+}
+
+type DependencyOverrideFactory = (resolver: ServiceResolver) => unknown;
+
+interface FactoryDependencyOverride {
+    readonly token: DependencyOverrideToken;
+    readonly useFactory: DependencyOverrideFactory;
+}
+
+interface ValueDependencyOverride {
+    readonly token: DependencyOverrideToken;
+    readonly useValue: unknown;
+}
+
+type DependencyOverride = ClassDependencyOverride | FactoryDependencyOverride | ValueDependencyOverride;
+
+interface DependencyInjectionOptions {
+    readonly containerBuild?: boolean;
+    readonly overrides?: readonly DependencyOverride[];
+    readonly servicesYamlPath: string;
+    readonly sourceDirectory: string;
+}
+
+declare class DependencyInjection implements ServiceResolver {
+    private readonly options;
+    private static configuredInstance;
+    private autowire;
+    private loader;
+    private readonly container;
+    private readonly overrideTokenIds;
+    static configure(options: DependencyInjectionOptions): DependencyInjection;
+    static get instance(): DependencyInjection;
+    constructor(options?: DependencyInjectionOptions);
+    private get definitions();
+    private get aliases();
+    private ensureFolderExists;
+    private getServiceClassName;
+    private getOverrideId;
+    private ensureSyntheticService;
+    private parentMatchesService;
+    private serviceIdMatchesService;
+    private serviceIdReferencesService;
+    private getReferenceId;
+    private getDefinitionArgumentReferences;
+    private findConcreteChildServiceId;
+    private findRegisteredServiceId;
+    private findAliasServiceId;
+    private findReferencedServiceIds;
+    private getOverrideTokenIds;
+    private getOverrideClassServiceId;
+    private applyClassOverride;
+    private applyFactoryOverride;
+    private applyValueOverride;
+    private applyOverrides;
+    private registerParentAliases;
+    compile(): Promise<void>;
+    getService<T>(serviceName: unknown): T;
+}
+
+type ServiceClass<T> = {
+    readonly prototype: T;
+    new (...args: never[]): T;
+};
+
+export { type ClassDependencyOverride as C, DependencyInjection as D, type FactoryDependencyOverride as F, type ServiceClass as S, type ValueDependencyOverride as V, type DependencyInjectionOptions as a, type DependencyOverride as b, type DependencyOverrideFactory as c, type DependencyOverrideToken as d };

package/dist/{Kernel-BWUOUWWI.d.cts → ShutdownHook-BjbnCKzr.d.cts}

@@ -1,10 +1,30 @@
-import { C as Consumer } from './Consumer-CC8ZRCsd.cjs';
-import { C as ConsumerMiddleware, S as ShutdownHook } from './ShutdownHook-Dib5uNKB.cjs';
-import { K as KernelLogger } from './KernelLogger-BESOFrpW.cjs';
+import { D as DomainEvent } from './DomainEvent-mXWEtr_J.cjs';
+import { D as DomainEventConsumer } from './DomainEventConsumer-Bg-bOwmh.cjs';
 import { Route } from './adapters/ui/routes/index.cjs';
-import { D as DependencyInjection, S as ServiceClass } from './ServiceClass-BmNw8fJj.cjs';
+import { b as DependencyOverride, D as DependencyInjection, S as ServiceClass } from './ServiceClass-BkEHcXDi.cjs';
 import { Initializer, Runtime } from './infrastructure/lifecycle/index.cjs';
-import { S as Scheduler } from './Scheduler-oigqNOUJ.cjs';
+import { a as Scheduler } from './Scheduler-BW-U5Ccg.cjs';
+import { K as KernelLogger } from './KernelLogger-BESOFrpW.cjs';
+
+declare abstract class Consumer {
+    private readonly consumer;
+    constructor(consumer: DomainEventConsumer);
+    private runMiddleware;
+    abstract get domainEvent(): typeof DomainEvent;
+    abstract get eventName(): string;
+    abstract get exchange(): string;
+    abstract get queueName(): string;
+    abstract handler(event: DomainEvent): Promise<void>;
+    init(): Promise<void>;
+    get<T>(service: unknown): T;
+}
+
+interface KernelDependencyInjectionOptions {
+    readonly containerBuild?: boolean;
+    readonly overrides?: readonly DependencyOverride[];
+    readonly servicesYamlPath?: string;
+    readonly sourceDirectory?: string;
+}
 
 interface KernelOptions {
     readonly di?: DependencyInjection;
@@ -29,6 +49,7 @@ declare class Kernel {
     static get consumerMiddleware(): ConsumerMiddleware[];
     static get di(): DependencyInjection;
     static get logger(): KernelLogger;
+    static get active(): Kernel;
     static get rootDirectory(): string;
     static get routes(): ServiceClass<Route>[];
     static get schedulers(): Scheduler[];
@@ -46,7 +67,8 @@ declare class Kernel {
     get logger(): KernelLogger;
     get routes(): ServiceClass<Route>[];
     get schedulers(): Scheduler[];
-    dependencyInjection(): Promise<void>;
+    private getDependencyInjectionOptions;
+    dependencyInjection(options?: KernelDependencyInjectionOptions): Promise<void>;
     getRoutes(): ServiceClass<Route>[];
     registerConsumerMiddleware(...middlewares: ConsumerMiddleware[]): void;
     registerConsumers(...ClassDefinitions: ServiceClass<Consumer>[]): void;
@@ -67,4 +89,24 @@ declare class Kernel {
 }
 declare function createKernel(options?: KernelOptions): Kernel;
 
-export { Kernel as K, type KernelOptions as a, createKernel as c };
+interface ConsumerExecutionContext {
+    readonly causationId?: string;
+    readonly correlationId?: string;
+    readonly eventId: string;
+    readonly eventName: string;
+    readonly exchange: string;
+    readonly kernel: Kernel;
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly rawMessage?: unknown;
+    readonly queueName: string;
+}
+
+type ConsumerNext = () => Promise<void>;
+
+interface ConsumerMiddleware {
+    handle(event: DomainEvent, next: ConsumerNext, context: ConsumerExecutionContext): Promise<void>;
+}
+
+type ShutdownHook = () => Promise<void> | void;
+
+export { Consumer as C, Kernel as K, type ShutdownHook as S, type ConsumerExecutionContext as a, type ConsumerMiddleware as b, type ConsumerNext as c, type KernelDependencyInjectionOptions as d, type KernelOptions as e, createKernel as f };