@haskou/ddd-kernel 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Haskou
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,143 @@
+
+[![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
+
+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.
+
+## Imports
+
+```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';
+```
+
+Optional adapters:
+
+```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';
+```
+
+Contracts:
+
+```ts
+import type { Repository, UnitOfWork } from '@haskou/ddd-kernel/contracts/db';
+import type { Consumer, PubSub } from '@haskou/ddd-kernel/contracts/pubsub';
+```
+
+UI helpers:
+
+```ts
+import Route from '@haskou/ddd-kernel/adapters/ui/routes';
+import { HttpRouteStatusEnum } from '@haskou/ddd-kernel/contracts/ui';
+```
+
+## 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
+
+See `example/` for a small route/application/domain setup that imports the
+package through `file:..`.
+
+```bash
+cd example
+yarn install
+yarn typecheck
+yarn build
+```
+
+## Documentation
+
+Full documentation is available at **https://haskou.github.io/ddd-kernel/**
+
+The documentation includes installation, quick start, examples, error handling, serialization notes, and one reference page per exported class.
+
+## Scripts
+
+```bash
+yarn lint
+yarn typecheck
+yarn build
+```
+
+## License
+
+MIT. See [LICENSE](LICENSE).

package/dist/Constructor-fyZLLIh8.d.cts

@@ -0,0 +1,5 @@
+type Constructor<T> = {
+    new (...args: unknown[]): T;
+};
+
+export type { Constructor as C };

package/dist/Constructor-fyZLLIh8.d.ts

@@ -0,0 +1,5 @@
+type Constructor<T> = {
+    new (...args: unknown[]): T;
+};
+
+export type { Constructor as C };

package/dist/Consumer-CC8ZRCsd.d.cts

@@ -0,0 +1,17 @@
+import { D as DomainEventConsumer } from './DomainEventConsumer-3WBMSSr2.cjs';
+import { D as DomainEvent } from './DomainEvent-mXWEtr_J.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;
+}
+
+export { Consumer as C };

package/dist/Consumer-CeT0Wbxb.d.ts

@@ -0,0 +1,17 @@
+import { D as DomainEventConsumer } from './DomainEventConsumer-B4hkIUmP.js';
+import { D as DomainEvent } from './DomainEvent-mXWEtr_J.js';
+
+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;
+}
+
+export { Consumer as C };

package/dist/DomainEvent-mXWEtr_J.d.cts

@@ -0,0 +1,26 @@
+interface Event {
+    decode(): string;
+    encode(data: string): object;
+    eventName(): string;
+}
+
+type EventAttributes = Record<string, unknown>;
+
+declare abstract class DomainEvent implements Event {
+    readonly aggregateId: string;
+    readonly attributes: EventAttributes;
+    readonly eventId: string;
+    readonly occurredOn: Date;
+    private causationId?;
+    private correlationId?;
+    constructor(aggregateId: string, attributes?: EventAttributes, eventId?: string, occurredOn?: Date, correlationId?: string, causationId?: string);
+    encode(data: string): object;
+    decode(): string;
+    getCorrelationId(): string | undefined;
+    getCausationId(): string | undefined;
+    withCorrelationId(correlationId: string): this;
+    withCausationId(causationId: string): this;
+    abstract eventName(): string;
+}
+
+export { DomainEvent as D, type Event as E, type EventAttributes as a };

package/dist/DomainEvent-mXWEtr_J.d.ts

@@ -0,0 +1,26 @@
+interface Event {
+    decode(): string;
+    encode(data: string): object;
+    eventName(): string;
+}
+
+type EventAttributes = Record<string, unknown>;
+
+declare abstract class DomainEvent implements Event {
+    readonly aggregateId: string;
+    readonly attributes: EventAttributes;
+    readonly eventId: string;
+    readonly occurredOn: Date;
+    private causationId?;
+    private correlationId?;
+    constructor(aggregateId: string, attributes?: EventAttributes, eventId?: string, occurredOn?: Date, correlationId?: string, causationId?: string);
+    encode(data: string): object;
+    decode(): string;
+    getCorrelationId(): string | undefined;
+    getCausationId(): string | undefined;
+    withCorrelationId(correlationId: string): this;
+    withCausationId(causationId: string): this;
+    abstract eventName(): string;
+}
+
+export { DomainEvent as D, type Event as E, type EventAttributes as a };

package/dist/DomainEventConsumer-3WBMSSr2.d.cts

@@ -0,0 +1,7 @@
+import { D as DomainEvent } from './DomainEvent-mXWEtr_J.cjs';
+
+declare abstract class DomainEventConsumer {
+    abstract consume(queueName: string, bindingKey: string, domainEvent: typeof DomainEvent, exchange: string, handler: (event: DomainEvent) => Promise<void>): Promise<void>;
+}
+
+export { DomainEventConsumer as D };

package/dist/DomainEventConsumer-B4hkIUmP.d.ts

@@ -0,0 +1,7 @@
+import { D as DomainEvent } from './DomainEvent-mXWEtr_J.js';
+
+declare abstract class DomainEventConsumer {
+    abstract consume(queueName: string, bindingKey: string, domainEvent: typeof DomainEvent, exchange: string, handler: (event: DomainEvent) => Promise<void>): Promise<void>;
+}
+
+export { DomainEventConsumer as D };

package/dist/DomainEventPublisher-8G0lvmdy.d.cts

@@ -0,0 +1,7 @@
+import { D as DomainEvent } from './DomainEvent-mXWEtr_J.cjs';
+
+declare abstract class DomainEventPublisher {
+    abstract publish(domainEvents: DomainEvent[]): Promise<void>;
+}
+
+export { DomainEventPublisher as D };

package/dist/DomainEventPublisher-DhGgM3f2.d.ts

@@ -0,0 +1,7 @@
+import { D as DomainEvent } from './DomainEvent-mXWEtr_J.js';
+
+declare abstract class DomainEventPublisher {
+    abstract publish(domainEvents: DomainEvent[]): Promise<void>;
+}
+
+export { DomainEventPublisher as D };

package/dist/HandlerContext-DUUExVo3.d.ts

@@ -0,0 +1,20 @@
+import { S as ServiceResolver } from './ServiceResolver-D2Jz-l_Z.js';
+
+type MessageMetadata = Readonly<Record<string, unknown>>;
+
+interface Message<Name extends string = string, Payload = unknown> {
+    readonly name: Name;
+    readonly payload: Payload;
+    readonly metadata?: MessageMetadata;
+}
+
+interface DomainEvent<Name extends string = string, Payload = unknown> extends Message<Name, Payload> {
+    readonly occurredAt: Date;
+}
+
+interface HandlerContext {
+    readonly di: ServiceResolver;
+    readonly publish: (event: DomainEvent) => Promise<void>;
+}
+
+export type { DomainEvent as D, HandlerContext as H, Message as M, MessageMetadata as a };

package/dist/HandlerContext-Lm89pSeG.d.cts

@@ -0,0 +1,20 @@
+import { S as ServiceResolver } from './ServiceResolver-D2Jz-l_Z.cjs';
+
+type MessageMetadata = Readonly<Record<string, unknown>>;
+
+interface Message<Name extends string = string, Payload = unknown> {
+    readonly name: Name;
+    readonly payload: Payload;
+    readonly metadata?: MessageMetadata;
+}
+
+interface DomainEvent<Name extends string = string, Payload = unknown> extends Message<Name, Payload> {
+    readonly occurredAt: Date;
+}
+
+interface HandlerContext {
+    readonly di: ServiceResolver;
+    readonly publish: (event: DomainEvent) => Promise<void>;
+}
+
+export type { DomainEvent as D, HandlerContext as H, Message as M, MessageMetadata as a };

package/dist/Kernel-BWUOUWWI.d.cts

@@ -0,0 +1,70 @@
+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 { Route } from './adapters/ui/routes/index.cjs';
+import { D as DependencyInjection, S as ServiceClass } from './ServiceClass-BmNw8fJj.cjs';
+import { Initializer, Runtime } from './infrastructure/lifecycle/index.cjs';
+import { S as Scheduler } from './Scheduler-oigqNOUJ.cjs';
+
+interface KernelOptions {
+    readonly di?: DependencyInjection;
+    readonly logger?: KernelLogger;
+    readonly servicesYamlPath?: string;
+    readonly sourceDirectory?: string;
+}
+
+declare class Kernel {
+    private readonly options;
+    private static readonly stateKey;
+    private readonly consumerMiddlewares;
+    private readonly consumersList;
+    private readonly loggerInstance;
+    private readonly routesList;
+    private readonly schedulersList;
+    private readonly shutdownHooks;
+    private dependencyInjectionInstance;
+    private static get state();
+    static get configDirectory(): string;
+    static get consumers(): Consumer[];
+    static get consumerMiddleware(): ConsumerMiddleware[];
+    static get di(): DependencyInjection;
+    static get logger(): KernelLogger;
+    static get rootDirectory(): string;
+    static get routes(): ServiceClass<Route>[];
+    static get schedulers(): Scheduler[];
+    static get sourceDirectory(): string;
+    private static getActiveKernel;
+    constructor(options?: KernelOptions);
+    private closeCandidate;
+    private getConsumerFromClass;
+    private getInitializerFromClass;
+    private getRuntimeFromClass;
+    private getSchedulerFromClass;
+    get consumers(): Consumer[];
+    get consumerMiddleware(): ConsumerMiddleware[];
+    get di(): DependencyInjection;
+    get logger(): KernelLogger;
+    get routes(): ServiceClass<Route>[];
+    get schedulers(): Scheduler[];
+    dependencyInjection(): Promise<void>;
+    getRoutes(): ServiceClass<Route>[];
+    registerConsumerMiddleware(...middlewares: ConsumerMiddleware[]): void;
+    registerConsumers(...ClassDefinitions: ServiceClass<Consumer>[]): void;
+    registerConsumerInstances(...consumers: Consumer[]): void;
+    registerRoutes(...ClassDefinitions: ServiceClass<Route>[]): void;
+    registerSchedulers(...ClassDefinitions: ServiceClass<Scheduler>[]): void;
+    registerSchedulerInstances(...schedulers: Scheduler[]): void;
+    registerShutdownHook(hook: ShutdownHook): void;
+    removeConsumers(): void;
+    removeRoutes(): void;
+    removeSchedulers(): void;
+    runConsumers(): Promise<void>;
+    runInitializers(...ClassDefinitions: ServiceClass<Initializer>[]): Promise<void>;
+    runRuntimes(...ClassDefinitions: ServiceClass<Runtime>[]): Promise<void>;
+    runSchedulerNowAndSchedule(ClassDefinition: ServiceClass<Scheduler>): Promise<void>;
+    runSchedulers(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+declare function createKernel(options?: KernelOptions): Kernel;
+
+export { Kernel as K, type KernelOptions as a, createKernel as c };

package/dist/Kernel-CUaqHa1s.d.ts

@@ -0,0 +1,70 @@
+import { C as Consumer } from './Consumer-CeT0Wbxb.js';
+import { C as ConsumerMiddleware, S as ShutdownHook } from './ShutdownHook-BGskq2-q.js';
+import { K as KernelLogger } from './KernelLogger-BESOFrpW.js';
+import { Route } from './adapters/ui/routes/index.js';
+import { D as DependencyInjection, S as ServiceClass } from './ServiceClass-C7NCKdSS.js';
+import { Initializer, Runtime } from './infrastructure/lifecycle/index.js';
+import { S as Scheduler } from './Scheduler-oigqNOUJ.js';
+
+interface KernelOptions {
+    readonly di?: DependencyInjection;
+    readonly logger?: KernelLogger;
+    readonly servicesYamlPath?: string;
+    readonly sourceDirectory?: string;
+}
+
+declare class Kernel {
+    private readonly options;
+    private static readonly stateKey;
+    private readonly consumerMiddlewares;
+    private readonly consumersList;
+    private readonly loggerInstance;
+    private readonly routesList;
+    private readonly schedulersList;
+    private readonly shutdownHooks;
+    private dependencyInjectionInstance;
+    private static get state();
+    static get configDirectory(): string;
+    static get consumers(): Consumer[];
+    static get consumerMiddleware(): ConsumerMiddleware[];
+    static get di(): DependencyInjection;
+    static get logger(): KernelLogger;
+    static get rootDirectory(): string;
+    static get routes(): ServiceClass<Route>[];
+    static get schedulers(): Scheduler[];
+    static get sourceDirectory(): string;
+    private static getActiveKernel;
+    constructor(options?: KernelOptions);
+    private closeCandidate;
+    private getConsumerFromClass;
+    private getInitializerFromClass;
+    private getRuntimeFromClass;
+    private getSchedulerFromClass;
+    get consumers(): Consumer[];
+    get consumerMiddleware(): ConsumerMiddleware[];
+    get di(): DependencyInjection;
+    get logger(): KernelLogger;
+    get routes(): ServiceClass<Route>[];
+    get schedulers(): Scheduler[];
+    dependencyInjection(): Promise<void>;
+    getRoutes(): ServiceClass<Route>[];
+    registerConsumerMiddleware(...middlewares: ConsumerMiddleware[]): void;
+    registerConsumers(...ClassDefinitions: ServiceClass<Consumer>[]): void;
+    registerConsumerInstances(...consumers: Consumer[]): void;
+    registerRoutes(...ClassDefinitions: ServiceClass<Route>[]): void;
+    registerSchedulers(...ClassDefinitions: ServiceClass<Scheduler>[]): void;
+    registerSchedulerInstances(...schedulers: Scheduler[]): void;
+    registerShutdownHook(hook: ShutdownHook): void;
+    removeConsumers(): void;
+    removeRoutes(): void;
+    removeSchedulers(): void;
+    runConsumers(): Promise<void>;
+    runInitializers(...ClassDefinitions: ServiceClass<Initializer>[]): Promise<void>;
+    runRuntimes(...ClassDefinitions: ServiceClass<Runtime>[]): Promise<void>;
+    runSchedulerNowAndSchedule(ClassDefinition: ServiceClass<Scheduler>): Promise<void>;
+    runSchedulers(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+declare function createKernel(options?: KernelOptions): Kernel;
+
+export { Kernel as K, type KernelOptions as a, createKernel as c };

package/dist/KernelLogger-BESOFrpW.d.cts

@@ -0,0 +1,8 @@
+interface KernelLogger {
+    debug(message: string): void;
+    error(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+}
+
+export type { KernelLogger as K };

package/dist/KernelLogger-BESOFrpW.d.ts

@@ -0,0 +1,8 @@
+interface KernelLogger {
+    debug(message: string): void;
+    error(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+}
+
+export type { KernelLogger as K };

package/dist/Log-36L3Z84a.d.cts

@@ -0,0 +1,8 @@
+interface Log {
+    debug(message: string): void;
+    error(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+}
+
+export type { Log as L };

package/dist/Log-36L3Z84a.d.ts

@@ -0,0 +1,8 @@
+interface Log {
+    debug(message: string): void;
+    error(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+}
+
+export type { Log as L };

package/dist/NoFailedMessagesError-0YJKRWPF.d.ts

@@ -0,0 +1,45 @@
+import { L as Log } from './Log-36L3Z84a.js';
+import { Channel } from 'amqplib';
+import { D as DomainEvent } from './DomainEvent-mXWEtr_J.js';
+import { C as Constructor } from './Constructor-fyZLLIh8.js';
+
+type AmqpMessage = {
+    readonly aggregate_id: string;
+    readonly attributes: Record<string, unknown>;
+    readonly causation_id?: string;
+    readonly correlation_id?: string;
+    readonly error?: string;
+    readonly event_id: string;
+    readonly occurred_on?: number | string;
+    readonly retries?: number;
+    readonly type: string;
+};
+
+interface AmqpMessageBusAdapterOptions {
+    readonly dsn?: string;
+    readonly exchange?: string;
+    readonly logger?: Log;
+    readonly maxRetries?: number;
+    readonly retryDelayInMilliseconds?: number;
+    readonly serviceName?: string;
+}
+
+type DomainEventHandler = (event: DomainEvent) => Promise<void>;
+
+type ConsumerContext = {
+    readonly bindingKey: string;
+    readonly channel: Channel;
+    readonly DomainEventInstance: Constructor<DomainEvent>;
+    readonly handler: DomainEventHandler;
+    readonly queueName: string;
+};
+
+declare class InvalidDomainEventError extends Error {
+    constructor(message: string);
+}
+
+declare class NoFailedMessagesError extends Error {
+    constructor(queueName: string);
+}
+
+export { type AmqpMessage as A, type ConsumerContext as C, type DomainEventHandler as D, InvalidDomainEventError as I, NoFailedMessagesError as N, type AmqpMessageBusAdapterOptions as a };

package/dist/NoFailedMessagesError-Kz7CYWpT.d.cts

@@ -0,0 +1,45 @@
+import { L as Log } from './Log-36L3Z84a.cjs';
+import { Channel } from 'amqplib';
+import { D as DomainEvent } from './DomainEvent-mXWEtr_J.cjs';
+import { C as Constructor } from './Constructor-fyZLLIh8.cjs';
+
+type AmqpMessage = {
+    readonly aggregate_id: string;
+    readonly attributes: Record<string, unknown>;
+    readonly causation_id?: string;
+    readonly correlation_id?: string;
+    readonly error?: string;
+    readonly event_id: string;
+    readonly occurred_on?: number | string;
+    readonly retries?: number;
+    readonly type: string;
+};
+
+interface AmqpMessageBusAdapterOptions {
+    readonly dsn?: string;
+    readonly exchange?: string;
+    readonly logger?: Log;
+    readonly maxRetries?: number;
+    readonly retryDelayInMilliseconds?: number;
+    readonly serviceName?: string;
+}
+
+type DomainEventHandler = (event: DomainEvent) => Promise<void>;
+
+type ConsumerContext = {
+    readonly bindingKey: string;
+    readonly channel: Channel;
+    readonly DomainEventInstance: Constructor<DomainEvent>;
+    readonly handler: DomainEventHandler;
+    readonly queueName: string;
+};
+
+declare class InvalidDomainEventError extends Error {
+    constructor(message: string);
+}
+
+declare class NoFailedMessagesError extends Error {
+    constructor(queueName: string);
+}
+
+export { type AmqpMessage as A, type ConsumerContext as C, type DomainEventHandler as D, InvalidDomainEventError as I, NoFailedMessagesError as N, type AmqpMessageBusAdapterOptions as a };

package/dist/Repository-D9CuAyCV.d.cts

@@ -0,0 +1,7 @@
+interface Repository<TEntity, TId> {
+    findById(id: TId): Promise<TEntity | null>;
+    save(entity: TEntity): Promise<void>;
+    delete(id: TId): Promise<void>;
+}
+
+export type { Repository as R };

package/dist/Repository-D9CuAyCV.d.ts

@@ -0,0 +1,7 @@
+interface Repository<TEntity, TId> {
+    findById(id: TId): Promise<TEntity | null>;
+    save(entity: TEntity): Promise<void>;
+    delete(id: TId): Promise<void>;
+}
+
+export type { Repository as R };

package/dist/Scheduler-oigqNOUJ.d.cts

@@ -0,0 +1,27 @@
+interface CronExpression {
+    readonly dayOfMonth?: number | string;
+    readonly dayOfWeek?: number | string;
+    readonly hour?: number | string;
+    readonly minute?: number | string;
+    readonly month?: number | string;
+    readonly second?: number | string;
+}
+
+interface SchedulerErrorPolicy {
+    handle(error: unknown, scheduler: Scheduler): Promise<void> | void;
+    shouldSkip(error: unknown): boolean;
+}
+
+declare abstract class Scheduler {
+    private readonly errorPolicy;
+    constructor(errorPolicy?: SchedulerErrorPolicy);
+    private parseCronExpression;
+    abstract execute(): Promise<void>;
+    abstract getCronExpression(): CronExpression;
+    abstract getProcessName(): string;
+    runOnce(): Promise<void>;
+    get<T>(service: unknown): T;
+    init(): Promise<void>;
+}
+
+export { type CronExpression as C, Scheduler as S, type SchedulerErrorPolicy as a };