@exium/core 1.0.0-rc.0

package/dist/index.d.ts

@@ -0,0 +1,1801 @@
+import { DynamicModule, OnApplicationBootstrap, NestInterceptor, ExecutionContext, CallHandler, ExceptionFilter, ArgumentsHost, OnApplicationShutdown, INestApplication, INestApplicationContext, Type } from '@nestjs/common';
+import { Logger } from 'nestjs-pino';
+import { ConfigService } from '@nestjs/config';
+import * as _mikro_orm_core from '@mikro-orm/core';
+import { EntityManager, EntityClass, AnyEntity, EntitySchema, FilterQuery } from '@mikro-orm/core';
+import { DiscoveryService } from '@nestjs/core';
+import { Observable } from 'rxjs';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import Redis from 'ioredis';
+import { Kysely } from 'kysely';
+
+interface ExiumApplicationModuleOptions {
+    readonly defaults?: {
+        readonly cacheStore?: boolean;
+        readonly cacheVersionService?: boolean;
+        readonly idempotencyStore?: boolean;
+        readonly auditWriter?: boolean;
+    };
+}
+declare class ExiumApplicationModule {
+    static forRoot(options?: ExiumApplicationModuleOptions): DynamicModule;
+}
+
+type FailureKind = 'validation' | 'not_found' | 'business_rule' | 'authentication' | 'authorization' | 'conflict' | 'idempotency' | 'internal';
+interface Failure {
+    readonly kind: FailureKind;
+    readonly code: string;
+    readonly message: string;
+    readonly field?: string;
+    readonly metadata?: Record<string, unknown>;
+    readonly internal?: Record<string, unknown>;
+}
+declare const Failure: {
+    validation(code: string, message: string, options?: {
+        field?: string;
+        metadata?: Record<string, unknown>;
+        internal?: Record<string, unknown>;
+    }): Failure;
+    notFound(code: string, message: string, metadata?: Record<string, unknown>): Failure;
+    businessRule(code: string, message: string, metadata?: Record<string, unknown>): Failure;
+    authentication(code: string, message: string, metadata?: Record<string, unknown>): Failure;
+    authorization(code: string, message: string, metadata?: Record<string, unknown>): Failure;
+    conflict(code: string, message: string, metadata?: Record<string, unknown>): Failure;
+    idempotency(code: string, message: string, metadata?: Record<string, unknown>): Failure;
+    internal(code: string, message: string, metadata?: Record<string, unknown>): Failure;
+};
+
+interface SuccessResult$1<T, E = Failure> {
+    readonly type: 'success';
+    readonly value: T;
+    isSuccess(): this is SuccessResult$1<T, E>;
+    isFailure(): this is FailureResult<T, E>;
+    map<U>(mapper: (value: T) => U): Result<U, E>;
+    flatMap<U, E2 = E>(mapper: (value: T) => Result<U, E2>): Result<U, E | E2>;
+    mapFailure<E2>(mapper: (error: E) => E2): Result<T, E2>;
+    match<U>(handlers: {
+        success: (value: T) => U;
+        failure: (error: E) => U;
+    }): U;
+}
+interface FailureResult<T = never, E = Failure> {
+    readonly type: 'failure';
+    readonly error: E;
+    isSuccess(): this is SuccessResult$1<T, E>;
+    isFailure(): this is FailureResult<T, E>;
+    map<U>(mapper: (value: T) => U): Result<U, E>;
+    flatMap<U, E2 = E>(mapper: (value: T) => Result<U, E2>): Result<U, E | E2>;
+    mapFailure<E2>(mapper: (error: E) => E2): Result<T, E2>;
+    match<U>(handlers: {
+        success: (value: T) => U;
+        failure: (error: E) => U;
+    }): U;
+}
+type ResultValue<R> = R extends Result<infer T, any> ? T : never;
+type ResultError<R> = R extends Result<any, infer E> ? E : never;
+type ResultRecord = Record<string, Result<any, any>>;
+type CompileValues<T extends ResultRecord> = {
+    [K in keyof T]: ResultValue<T[K]>;
+};
+type CompileErrors<T extends ResultRecord> = Array<ResultError<T[keyof T]>>;
+type Result<T, E = Failure> = SuccessResult$1<T, E> | FailureResult<T, E>;
+declare const Result: {
+    ok<T>(value: T): Result<T, never>;
+    fail<E = Failure>(error: E): Result<never, E>;
+    combine<T, E = Failure>(results: readonly Result<T, E>[]): Result<T[], E[]>;
+    compile<T extends ResultRecord>(results: T): Result<CompileValues<T>, CompileErrors<T>>;
+};
+
+type ResultType<T, E = Failure> = Result<T, E>;
+type FailureType = Failure;
+
+type ReadonlyDate = Omit<Date, 'setTime' | 'setMilliseconds' | 'setUTCMilliseconds' | 'setSeconds' | 'setUTCSeconds' | 'setMinutes' | 'setUTCMinutes' | 'setHours' | 'setUTCHours' | 'setDate' | 'setUTCDate' | 'setMonth' | 'setUTCMonth' | 'setFullYear' | 'setUTCFullYear'>;
+type DeepReadonly<T> = T extends Date ? ReadonlyDate : T extends readonly (infer Item)[] ? ReadonlyArray<DeepReadonly<Item>> : T extends object ? {
+    readonly [Key in keyof T]: DeepReadonly<T[Key]>;
+} : T;
+declare abstract class ValueObject<TProps extends Record<string, unknown>> {
+    protected readonly props: DeepReadonly<TProps>;
+    protected constructor(props: TProps);
+    equals(other?: ValueObject<TProps>): boolean;
+}
+
+type IdStatic<TId extends Id> = {
+    readonly prototype: TId;
+    readonly name: string;
+};
+declare abstract class Id extends ValueObject<{
+    value: string;
+}> {
+    protected constructor(value: string);
+    protected static newUuid(): string;
+    static generate<TId extends Id>(this: IdStatic<TId>): TId;
+    static of<TId extends Id>(this: IdStatic<TId>, value: string): TId;
+    static parse<TId extends Id>(this: IdStatic<TId>, value: string, options?: {
+        field?: string;
+    }): ResultType<TId>;
+    protected static parseUuid(value: string, options: {
+        idType: string;
+        field?: string;
+    }): ResultType<string>;
+    private static create;
+    private static isUuidV7;
+    get value(): string;
+    toString(): string;
+    toJSON(): string;
+}
+
+declare abstract class Entity<TId extends Id> {
+    readonly id: TId;
+    protected constructor(id: TId);
+    equals(other?: Entity<Id> | null): boolean;
+    toString(): string;
+}
+
+declare abstract class DomainEvent {
+    readonly aggregateId: string;
+    readonly eventId: string;
+    readonly occurredAt: Date;
+    abstract readonly name: string;
+    protected constructor(aggregateId: string);
+}
+
+declare abstract class AggregateRoot<TId extends Id> extends Entity<TId> {
+    private domainEvents;
+    protected raise(event: DomainEvent): void;
+    pullDomainEvents(): DomainEvent[];
+}
+
+/**
+ * Marker base class for domain services.
+ *
+ * Domain services contain business logic that does not naturally belong
+ * to a single entity or aggregate — typically operations that coordinate
+ * between multiple domain objects.
+ *
+ * Rules:
+ *  - Stateless: no mutable instance state
+ *  - Pure: no infrastructure dependencies, no I/O
+ *  - No framework imports: do not use @Injectable() or any NestJS decorator
+ *
+ * Registration:
+ *  Domain services are registered as plain providers in NestJS modules.
+ *  Since they have no injected dependencies, @Injectable() is not needed.
+ *
+ *  @Module({ providers: [MoneyTransferService] })
+ */
+declare abstract class DomainService {
+}
+
+declare abstract class Specification<T> {
+    abstract isSatisfiedBy(candidate: T): boolean;
+    and(other: Specification<T>): Specification<T>;
+    or(other: Specification<T>): Specification<T>;
+    not(): Specification<T>;
+}
+
+interface Repository<TAggregate extends AggregateRoot<TId>, TId extends Id> {
+    findById(id: TId): Promise<TAggregate | null>;
+    findByIds(ids: readonly TId[]): Promise<TAggregate[]>;
+    exists(id: TId): Promise<boolean>;
+    save(aggregate: TAggregate): Promise<void>;
+    delete(id: TId): Promise<void>;
+}
+
+interface Auditable$1 {
+    createdAt: Date;
+    updatedAt: Date;
+}
+declare function isAuditable(obj: any): obj is Auditable$1;
+
+interface Versionable {
+    version: number;
+}
+declare function isVersionable(obj: any): obj is Versionable;
+
+declare abstract class UnitOfWork {
+    abstract execute<T>(work: () => Promise<T>): Promise<T>;
+    abstract registerAggregate(aggregate: AggregateRoot<any>): void;
+}
+
+declare abstract class Command<TResult = void> {
+    readonly __resultType?: TResult;
+}
+type CommandResultOf<TCommand extends Command<any>> = TCommand extends Command<infer TResult> ? TResult : never;
+
+declare abstract class CommandHandler<TCommand extends Command<any>> {
+    abstract handle(command: TCommand): Promise<ResultType<CommandResultOf<TCommand>>>;
+}
+
+interface CommandMiddleware {
+    use<TCommand extends Command<any>>(command: TCommand, next: () => Promise<ResultType<CommandResultOf<TCommand>>>): Promise<ResultType<CommandResultOf<TCommand>>>;
+}
+
+type CommandConstructor<TCommand extends Command<any>> = new (...args: any[]) => TCommand;
+declare class CommandRegistry {
+    private readonly handlers;
+    private readonly middlewares;
+    register<TCommand extends Command<any>>(commandType: CommandConstructor<TCommand>, handler: CommandHandler<TCommand>): void;
+    registerMiddleware(middleware: CommandMiddleware, priority?: number): void;
+    resolve<TCommand extends Command<any>>(command: TCommand): CommandHandler<TCommand>;
+    getMiddlewares(): CommandMiddleware[];
+}
+
+declare class CommandExecutor {
+    private readonly registry;
+    constructor(registry: CommandRegistry);
+    execute<TCommand extends Command<any>>(command: TCommand): Promise<ResultType<CommandResultOf<TCommand>>>;
+}
+
+declare abstract class Query<TResult = unknown> {
+    readonly __resultType?: TResult;
+}
+type QueryResultOf<TQuery extends Query<any>> = TQuery extends Query<infer TResult> ? TResult : never;
+
+declare abstract class QueryResult {
+}
+
+declare abstract class QueryHandler<TQuery extends Query<any>> {
+    abstract handle(query: TQuery): Promise<ResultType<QueryResultOf<TQuery>>>;
+}
+
+interface QueryMiddleware {
+    use<TQuery extends Query<any>>(query: TQuery, next: () => Promise<ResultType<QueryResultOf<TQuery>>>): Promise<ResultType<QueryResultOf<TQuery>>>;
+}
+
+type QueryConstructor<TQuery extends Query<any>> = new (...args: any[]) => TQuery;
+declare class QueryRegistry {
+    private readonly handlers;
+    private readonly middlewares;
+    register<TQuery extends Query<any>>(queryType: QueryConstructor<TQuery>, handler: QueryHandler<TQuery>): void;
+    registerMiddleware(middleware: QueryMiddleware, priority?: number): void;
+    resolve<TQuery extends Query<any>>(query: TQuery): QueryHandler<TQuery>;
+    getMiddlewares(): QueryMiddleware[];
+}
+
+declare class QueryExecutor {
+    private readonly registry;
+    constructor(registry: QueryRegistry);
+    execute<TQuery extends Query<any>>(query: TQuery): Promise<ResultType<QueryResultOf<TQuery>>>;
+}
+
+declare abstract class EventHandler<TEvent extends DomainEvent> {
+    abstract handle(event: TEvent): Promise<void>;
+}
+
+type EventConstructor<TEvent extends DomainEvent> = new (...args: any[]) => TEvent;
+declare class EventRegistry {
+    private readonly handlers;
+    register<TEvent extends DomainEvent>(eventType: EventConstructor<TEvent>, handler: EventHandler<TEvent>): void;
+    resolve<TEvent extends DomainEvent>(event: TEvent): EventHandler<TEvent>[];
+}
+
+declare class EventBus {
+    private readonly registry;
+    constructor(registry: EventRegistry);
+    publish<TEvent extends DomainEvent>(event: TEvent): Promise<void>;
+}
+
+declare function HandleCommand<TCommand extends Command<any>>(commandType: new (...args: any[]) => TCommand): ClassDecorator;
+
+declare function HandleQuery<TQuery extends Query<any>>(queryType: new (...args: any[]) => TQuery): ClassDecorator;
+
+declare function HandleEvent<TEvent extends DomainEvent>(eventType: new (...args: any[]) => TEvent): ClassDecorator;
+
+interface MiddlewareOptions {
+    priority?: number;
+}
+declare function RegisterCommandMiddleware(options?: MiddlewareOptions): ClassDecorator;
+declare function RegisterQueryMiddleware(options?: MiddlewareOptions): ClassDecorator;
+
+declare const TRANSACTIONAL_METADATA: unique symbol;
+interface TransactionalOptions {
+    readonly enabled?: boolean;
+}
+declare function Transactional(options?: TransactionalOptions): ClassDecorator;
+declare function NonTransactional(): ClassDecorator;
+
+declare const SKIP_VALIDATION_METADATA: unique symbol;
+declare function SkipValidation(): ClassDecorator;
+
+declare const AUTHORIZATION_METADATA: unique symbol;
+type AuthorizationRequirementMode = 'all' | 'any';
+interface AuthorizationMetadata {
+    readonly allowAnonymous?: boolean;
+    readonly permissions?: readonly string[];
+    readonly permissionMode?: AuthorizationRequirementMode;
+    readonly roles?: readonly string[];
+    readonly roleMode?: AuthorizationRequirementMode;
+}
+declare function AllowAnonymous(): ClassDecorator;
+declare function RequirePermission(...permissions: string[]): ClassDecorator;
+declare function RequireAnyPermission(...permissions: string[]): ClassDecorator;
+declare function RequireRole(...roles: string[]): ClassDecorator;
+declare function RequireAnyRole(...roles: string[]): ClassDecorator;
+
+declare class HandlerNotFoundException extends Error {
+    constructor(name: string);
+}
+
+declare class DuplicateHandlerException extends Error {
+    constructor(type: 'command' | 'query', name: string);
+}
+
+type AuthorizationFailureReason = 'missing_context' | 'missing_user' | 'missing_permission' | 'missing_role' | 'custom_denied';
+declare class AuthorizationException extends Error {
+    readonly operationName: string;
+    readonly reason: AuthorizationFailureReason;
+    readonly required?: readonly string[] | undefined;
+    constructor(operationName: string, reason: AuthorizationFailureReason, required?: readonly string[] | undefined);
+}
+
+type IdempotencyFailureReason = 'missing_key' | 'in_progress' | 'conflict' | 'store_not_configured';
+interface IdempotencyExceptionDetails {
+    readonly scope?: string;
+    readonly key?: string;
+    readonly existingFingerprint?: string;
+    readonly incomingFingerprint?: string;
+}
+declare class IdempotencyException extends Error {
+    readonly operationName: string;
+    readonly reason: IdempotencyFailureReason;
+    readonly details: IdempotencyExceptionDetails;
+    constructor(operationName: string, reason: IdempotencyFailureReason, details?: IdempotencyExceptionDetails);
+}
+
+declare const INTEGRATION_EVENT_MAPPER_METADATA: unique symbol;
+declare function RegisterIntegrationEventMapper(): ClassDecorator;
+
+declare abstract class IntegrationEvent {
+    readonly id: string;
+    readonly name: string;
+    readonly version: number;
+    readonly occurredAt: Date;
+    protected constructor(params: {
+        id: string;
+        name: string;
+        version: number;
+        occurredAt?: Date;
+    });
+}
+
+declare abstract class IntegrationEventMapper<TDomainEvent extends DomainEvent = DomainEvent> {
+    abstract supports(event: DomainEvent): event is TDomainEvent;
+    abstract map(event: TDomainEvent): IntegrationEvent | IntegrationEvent[] | null;
+}
+
+declare class IntegrationEventRegistry {
+    private readonly mappers;
+    register(mapper: IntegrationEventMapper): void;
+    map(domainEvents: readonly DomainEvent[]): IntegrationEvent[];
+}
+
+declare abstract class OutboxWriter {
+    abstract write(events: readonly IntegrationEvent[]): Promise<void>;
+}
+
+declare class NoopOutboxWriter extends OutboxWriter {
+    write(_events: readonly IntegrationEvent[]): Promise<void>;
+}
+
+declare const CACHE_QUERY_METADATA: unique symbol;
+interface CacheQueryOptions {
+    readonly namespace?: string;
+    readonly ttlSeconds?: number;
+    readonly versioned?: boolean;
+}
+interface CacheQueryMetadata {
+    readonly enabled: boolean;
+    readonly namespace?: string;
+    readonly ttlSeconds?: number;
+    readonly versioned: boolean;
+}
+declare function CacheQuery(options?: CacheQueryOptions): ClassDecorator;
+declare function NonCacheable(): ClassDecorator;
+
+declare const INVALIDATE_CACHE_METADATA: unique symbol;
+type CacheInvalidationMode = 'version-bump' | 'delete-prefix' | 'both';
+interface InvalidateCacheOptions {
+    readonly namespaces: readonly string[];
+    readonly mode?: CacheInvalidationMode;
+    /**
+     * Default false.
+     *
+     * Cache invalidation happens after the command succeeds.
+     * If invalidation fails after DB commit, failing the command response may be misleading.
+     */
+    readonly failOnError?: boolean;
+}
+interface InvalidateCacheMetadata {
+    readonly enabled: boolean;
+    readonly namespaces: readonly string[];
+    readonly mode: CacheInvalidationMode;
+    readonly failOnError: boolean;
+}
+declare function InvalidateCache(namespace: string, ...namespaces: string[]): ClassDecorator;
+declare function InvalidateCache(options: InvalidateCacheOptions): ClassDecorator;
+
+declare const IDEMPOTENT_METADATA: unique symbol;
+interface IdempotentOptions {
+    /**
+     * The command property that contains the idempotency key.
+     *
+     * Default: "idempotencyKey"
+     */
+    readonly keyProperty?: string;
+    /**
+     * Logical idempotency scope.
+     *
+     * Default: command class name.
+     */
+    readonly scope?: string;
+    /**
+     * How long the idempotency record should live.
+     *
+     * Default: 24 hours.
+     */
+    readonly ttlSeconds?: number;
+    /**
+     * Protects against reusing the same idempotency key with a different payload.
+     *
+     * Default: true.
+     */
+    readonly fingerprintPayload?: boolean;
+}
+interface IdempotentMetadata {
+    readonly enabled: boolean;
+    readonly keyProperty: string;
+    readonly scope?: string;
+    readonly ttlSeconds: number;
+    readonly fingerprintPayload: boolean;
+}
+declare function Idempotent(options?: IdempotentOptions): ClassDecorator;
+declare function NonIdempotent(): ClassDecorator;
+
+declare const AUDITABLE_METADATA: unique symbol;
+interface AuditableOptions {
+    readonly action: string;
+    readonly resource?: string;
+    /**
+     * Optional static resource id.
+     *
+     * Dynamic resource id extraction can be added later with resourceIdProperty.
+     */
+    readonly resourceId?: string;
+    /**
+     * Optional command/query property path for resource id extraction.
+     *
+     * Example:
+     * resourceIdProperty: "userId"
+     * resourceIdProperty: "payload.customerId"
+     */
+    readonly resourceIdProperty?: string;
+    /**
+     * Extra static metadata written to audit event.
+     */
+    readonly metadata?: Record<string, unknown>;
+    /**
+     * Default false.
+     *
+     * If audit write fails, command/query result should usually not fail.
+     */
+    readonly failOnError?: boolean;
+}
+interface AuditableMetadata {
+    readonly enabled: boolean;
+    readonly action: string;
+    readonly resource?: string;
+    readonly resourceId?: string;
+    readonly resourceIdProperty?: string;
+    readonly metadata?: Record<string, unknown>;
+    readonly failOnError: boolean;
+}
+declare function Auditable(options: AuditableOptions): ClassDecorator;
+declare function NonAuditable(): ClassDecorator;
+
+declare const ApplicationMiddlewarePriority: {
+    readonly Context: 1000;
+    readonly Logging: 900;
+    readonly Validation: 800;
+    readonly Authorization: 700;
+    readonly Idempotency: 600;
+    /**
+     * Runs outside/around transaction middleware.
+     * Its "after next()" section executes after transactional command has committed.
+     */
+    readonly CacheInvalidation: 550;
+    readonly Audit: 525;
+    readonly Transaction: 500;
+    readonly Cache: 400;
+    readonly Metrics: 100;
+};
+
+interface ApplicationValidationErrorItem {
+    readonly property: string;
+    readonly constraints: Record<string, string>;
+    readonly children?: ApplicationValidationErrorItem[];
+}
+
+type ExiumOperationType = 'command' | 'query' | 'event' | 'http' | 'job' | 'unknown';
+interface ExiumExecutionContext {
+    readonly correlationId: string;
+    readonly causationId?: string;
+    readonly requestId?: string;
+    readonly tenantId?: string;
+    readonly userId?: string;
+    readonly roles?: readonly string[];
+    readonly permissions?: readonly string[];
+    readonly locale?: string;
+    readonly source?: string;
+    readonly operationType?: ExiumOperationType;
+    readonly operationName?: string;
+    readonly startedAt: Date;
+}
+
+declare class ExiumContextService {
+    private readonly storage;
+    run<T>(context: Partial<ExiumExecutionContext>, callback: () => Promise<T> | T): Promise<T> | T;
+    get(): ExiumExecutionContext;
+    getOrUndefined(): ExiumExecutionContext | undefined;
+    getCorrelationId(): string | undefined;
+    getTenantId(): string | undefined;
+    getUserId(): string | undefined;
+    withOperation<T>(operationType: ExiumOperationType, operationName: string, callback: () => Promise<T> | T): Promise<T> | T;
+}
+
+declare class ContextCommandMiddleware implements CommandMiddleware {
+    private readonly contextService;
+    constructor(contextService: ExiumContextService);
+    use<TCommand extends Command<any>>(command: TCommand, next: () => Promise<ResultType<CommandResultOf<TCommand>>>): Promise<ResultType<CommandResultOf<TCommand>>>;
+}
+
+declare class ContextQueryMiddleware implements QueryMiddleware {
+    private readonly contextService;
+    constructor(contextService: ExiumContextService);
+    use<TQuery extends Query<any>>(query: TQuery, next: () => Promise<ResultType<QueryResultOf<TQuery>>>): Promise<ResultType<QueryResultOf<TQuery>>>;
+}
+
+declare class LoggingCommandMiddleware implements CommandMiddleware {
+    private readonly logger;
+    private readonly contextService;
+    constructor(logger: Logger, contextService: ExiumContextService);
+    use<TCommand extends Command<any>>(command: TCommand, next: () => Promise<ResultType<CommandResultOf<TCommand>>>): Promise<ResultType<CommandResultOf<TCommand>>>;
+}
+
+declare class LoggingQueryMiddleware implements QueryMiddleware {
+    private readonly logger;
+    private readonly contextService;
+    constructor(logger: Logger, contextService: ExiumContextService);
+    use<TQuery extends Query<any>>(query: TQuery, next: () => Promise<ResultType<QueryResultOf<TQuery>>>): Promise<ResultType<QueryResultOf<TQuery>>>;
+}
+
+declare class ValidationCommandMiddleware implements CommandMiddleware {
+    use<TCommand extends Command<any>>(command: TCommand, next: () => Promise<ResultType<CommandResultOf<TCommand>>>): Promise<ResultType<CommandResultOf<TCommand>>>;
+}
+
+declare class ValidationQueryMiddleware implements QueryMiddleware {
+    use<TQuery extends Query<any>>(query: TQuery, next: () => Promise<ResultType<QueryResultOf<TQuery>>>): Promise<ResultType<QueryResultOf<TQuery>>>;
+}
+
+interface PermissionCheckInput {
+    readonly context: ExiumExecutionContext;
+    readonly operationName: string;
+    readonly permissions?: readonly string[];
+    readonly permissionMode?: 'all' | 'any';
+    readonly roles?: readonly string[];
+    readonly roleMode?: 'all' | 'any';
+}
+interface PermissionCheckResult {
+    readonly allowed: boolean;
+    readonly reason?: string;
+}
+declare abstract class PermissionChecker {
+    abstract check(input: PermissionCheckInput): Promise<PermissionCheckResult>;
+}
+
+declare class AuthorizationCommandMiddleware implements CommandMiddleware {
+    private readonly contextService;
+    private readonly permissionChecker;
+    constructor(contextService: ExiumContextService, permissionChecker: PermissionChecker);
+    use<TCommand extends Command<any>>(command: TCommand, next: () => Promise<ResultType<CommandResultOf<TCommand>>>): Promise<ResultType<CommandResultOf<TCommand>>>;
+}
+
+declare class AuthorizationQueryMiddleware implements QueryMiddleware {
+    private readonly contextService;
+    private readonly permissionChecker;
+    constructor(contextService: ExiumContextService, permissionChecker: PermissionChecker);
+    use<TQuery extends Query<any>>(query: TQuery, next: () => Promise<ResultType<QueryResultOf<TQuery>>>): Promise<ResultType<QueryResultOf<TQuery>>>;
+}
+
+interface CacheGetResult<T> {
+    readonly hit: boolean;
+    readonly value?: T;
+}
+interface CacheSetOptions {
+    readonly ttlSeconds?: number;
+}
+declare abstract class CacheStore {
+    abstract get<T>(key: string): Promise<CacheGetResult<T>>;
+    abstract set<T>(key: string, value: T, options?: CacheSetOptions): Promise<void>;
+    abstract delete(key: string): Promise<void>;
+    abstract deleteByPrefix(prefix: string): Promise<void>;
+}
+
+declare class NoopCacheStore extends CacheStore {
+    get<T>(_key: string): Promise<CacheGetResult<T>>;
+    set<T>(_key: string, _value: T, _options?: CacheSetOptions): Promise<void>;
+    delete(_key: string): Promise<void>;
+    deleteByPrefix(_prefix: string): Promise<void>;
+}
+
+interface CacheKeyFactoryInput {
+    readonly namespace: string;
+    readonly queryName: string;
+    readonly version: string | number;
+    readonly payload: unknown;
+}
+interface CacheKeyPrefixInput {
+    readonly namespace: string;
+    readonly version?: string | number;
+    readonly queryName?: string;
+}
+declare abstract class CacheKeyFactory {
+    abstract create(input: CacheKeyFactoryInput): string;
+    abstract createPrefix(input: CacheKeyPrefixInput): string;
+}
+declare class DefaultCacheKeyFactory extends CacheKeyFactory {
+    create(input: CacheKeyFactoryInput): string;
+    createPrefix(input: CacheKeyPrefixInput): string;
+}
+
+declare abstract class CacheVersionService {
+    abstract getVersion(namespace: string): Promise<string | number>;
+    abstract bumpVersion(namespace: string): Promise<string | number>;
+}
+declare class InMemoryCacheVersionService extends CacheVersionService {
+    private readonly versions;
+    getVersion(namespace: string): Promise<number>;
+    bumpVersion(namespace: string): Promise<number>;
+}
+
+declare class CacheQueryMiddleware implements QueryMiddleware {
+    private readonly cacheStore;
+    private readonly cacheKeyFactory;
+    private readonly cacheVersionService;
+    constructor(cacheStore: CacheStore, cacheKeyFactory: CacheKeyFactory, cacheVersionService: CacheVersionService);
+    use<TQuery extends Query<any>>(query: TQuery, next: () => Promise<ResultType<QueryResultOf<TQuery>>>): Promise<ResultType<QueryResultOf<TQuery>>>;
+}
+
+declare class CacheInvalidationCommandMiddleware implements CommandMiddleware {
+    private readonly cacheStore;
+    private readonly cacheKeyFactory;
+    private readonly cacheVersionService;
+    private readonly logger;
+    constructor(cacheStore: CacheStore, cacheKeyFactory: CacheKeyFactory, cacheVersionService: CacheVersionService, logger: Logger);
+    use<TCommand extends Command<any>>(command: TCommand, next: () => Promise<ResultType<CommandResultOf<TCommand>>>): Promise<ResultType<CommandResultOf<TCommand>>>;
+    private invalidate;
+}
+
+type IdempotencyBeginStatus = 'started' | 'completed' | 'in_progress' | 'conflict';
+interface IdempotencyBeginInput {
+    readonly scope: string;
+    readonly key: string;
+    readonly fingerprint: string;
+    readonly ttlSeconds: number;
+    readonly operationName: string;
+    readonly startedAt: Date;
+}
+type IdempotencyBeginResult<TResult = unknown> = {
+    readonly status: 'started';
+} | {
+    readonly status: 'completed';
+    readonly result: TResult;
+} | {
+    readonly status: 'in_progress';
+} | {
+    readonly status: 'conflict';
+    readonly existingFingerprint?: string;
+    readonly incomingFingerprint: string;
+};
+interface IdempotencyCompleteInput<TResult = unknown> {
+    readonly scope: string;
+    readonly key: string;
+    readonly result: TResult;
+    readonly completedAt: Date;
+}
+interface IdempotencyFailInput {
+    readonly scope: string;
+    readonly key: string;
+    readonly failedAt: Date;
+    readonly error: unknown;
+}
+declare abstract class IdempotencyStore {
+    abstract begin<TResult = unknown>(input: IdempotencyBeginInput): Promise<IdempotencyBeginResult<TResult>>;
+    abstract complete<TResult = unknown>(input: IdempotencyCompleteInput<TResult>): Promise<void>;
+    abstract fail(input: IdempotencyFailInput): Promise<void>;
+}
+
+declare class NoopIdempotencyStore extends IdempotencyStore {
+    begin<TResult = unknown>(input: IdempotencyBeginInput): Promise<IdempotencyBeginResult<TResult>>;
+    complete<TResult = unknown>(_input: IdempotencyCompleteInput<TResult>): Promise<void>;
+    fail(_input: IdempotencyFailInput): Promise<void>;
+}
+
+interface IdempotencyKeyResolverInput {
+    readonly command: object;
+    readonly operationName: string;
+    readonly keyProperty: string;
+}
+declare abstract class IdempotencyKeyResolver {
+    abstract resolve(input: IdempotencyKeyResolverInput): Promise<string | undefined>;
+}
+declare class DefaultIdempotencyKeyResolver extends IdempotencyKeyResolver {
+    resolve(input: IdempotencyKeyResolverInput): Promise<string | undefined>;
+}
+
+interface IdempotencyFingerprintFactoryInput {
+    readonly operationName: string;
+    readonly payload: unknown;
+    readonly excludeProperties?: readonly string[];
+}
+declare abstract class IdempotencyFingerprintFactory {
+    abstract create(input: IdempotencyFingerprintFactoryInput): string;
+}
+declare class DefaultIdempotencyFingerprintFactory extends IdempotencyFingerprintFactory {
+    create(input: IdempotencyFingerprintFactoryInput): string;
+}
+
+declare class IdempotencyCommandMiddleware implements CommandMiddleware {
+    private readonly store;
+    private readonly keyResolver;
+    private readonly fingerprintFactory;
+    constructor(store: IdempotencyStore, keyResolver: IdempotencyKeyResolver, fingerprintFactory: IdempotencyFingerprintFactory);
+    use<TCommand extends Command<any>>(command: TCommand, next: () => Promise<ResultType<CommandResultOf<TCommand>>>): Promise<ResultType<CommandResultOf<TCommand>>>;
+}
+
+type AuditOperationType = 'command' | 'query';
+type AuditOutcome = 'success' | 'failure';
+interface AuditEvent {
+    readonly id?: string;
+    readonly action: string;
+    readonly resource?: string;
+    readonly resourceId?: string;
+    readonly operationType: AuditOperationType;
+    readonly operationName: string;
+    readonly outcome: AuditOutcome;
+    readonly errorName?: string;
+    readonly errorMessage?: string;
+    readonly failureKind?: FailureKind;
+    readonly failureCode?: string;
+    readonly failureMessage?: string;
+    readonly correlationId?: string;
+    readonly causationId?: string;
+    readonly requestId?: string;
+    readonly tenantId?: string;
+    readonly userId?: string;
+    readonly source?: string;
+    readonly locale?: string;
+    readonly durationMs: number;
+    readonly occurredAt: Date;
+    readonly metadata?: Record<string, unknown>;
+}
+
+declare abstract class AuditWriter {
+    abstract write(event: AuditEvent): Promise<void>;
+}
+
+declare class NoopAuditWriter extends AuditWriter {
+    write(_event: AuditEvent): Promise<void>;
+}
+
+declare class AuditCommandMiddleware implements CommandMiddleware {
+    private readonly auditWriter;
+    private readonly contextService;
+    private readonly logger;
+    constructor(auditWriter: AuditWriter, contextService: ExiumContextService, logger: Logger);
+    use<TCommand extends Command<any>>(command: TCommand, next: () => Promise<ResultType<CommandResultOf<TCommand>>>): Promise<ResultType<CommandResultOf<TCommand>>>;
+    private writeAuditSafely;
+}
+
+declare class AuditQueryMiddleware implements QueryMiddleware {
+    private readonly auditWriter;
+    private readonly contextService;
+    private readonly logger;
+    constructor(auditWriter: AuditWriter, contextService: ExiumContextService, logger: Logger);
+    use<TQuery extends Query<any>>(query: TQuery, next: () => Promise<ResultType<QueryResultOf<TQuery>>>): Promise<ResultType<QueryResultOf<TQuery>>>;
+    private writeAuditSafely;
+}
+
+declare class ContextPermissionChecker extends PermissionChecker {
+    check(input: PermissionCheckInput): Promise<PermissionCheckResult>;
+}
+
+interface Finder {
+}
+
+interface ReadModel {
+}
+interface View {
+}
+
+declare class ReadQueryException extends Error {
+    constructor(message: string);
+}
+declare class ReadFieldNotFoundException extends ReadQueryException {
+    constructor(sourceName: string, field: string);
+}
+declare class ReadOperationNotSupportedException extends ReadQueryException {
+    constructor(operation: string, reason?: string);
+}
+
+type CriteriaOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'notIn' | 'contains' | 'startsWith' | 'endsWith' | 'isNull' | 'isNotNull' | 'between';
+interface ComparisonCriteriaNode {
+    readonly type: 'comparison';
+    readonly field: string;
+    readonly operator: Exclude<CriteriaOperator, 'in' | 'notIn' | 'isNull' | 'isNotNull' | 'between'>;
+    readonly value: unknown;
+}
+interface InCriteriaNode {
+    readonly type: 'in';
+    readonly field: string;
+    readonly operator: 'in' | 'notIn';
+    readonly values: readonly unknown[];
+}
+interface IsNullCriteriaNode {
+    readonly type: 'isNull';
+    readonly field: string;
+}
+interface IsNotNullCriteriaNode {
+    readonly type: 'isNotNull';
+    readonly field: string;
+}
+interface BetweenCriteriaNode {
+    readonly type: 'between';
+    readonly field: string;
+    readonly lower: unknown;
+    readonly upper: unknown;
+}
+interface AndCriteriaNode {
+    readonly type: 'and';
+    readonly nodes: readonly CriteriaNode[];
+}
+interface OrCriteriaNode {
+    readonly type: 'or';
+    readonly nodes: readonly CriteriaNode[];
+}
+interface NotCriteriaNode {
+    readonly type: 'not';
+    readonly node: CriteriaNode;
+}
+type CriteriaNode = ComparisonCriteriaNode | InCriteriaNode | IsNullCriteriaNode | IsNotNullCriteriaNode | BetweenCriteriaNode | AndCriteriaNode | OrCriteriaNode | NotCriteriaNode;
+type CriteriaConnector = 'and' | 'or';
+declare class Criteria {
+    readonly node: CriteriaNode | null;
+    private constructor();
+    static empty(): Criteria;
+    static where(field: string): CriteriaFieldBuilder;
+    where(field: string): CriteriaFieldBuilder;
+    and(field: string): CriteriaFieldBuilder;
+    or(field: string): CriteriaFieldBuilder;
+    andGroup(factory: (group: Criteria) => Criteria): Criteria;
+    orGroup(factory: (group: Criteria) => Criteria): Criteria;
+    not(): Criteria;
+    isEmpty(): boolean;
+    private append;
+}
+declare class CriteriaFieldBuilder {
+    private readonly criteria;
+    private readonly connector;
+    private readonly field;
+    constructor(criteria: Criteria, connector: CriteriaConnector, field: string);
+    eq(value: unknown): Criteria;
+    ne(value: unknown): Criteria;
+    gt(value: unknown): Criteria;
+    gte(value: unknown): Criteria;
+    lt(value: unknown): Criteria;
+    lte(value: unknown): Criteria;
+    in(values: readonly unknown[]): Criteria;
+    notIn(values: readonly unknown[]): Criteria;
+    contains(value: string): Criteria;
+    startsWith(value: string): Criteria;
+    endsWith(value: string): Criteria;
+    isNull(): Criteria;
+    isNotNull(): Criteria;
+    between(lower: unknown, upper: unknown): Criteria;
+    private comparison;
+    private inclusion;
+    private addNode;
+}
+
+interface PageRequestOptions {
+    readonly maxSize?: number;
+}
+declare class PageRequest {
+    readonly page: number;
+    readonly size: number;
+    private constructor();
+    static of(page: number, size: number, options?: PageRequestOptions): ResultType<PageRequest>;
+    get offset(): number;
+}
+declare class Page<T> {
+    readonly items: readonly T[];
+    readonly page: number;
+    readonly size: number;
+    readonly totalItems: number;
+    readonly totalPages: number;
+    private constructor();
+    static of<T>(items: readonly T[], request: PageRequest, totalItems: number): Page<T>;
+}
+declare class CursorRequest {
+    readonly after: string | null;
+    readonly before: string | null;
+    readonly limit: number;
+    private constructor();
+    static first(limit: number, options?: PageRequestOptions): ResultType<CursorRequest>;
+    static after(cursor: string, limit: number, options?: PageRequestOptions): ResultType<CursorRequest>;
+    static before(cursor: string, limit: number, options?: PageRequestOptions): ResultType<CursorRequest>;
+    private static create;
+}
+declare class CursorPage<T> {
+    readonly items: readonly T[];
+    readonly hasNext: boolean;
+    readonly hasPrevious: boolean;
+    readonly nextCursor?: string | undefined;
+    readonly previousCursor?: string | undefined;
+    constructor(items: readonly T[], hasNext: boolean, hasPrevious: boolean, nextCursor?: string | undefined, previousCursor?: string | undefined);
+}
+
+type SortDirection = 'asc' | 'desc';
+type SortNulls = 'first' | 'last';
+interface SortField {
+    readonly field: string;
+    readonly direction: SortDirection;
+    readonly nulls?: SortNulls;
+}
+declare class Sort {
+    readonly fields: readonly SortField[];
+    private constructor();
+    static none(): Sort;
+    static by(field: string): SortDirectionBuilder;
+    thenBy(field: string): SortDirectionBuilder;
+    isEmpty(): boolean;
+    static fromFields(fields: readonly SortField[]): Sort;
+}
+declare class SortDirectionBuilder {
+    private readonly previousFields;
+    private readonly field;
+    constructor(previousFields: readonly SortField[], field: string);
+    asc(options?: {
+        readonly nulls?: SortNulls;
+    }): Sort;
+    desc(options?: {
+        readonly nulls?: SortNulls;
+    }): Sort;
+    private build;
+}
+
+interface ReadSource {
+    readonly name: string;
+}
+type SqlJoinType = 'left' | 'inner';
+type SqlJoinOperator = '=' | '!=' | '<' | '<=' | '>' | '>=';
+interface SqlJoinOnRef {
+    readonly left: string;
+    readonly operator: SqlJoinOperator;
+    readonly right: string;
+}
+interface SqlJoin {
+    readonly type: SqlJoinType;
+    readonly table: string;
+    readonly alias: string;
+    readonly on: SqlJoinOnRef;
+}
+interface SqlReadSourceDefinition {
+    readonly name: string;
+    readonly table: string;
+    readonly alias?: string;
+    readonly fields: Record<string, string>;
+    readonly joins?: readonly SqlJoin[];
+    readonly defaultSort?: Sort;
+    readonly defaultSelectedFields?: readonly string[];
+}
+declare class SqlReadSource implements ReadSource {
+    readonly name: string;
+    readonly table: string;
+    readonly alias: string | undefined;
+    readonly fields: Readonly<Record<string, string>>;
+    readonly joins: readonly SqlJoin[];
+    readonly defaultSort: Sort | undefined;
+    readonly defaultSelectedFields: readonly string[] | undefined;
+    private constructor();
+    static define(definition: SqlReadSourceDefinition): SqlReadSource;
+    static is(source: ReadSource): source is SqlReadSource;
+    resolveField(field: string): string;
+    getSelectFields(): readonly string[];
+    getFromExpression(): string;
+}
+declare class Join {
+    static left(table: string, alias: string): JoinBuilder;
+    static inner(table: string, alias: string): JoinBuilder;
+}
+declare class JoinBuilder {
+    private readonly type;
+    private readonly table;
+    private readonly alias;
+    constructor(type: SqlJoinType, table: string, alias: string);
+    onRef(left: string, operator: SqlJoinOperator, right: string): SqlJoin;
+}
+
+type RowMapper<TView> = (row: unknown) => TView;
+interface BaseReadQuery<TView> {
+    readonly from: ReadSource;
+    readonly criteria?: Criteria;
+    readonly sort?: Sort;
+    readonly map?: RowMapper<TView>;
+}
+interface FindOneQuery<TView> extends BaseReadQuery<TView> {
+}
+interface FindManyQuery<TView> extends BaseReadQuery<TView> {
+    readonly limit?: number;
+}
+interface FindPageQuery<TView> extends BaseReadQuery<TView> {
+    readonly page: PageRequest;
+}
+interface FindCursorQuery<TView> extends BaseReadQuery<TView> {
+    readonly cursor: CursorRequest;
+    readonly sort: Sort;
+}
+interface ExistsQuery {
+    readonly from: ReadSource;
+    readonly criteria?: Criteria;
+}
+interface CountQuery {
+    readonly from: ReadSource;
+    readonly criteria?: Criteria;
+}
+interface ReadEngine {
+    findOne<TView>(query: FindOneQuery<TView>): Promise<TView | null>;
+    findMany<TView>(query: FindManyQuery<TView>): Promise<readonly TView[]>;
+    findPage<TView>(query: FindPageQuery<TView>): Promise<Page<TView>>;
+    findCursor<TView>(query: FindCursorQuery<TView>): Promise<CursorPage<TView>>;
+    exists(query: ExistsQuery): Promise<boolean>;
+    count(query: CountQuery): Promise<number>;
+}
+
+declare abstract class AuditableEntity<TId extends Id> extends Entity<TId> {
+    readonly createdAt: Date;
+    updatedAt: Date;
+    constructor(id: TId, createdAt?: Date, updatedAt?: Date);
+    protected touch(): void;
+}
+
+declare abstract class AuditableAggregateRoot<TId extends Id> extends AggregateRoot<TId> implements Auditable$1, Versionable {
+    readonly createdAt: Date;
+    updatedAt: Date;
+    version: number;
+    constructor(id: TId, createdAt?: Date, updatedAt?: Date, version?: number);
+    protected touch(): void;
+}
+
+declare abstract class PrimitiveValueObject<T> extends ValueObject<{
+    value: T;
+}> {
+    get value(): T;
+    protected constructor(value: T);
+}
+
+declare class ExiumConfigModule {
+}
+
+declare class ExiumEnvironment {
+    EXIUM_DB_URL?: string;
+    EXIUM_RABBITMQ_URL?: string;
+    EXIUM_REDIS_URL?: string;
+    EXIUM_LOG_LEVEL?: string;
+    EXIUM_LOG_PRETTY?: boolean;
+}
+
+declare class ExiumConfigService {
+    private readonly configService;
+    constructor(configService: ConfigService<ExiumEnvironment, true>);
+    get isProduction(): boolean;
+    get databaseUrl(): string | undefined;
+    getRequiredDatabaseUrl(): string;
+    get rabbitMqUrl(): string | undefined;
+    get redisUrl(): string | undefined;
+    get logLevel(): string | undefined;
+    get logPretty(): boolean | undefined;
+}
+
+declare abstract class ApiResponse {
+    success: boolean;
+    message?: string;
+    timestamp: string;
+    constructor(message?: string);
+}
+
+declare class SuccessResult extends ApiResponse {
+    constructor(message?: string);
+}
+declare class SuccessDataResult<T> extends SuccessResult {
+    data: T;
+    constructor(data: T, message?: string);
+}
+declare class SuccessListResult<T> extends SuccessResult {
+    data: T[];
+    constructor(data: T[], message?: string);
+}
+declare class SuccessPageResult<T> extends SuccessResult {
+    data: T[];
+    meta: {
+        total: number;
+        page: number;
+        size: number;
+        totalPages?: number;
+    };
+    constructor(data: T[], meta: {
+        total: number;
+        page: number;
+        size: number;
+        totalPages?: number;
+    }, message?: string);
+}
+declare class SuccessCursorResult<T> extends SuccessResult {
+    data: T[];
+    meta: {
+        nextCursor?: string;
+        previousCursor?: string;
+        hasNext: boolean;
+        hasPrevious: boolean;
+    };
+    constructor(data: T[], meta: {
+        nextCursor?: string;
+        previousCursor?: string;
+        hasNext: boolean;
+        hasPrevious: boolean;
+    }, message?: string);
+}
+
+declare class ErrorResult extends ApiResponse {
+    error: {
+        code: string;
+        kind?: FailureKind;
+        details?: unknown;
+    };
+    constructor(code: string, message: string, details?: unknown, kind?: FailureKind);
+}
+
+type HttpApiExposure = 'external' | 'internal';
+type InternalApiMode = 'auto' | 'local' | 'remote';
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+interface HttpApiMetadata {
+    readonly exposure: HttpApiExposure;
+    readonly name?: string;
+    readonly version?: string;
+    readonly owner?: string;
+    readonly audience?: string;
+    readonly description?: string;
+    readonly tags?: readonly string[];
+    readonly internalMode?: InternalApiMode;
+}
+declare const EXIUM_HTTP_API_METADATA: unique symbol;
+declare function defineHttpApiMetadata(metadata: HttpApiMetadata, target: object, propertyKey?: string | symbol): void;
+declare function getHttpApiMetadata(target: object, propertyKey?: string | symbol): HttpApiMetadata | undefined;
+
+type ExternalApiOptions = Omit<HttpApiMetadata, 'exposure' | 'internalMode'>;
+declare function ExternalApi(options?: ExternalApiOptions): ClassDecorator & MethodDecorator;
+
+interface InternalApiOptions extends Omit<HttpApiMetadata, 'exposure' | 'internalMode'> {
+    readonly mode?: InternalApiMode;
+}
+declare function InternalApi(options?: InternalApiOptions): ClassDecorator & MethodDecorator;
+
+declare const EXIUM_HTTP_OPTIONS: unique symbol;
+type ExiumHttpAdapter = 'express';
+interface ExiumHttpHeaderNames {
+    readonly requestId: string;
+    readonly correlationId: string;
+    readonly causationId: string;
+    readonly tenantId: string;
+    readonly userId: string;
+    readonly roles: string;
+    readonly permissions: string;
+    readonly source: string;
+    readonly locale: string;
+}
+interface ExiumHttpOptions {
+    readonly adapter?: ExiumHttpAdapter;
+    readonly context?: {
+        readonly headerNames?: Partial<ExiumHttpHeaderNames>;
+    };
+    readonly internalApis?: {
+        readonly defaultMode?: InternalApiMode;
+        readonly remoteServices?: Record<string, string>;
+    };
+}
+interface ResolvedExiumHttpOptions {
+    readonly adapter: ExiumHttpAdapter;
+    readonly context: {
+        readonly headerNames: ExiumHttpHeaderNames;
+    };
+    readonly internalApis: {
+        readonly defaultMode: InternalApiMode;
+        readonly remoteServices: Record<string, string>;
+    };
+}
+declare const DEFAULT_EXIUM_HTTP_HEADER_NAMES: ExiumHttpHeaderNames;
+declare function resolveExiumHttpOptions(options?: ExiumHttpOptions): ResolvedExiumHttpOptions;
+
+declare class ExiumHttpModule {
+    static forRoot(options?: ExiumHttpOptions): DynamicModule;
+}
+
+interface InternalApiHandlerContext {
+    readonly sourceServiceName: string;
+    readonly targetServiceName: string;
+    readonly operation: string;
+    readonly mode: Exclude<InternalApiMode, 'auto'>;
+    readonly method?: HttpMethod;
+    readonly path?: string;
+}
+interface InternalApiHandler<TRequest = unknown, TResponse = unknown> {
+    handle(request: TRequest, context: InternalApiHandlerContext): Promise<ResultType<TResponse> | TResponse> | ResultType<TResponse> | TResponse;
+}
+interface InternalApiHandlerMetadata {
+    readonly operation: string;
+    readonly serviceName?: string;
+    readonly description?: string;
+}
+declare const INTERNAL_API_HANDLER_METADATA: unique symbol;
+declare function HandleInternalApi(options: InternalApiHandlerMetadata): ClassDecorator;
+declare function getInternalApiHandlerMetadata(target: object): InternalApiHandlerMetadata | undefined;
+
+interface RegisteredInternalApiHandler {
+    readonly metadata: InternalApiHandlerMetadata;
+    readonly handler: InternalApiHandler<any, any>;
+}
+declare class ExiumInternalApiRegistry {
+    private readonly handlers;
+    register(metadata: InternalApiHandlerMetadata, handler: InternalApiHandler<any, any>): void;
+    resolve(serviceName: string, operation: string): RegisteredInternalApiHandler | undefined;
+    has(serviceName: string, operation: string): boolean;
+    list(): RegisteredInternalApiHandler[];
+}
+
+declare class ExiumHttpDiscoveryService implements OnApplicationBootstrap {
+    private readonly discovery;
+    private readonly internalApiRegistry;
+    constructor(discovery: DiscoveryService, internalApiRegistry: ExiumInternalApiRegistry);
+    onApplicationBootstrap(): void;
+}
+
+declare abstract class ExiumInternalApiEndpointResolver {
+    abstract resolve(serviceName: string): Promise<string | undefined> | string | undefined;
+}
+declare class ConfiguredInternalApiEndpointResolver extends ExiumInternalApiEndpointResolver {
+    private readonly options;
+    constructor(options: ResolvedExiumHttpOptions);
+    resolve(serviceName: string): string | undefined;
+}
+
+type InternalApiQueryScalar = string | number | boolean | null | undefined;
+type InternalApiQueryValue = InternalApiQueryScalar | readonly InternalApiQueryScalar[];
+interface InternalApiCall<TRequest = unknown> {
+    readonly serviceName: string;
+    readonly operation: string;
+    readonly mode?: InternalApiMode;
+    readonly method?: HttpMethod;
+    readonly path?: string;
+    readonly query?: Record<string, InternalApiQueryValue>;
+    readonly body?: TRequest;
+    readonly headers?: Record<string, string>;
+    readonly timeoutMs?: number;
+}
+declare class ExiumInternalApiClient {
+    private readonly registry;
+    private readonly endpointResolver;
+    private readonly contextService;
+    private readonly sourceServiceName;
+    private readonly options;
+    constructor(registry: ExiumInternalApiRegistry, endpointResolver: ExiumInternalApiEndpointResolver, contextService: ExiumContextService, sourceServiceName?: string, options?: ResolvedExiumHttpOptions);
+    call<TResult, TRequest = unknown>(call: InternalApiCall<TRequest>): Promise<ResultType<TResult>>;
+    private callLocal;
+    private callRemote;
+    private createRemoteHeaders;
+}
+
+declare class ExiumHttpContextInterceptor implements NestInterceptor {
+    private readonly contextService;
+    private readonly options;
+    constructor(contextService: ExiumContextService, options?: ResolvedExiumHttpOptions);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+    private createExecutionContext;
+}
+
+declare class ExiumResponseInterceptor implements NestInterceptor {
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+    private wrapSuccess;
+}
+
+/**
+ * Exception policy:
+ *
+ * - Thrown exceptions represent unexpected failures (programmer errors,
+ *   infrastructure faults). They are logged and surfaced as HTTP 500 with a
+ *   generic message — internal details never leak to clients.
+ * - Expected business failures must be returned as `Result.fail(Failure...)`,
+ *   which the response interceptor maps to the appropriate 4xx status.
+ *
+ * `HttpException` is the only exception with a meaningful HTTP status — it is
+ * preserved for compatibility with NestJS pipes (e.g. ValidationPipe) and any
+ * controller-level redirect/throw semantics.
+ */
+declare class ExiumExceptionFilter implements ExceptionFilter {
+    private readonly logger?;
+    constructor(logger?: Logger | undefined);
+    catch(exception: unknown, host: ArgumentsHost): void;
+}
+
+type ExiumCacheInfrastructureDriver = 'redis';
+interface ExiumCacheInfrastructureOptions {
+    readonly driver?: ExiumCacheInfrastructureDriver;
+}
+declare class ExiumCacheInfrastructureModule {
+    static forRoot(options?: ExiumCacheInfrastructureOptions): DynamicModule;
+}
+
+declare const EXIUM_REDIS_OPTIONS: unique symbol;
+declare const EXIUM_REDIS_CLIENT: unique symbol;
+interface ExiumRedisOptions {
+    readonly url: string;
+    /**
+     * Application-level Redis key prefix.
+     *
+     * This is intentionally not passed to ioredis as native keyPrefix.
+     * Framework adapters apply it manually so scan/delete-by-prefix behavior
+     * stays deterministic.
+     */
+    readonly keyPrefix?: string;
+    readonly connectTimeoutMs: number;
+    readonly lazyConnect: boolean;
+    readonly maxRetriesPerRequest: number;
+    readonly enableOfflineQueue: boolean;
+}
+type ExiumRedisOptionsInput = Partial<ExiumRedisOptions>;
+declare const DEFAULT_EXIUM_REDIS_OPTIONS: Omit<ExiumRedisOptions, 'url'>;
+declare function normalizeExiumRedisOptions(input?: ExiumRedisOptionsInput): ExiumRedisOptions;
+
+declare class ExiumRedisModule {
+    static forRoot(options?: ExiumRedisOptionsInput): DynamicModule;
+}
+
+declare class ExiumRedisClient implements OnApplicationShutdown {
+    private readonly options;
+    private client?;
+    constructor(options: ExiumRedisOptions);
+    get native(): Redis;
+    ping(): Promise<string>;
+    onApplicationShutdown(): Promise<void>;
+}
+
+declare class RedisCacheStore extends CacheStore {
+    private readonly redis;
+    private readonly options;
+    constructor(redis: Redis, options: ExiumRedisOptions);
+    get<T>(key: string): Promise<CacheGetResult<T>>;
+    set<T>(key: string, value: T, options?: CacheSetOptions): Promise<void>;
+    delete(key: string): Promise<void>;
+    deleteByPrefix(prefix: string): Promise<void>;
+    private toPhysicalKey;
+}
+
+declare class RedisCacheVersionService extends CacheVersionService {
+    private readonly redis;
+    private readonly options;
+    constructor(redis: Redis, options: ExiumRedisOptions);
+    getVersion(namespace: string): Promise<number>;
+    bumpVersion(namespace: string): Promise<number>;
+    private createVersionKey;
+    private toPhysicalKey;
+}
+
+type ExiumIdempotencyInfrastructureDriver = 'redis';
+interface ExiumIdempotencyInfrastructureOptions {
+    readonly driver?: ExiumIdempotencyInfrastructureDriver;
+}
+declare class ExiumIdempotencyInfrastructureModule {
+    static forRoot(options?: ExiumIdempotencyInfrastructureOptions): DynamicModule;
+}
+
+declare class RedisIdempotencyStore extends IdempotencyStore {
+    private readonly redis;
+    private readonly options;
+    constructor(redis: Redis, options: ExiumRedisOptions);
+    begin<TResult = unknown>(input: IdempotencyBeginInput): Promise<IdempotencyBeginResult<TResult>>;
+    complete<TResult = unknown>(input: IdempotencyCompleteInput<TResult>): Promise<void>;
+    fail(input: IdempotencyFailInput): Promise<void>;
+    private readRecord;
+    private writePreservingTtl;
+    private createPhysicalKey;
+    private toPhysicalKey;
+}
+
+interface IntegrationMessageEnvelope {
+    readonly id: string;
+    readonly name: string;
+    readonly version: number;
+    readonly occurredAt: Date;
+    readonly payload: Record<string, unknown>;
+}
+declare abstract class IntegrationMessagePublisher {
+    abstract publish(message: IntegrationMessageEnvelope): Promise<void>;
+}
+
+declare class NoopIntegrationMessagePublisher extends IntegrationMessagePublisher {
+    publish(message: IntegrationMessageEnvelope): Promise<void>;
+}
+
+declare const RABBITMQ_OPTIONS: unique symbol;
+type RabbitMqExchangeType = 'topic' | 'direct' | 'fanout';
+interface RabbitMqOptions {
+    readonly url: string;
+    readonly exchange: string;
+    readonly exchangeType: RabbitMqExchangeType;
+    readonly routingKey?: string;
+    readonly durable: boolean;
+    readonly persistent: boolean;
+}
+type RabbitMqOptionsInput = Partial<RabbitMqOptions>;
+declare const DEFAULT_RABBITMQ_OPTIONS: Omit<RabbitMqOptions, 'url'>;
+declare function normalizeRabbitMqOptions(input: RabbitMqOptionsInput): RabbitMqOptions;
+
+type ExiumMessagingDriver = 'noop' | 'rabbitmq';
+interface ExiumMessagingOptions {
+    readonly driver?: ExiumMessagingDriver;
+    readonly rabbitmq?: RabbitMqOptionsInput;
+}
+declare class ExiumMessagingModule {
+    static forRoot(options?: ExiumMessagingOptions): DynamicModule;
+}
+
+declare class RabbitMqIntegrationMessagePublisher extends IntegrationMessagePublisher implements OnApplicationShutdown {
+    private readonly options;
+    private connection?;
+    private channel?;
+    private initializing?;
+    constructor(options: RabbitMqOptions);
+    publish(message: IntegrationMessageEnvelope): Promise<void>;
+    onApplicationShutdown(): Promise<void>;
+    private ensureChannel;
+    private initialize;
+    private closeSafely;
+}
+
+declare const OutboxMessageSchema: _mikro_orm_core.EntitySchemaWithMeta<"OutboxMessageEntity", "exium_outbox_messages", _mikro_orm_core.InferEntityFromProperties<{
+    readonly id: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<string, Omit<_mikro_orm_core.EmptyOptions, "primary"> & {
+        primary: true;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly eventId: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<string, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly eventName: _mikro_orm_core.UniversalPropertyOptionsBuilder<string, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly eventVersion: _mikro_orm_core.UniversalPropertyOptionsBuilder<number, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly payload: _mikro_orm_core.UniversalPropertyOptionsBuilder<Record<string, unknown>, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly occurredAt: _mikro_orm_core.UniversalPropertyOptionsBuilder<Date, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    /**
+     * Keep status as string instead of enum metadata here.
+     * This keeps the schema simple and portable across SQL/Mongo drivers.
+     */
+    readonly status: _mikro_orm_core.UniversalPropertyOptionsBuilder<string, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly retryCount: _mikro_orm_core.UniversalPropertyOptionsBuilder<number, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly nextAttemptAt: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<Date, Omit<_mikro_orm_core.EmptyOptions, "nullable"> & {
+        nullable: true;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly publishedAt: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<Date, Omit<_mikro_orm_core.EmptyOptions, "nullable"> & {
+        nullable: true;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly lockedAt: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<Date, Omit<_mikro_orm_core.EmptyOptions, "nullable"> & {
+        nullable: true;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly lockedBy: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<string, Omit<_mikro_orm_core.EmptyOptions, "nullable"> & {
+        nullable: true;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly lastError: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<string, Omit<_mikro_orm_core.EmptyOptions, "nullable"> & {
+        nullable: true;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly createdAt: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<Date, _mikro_orm_core.EmptyOptions & {
+        onCreate: (...args: any[]) => any;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly updatedAt: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<Date, _mikro_orm_core.EmptyOptions & {
+        onCreate: (...args: any[]) => any;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+}, undefined, never, never, false>, never, {
+    readonly id: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<string, Omit<_mikro_orm_core.EmptyOptions, "primary"> & {
+        primary: true;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly eventId: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<string, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly eventName: _mikro_orm_core.UniversalPropertyOptionsBuilder<string, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly eventVersion: _mikro_orm_core.UniversalPropertyOptionsBuilder<number, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly payload: _mikro_orm_core.UniversalPropertyOptionsBuilder<Record<string, unknown>, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly occurredAt: _mikro_orm_core.UniversalPropertyOptionsBuilder<Date, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    /**
+     * Keep status as string instead of enum metadata here.
+     * This keeps the schema simple and portable across SQL/Mongo drivers.
+     */
+    readonly status: _mikro_orm_core.UniversalPropertyOptionsBuilder<string, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly retryCount: _mikro_orm_core.UniversalPropertyOptionsBuilder<number, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly nextAttemptAt: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<Date, Omit<_mikro_orm_core.EmptyOptions, "nullable"> & {
+        nullable: true;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly publishedAt: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<Date, Omit<_mikro_orm_core.EmptyOptions, "nullable"> & {
+        nullable: true;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly lockedAt: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<Date, Omit<_mikro_orm_core.EmptyOptions, "nullable"> & {
+        nullable: true;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly lockedBy: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<string, Omit<_mikro_orm_core.EmptyOptions, "nullable"> & {
+        nullable: true;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly lastError: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<string, Omit<_mikro_orm_core.EmptyOptions, "nullable"> & {
+        nullable: true;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly createdAt: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<Date, _mikro_orm_core.EmptyOptions & {
+        onCreate: (...args: any[]) => any;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly updatedAt: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<Date, _mikro_orm_core.EmptyOptions & {
+        onCreate: (...args: any[]) => any;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+}, _mikro_orm_core.EntityCtor<_mikro_orm_core.InferEntityFromProperties<{
+    readonly id: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<string, Omit<_mikro_orm_core.EmptyOptions, "primary"> & {
+        primary: true;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly eventId: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<string, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly eventName: _mikro_orm_core.UniversalPropertyOptionsBuilder<string, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly eventVersion: _mikro_orm_core.UniversalPropertyOptionsBuilder<number, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly payload: _mikro_orm_core.UniversalPropertyOptionsBuilder<Record<string, unknown>, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly occurredAt: _mikro_orm_core.UniversalPropertyOptionsBuilder<Date, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    /**
+     * Keep status as string instead of enum metadata here.
+     * This keeps the schema simple and portable across SQL/Mongo drivers.
+     */
+    readonly status: _mikro_orm_core.UniversalPropertyOptionsBuilder<string, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly retryCount: _mikro_orm_core.UniversalPropertyOptionsBuilder<number, _mikro_orm_core.EmptyOptions, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly nextAttemptAt: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<Date, Omit<_mikro_orm_core.EmptyOptions, "nullable"> & {
+        nullable: true;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly publishedAt: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<Date, Omit<_mikro_orm_core.EmptyOptions, "nullable"> & {
+        nullable: true;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly lockedAt: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<Date, Omit<_mikro_orm_core.EmptyOptions, "nullable"> & {
+        nullable: true;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly lockedBy: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<string, Omit<_mikro_orm_core.EmptyOptions, "nullable"> & {
+        nullable: true;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly lastError: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<string, Omit<_mikro_orm_core.EmptyOptions, "nullable"> & {
+        nullable: true;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly createdAt: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<Date, _mikro_orm_core.EmptyOptions & {
+        onCreate: (...args: any[]) => any;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+    readonly updatedAt: Pick<_mikro_orm_core.UniversalPropertyOptionsBuilder<Date, _mikro_orm_core.EmptyOptions & {
+        onCreate: (...args: any[]) => any;
+    }, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>, keyof _mikro_orm_core.PropertyOptions<any> | ("~options" | "~type" | "$type" | "strictNullable")>;
+}, undefined, never, never, false>>>;
+declare class OutboxMessageEntity extends OutboxMessageSchema.class {
+    static create(params: {
+        eventId: string;
+        eventName: string;
+        eventVersion: number;
+        payload: Record<string, unknown>;
+        occurredAt: Date;
+    }): OutboxMessageEntity;
+}
+
+declare enum OutboxMessageStatus {
+    Pending = "pending",
+    Published = "published",
+    Failed = "failed"
+}
+
+declare class MikroOrmOutboxWriter extends OutboxWriter {
+    write(events: readonly IntegrationEvent[]): Promise<void>;
+}
+
+declare const OUTBOX_PUBLISHER_OPTIONS: unique symbol;
+interface OutboxPublisherOptions {
+    readonly batchSize: number;
+    readonly maxRetryCount: number;
+    readonly retryDelayMs: number;
+    readonly lockTimeoutMs: number;
+    readonly publisherId: string;
+}
+type OutboxPublisherOptionsInput = Partial<OutboxPublisherOptions>;
+declare const DEFAULT_OUTBOX_PUBLISHER_OPTIONS: OutboxPublisherOptions;
+declare function normalizeOutboxPublisherOptions(input?: OutboxPublisherOptionsInput): OutboxPublisherOptions;
+
+declare class OutboxPublisher {
+    private readonly em;
+    private readonly messagePublisher;
+    private readonly logger;
+    private readonly options;
+    constructor(em: EntityManager, messagePublisher: IntegrationMessagePublisher, logger: Logger, options: OutboxPublisherOptions);
+    publishPending(): Promise<number>;
+    private findPublishableMessages;
+    private claim;
+    private toEnvelope;
+}
+
+interface ExiumPersistenceOutboxOptions {
+    readonly enabled?: boolean;
+    readonly publisher?: OutboxPublisherOptionsInput;
+}
+type ExiumPersistenceDriver = 'postgres' | 'mongo';
+type ExiumPersistenceEntity = string | EntityClass<AnyEntity> | EntitySchema;
+interface ExiumPersistenceOptions {
+    readonly driver: ExiumPersistenceDriver;
+    readonly entities: ExiumPersistenceEntity[];
+    readonly outbox?: ExiumPersistenceOutboxOptions;
+}
+declare class ExiumPersistenceModule {
+    static forRoot(options: ExiumPersistenceOptions): DynamicModule;
+}
+
+declare class MikroOrmUnitOfWork extends UnitOfWork {
+    private readonly rootEntityManager;
+    private readonly eventBus;
+    private readonly integrationEventRegistry;
+    private readonly outboxWriter;
+    private readonly logger;
+    constructor(rootEntityManager: EntityManager, eventBus: EventBus, integrationEventRegistry: IntegrationEventRegistry, outboxWriter: OutboxWriter, logger: Logger);
+    execute<T>(work: () => Promise<T>): Promise<T>;
+    registerAggregate(aggregate: AggregateRoot<any>): void;
+}
+
+interface MikroOrmRepositoryOptions<TPersistenceEntity extends object> {
+    /**
+     * Persistence entity id field.
+     *
+     * Default: "id"
+     *
+     * Examples:
+     * - Postgres entity: "id"
+     * - Mongo entity: "_id"
+     * - Legacy entity: "uuid"
+     */
+    readonly idField?: keyof TPersistenceEntity & string;
+}
+interface EntityManagerLike {
+    getContext(): EntityManagerLike;
+    findOne(entityName: unknown, where: FilterQuery<any>): Promise<any>;
+    find(entityName: unknown, where: FilterQuery<any>): Promise<any[]>;
+    count(entityName: unknown, where: FilterQuery<any>): Promise<number>;
+    persist(entity: object): void;
+    remove(entity: object): void;
+}
+declare abstract class MikroOrmRepository<TPersistenceEntity extends object, TPrimitiveId> {
+    private readonly entityName;
+    private readonly rootEntityManager;
+    private readonly idField;
+    protected constructor(entityName: unknown, rootEntityManager: EntityManagerLike, options?: MikroOrmRepositoryOptions<TPersistenceEntity>);
+    /**
+     * Read operations may run outside explicit transaction.
+     * If a transaction exists, reads use the transaction EntityManager.
+     */
+    protected get em(): EntityManagerLike;
+    /**
+     * Write operations must be executed inside UnitOfWork transaction.
+     */
+    protected get transactionalEm(): EntityManagerLike;
+    protected getIdField(): keyof TPersistenceEntity & string;
+    protected createIdFilter(id: TPrimitiveId): FilterQuery<TPersistenceEntity>;
+    protected createIdsFilter(ids: readonly TPrimitiveId[]): FilterQuery<TPersistenceEntity>;
+    protected findOrmById(id: TPrimitiveId): Promise<TPersistenceEntity | null>;
+    protected findOrmByIds(ids: readonly TPrimitiveId[]): Promise<TPersistenceEntity[]>;
+    protected persistOrm(entity: TPersistenceEntity): void;
+    protected removeOrm(entity: TPersistenceEntity): void;
+    protected deleteOrmById(id: TPrimitiveId): Promise<void>;
+    protected existsOrm(id: TPrimitiveId): Promise<boolean>;
+}
+
+interface PersistenceMapper<TAggregate extends AggregateRoot<TId>, TId extends Id, TPersistenceEntity extends object, TPrimitiveId> {
+    toDomain(entity: TPersistenceEntity): TAggregate;
+    toPersistence(aggregate: TAggregate): TPersistenceEntity;
+    toPersistenceId(id: TId): TPrimitiveId;
+    getPersistenceId(aggregate: TAggregate): TPrimitiveId;
+}
+
+declare abstract class MikroOrmAggregateRepository<TAggregate extends AggregateRoot<TId>, TId extends Id, TPersistenceEntity extends object, TPrimitiveId> extends MikroOrmRepository<TPersistenceEntity, TPrimitiveId> implements Repository<TAggregate, TId> {
+    private readonly mapper;
+    private readonly unitOfWork;
+    protected constructor(entityName: unknown, rootEntityManager: EntityManagerLike, mapper: PersistenceMapper<TAggregate, TId, TPersistenceEntity, TPrimitiveId>, unitOfWork: UnitOfWork, options?: MikroOrmRepositoryOptions<TPersistenceEntity>);
+    findById(id: TId): Promise<TAggregate | null>;
+    findByIds(ids: readonly TId[]): Promise<TAggregate[]>;
+    save(aggregate: TAggregate): Promise<void>;
+    delete(id: TId): Promise<void>;
+    exists(id: TId): Promise<boolean>;
+}
+
+interface PersistenceTransactionContext {
+    readonly em: EntityManager;
+    readonly aggregates: Set<AggregateRoot<any>>;
+}
+declare const TransactionContext: AsyncLocalStorage<PersistenceTransactionContext>;
+declare function getTransactionContext(): PersistenceTransactionContext | undefined;
+declare function getTransactionEntityManager(): EntityManager | undefined;
+declare function getTransactionAggregates(): Set<AggregateRoot<any>> | undefined;
+
+declare class TransactionCommandMiddleware implements CommandMiddleware {
+    private readonly unitOfWork;
+    constructor(unitOfWork: UnitOfWork);
+    use<TCommand extends Command<any>>(command: TCommand, next: () => Promise<ResultType<CommandResultOf<TCommand>>>): Promise<ResultType<CommandResultOf<TCommand>>>;
+}
+
+declare class PersistenceTransactionNotActiveException extends Error {
+    constructor(operation: string);
+}
+
+interface ExiumInfrastructureOptions {
+    readonly messaging?: ExiumMessagingOptions;
+    readonly persistence?: ExiumPersistenceOptions;
+    readonly redis?: ExiumRedisOptionsInput;
+    readonly cache?: ExiumCacheInfrastructureOptions;
+    readonly idempotency?: ExiumIdempotencyInfrastructureOptions;
+}
+declare class ExiumInfrastructureModule {
+    static forRoot(options?: ExiumInfrastructureOptions): DynamicModule;
+}
+
+type AnyDatabase = Record<string, any>;
+declare class KyselyReadEngine<TDatabase extends AnyDatabase = AnyDatabase> implements ReadEngine {
+    private readonly db;
+    constructor(db: Kysely<TDatabase>);
+    findOne<TView>(query: FindOneQuery<TView>): Promise<TView | null>;
+    findMany<TView>(query: FindManyQuery<TView>): Promise<readonly TView[]>;
+    findPage<TView>(query: FindPageQuery<TView>): Promise<Page<TView>>;
+    findCursor<TView>(query: FindCursorQuery<TView>): Promise<CursorPage<TView>>;
+    exists(query: ExistsQuery): Promise<boolean>;
+    count(query: CountQuery): Promise<number>;
+    private createSelect;
+    private createBaseQuery;
+    private applyCriteria;
+    private applySort;
+    private applyCursorPredicate;
+    private toKyselyExpression;
+    private toComparisonExpression;
+}
+
+interface ExiumModuleOptions {
+    readonly serviceName: string;
+    readonly http?: ExiumHttpOptions;
+    readonly infrastructure?: ExiumInfrastructureOptions;
+}
+declare class ExiumModule {
+    static forRoot(options: ExiumModuleOptions): DynamicModule;
+}
+
+interface ExiumApp {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getNestApp(): INestApplication | INestApplicationContext;
+}
+
+type ExiumMode = 'http' | 'context';
+interface ExiumOptions {
+    readonly serviceName: string;
+    readonly mode?: ExiumMode;
+    readonly port?: number;
+    readonly module: Type<unknown> | DynamicModule;
+    readonly shutdownHooks?: boolean;
+    readonly http?: ExiumHttpOptions;
+    /**
+     * Optional framework infrastructure modules.
+     *
+     * If omitted, Exium runs only with config/logger/application layer.
+     */
+    readonly infrastructure?: ExiumInfrastructureOptions;
+}
+
+declare function createExiumApp(options: ExiumOptions): Promise<ExiumApp>;
+
+declare class ExiumLoggerModule {
+}
+
+export { AUDITABLE_METADATA, AUTHORIZATION_METADATA, AggregateRoot, AllowAnonymous, type AndCriteriaNode, ApiResponse, ApplicationMiddlewarePriority, type ApplicationValidationErrorItem, AuditCommandMiddleware, type AuditEvent, type AuditOperationType, type AuditOutcome, AuditQueryMiddleware, AuditWriter, Auditable, AuditableAggregateRoot, AuditableEntity, type AuditableMetadata, type AuditableOptions, AuthorizationCommandMiddleware, AuthorizationException, type AuthorizationFailureReason, type AuthorizationMetadata, AuthorizationQueryMiddleware, type AuthorizationRequirementMode, type BaseReadQuery, type BetweenCriteriaNode, CACHE_QUERY_METADATA, type CacheGetResult, CacheInvalidationCommandMiddleware, type CacheInvalidationMode, CacheKeyFactory, type CacheKeyFactoryInput, type CacheKeyPrefixInput, CacheQuery, type CacheQueryMetadata, CacheQueryMiddleware, type CacheQueryOptions, type CacheSetOptions, CacheStore, CacheVersionService, Command, CommandExecutor, CommandHandler, type CommandMiddleware, type CommandResultOf, type ComparisonCriteriaNode, ConfiguredInternalApiEndpointResolver, ContextCommandMiddleware, ContextPermissionChecker, ContextQueryMiddleware, type CountQuery, Criteria, CriteriaFieldBuilder, type CriteriaNode, type CriteriaOperator, CursorPage, CursorRequest, DEFAULT_EXIUM_HTTP_HEADER_NAMES, DEFAULT_EXIUM_REDIS_OPTIONS, DEFAULT_OUTBOX_PUBLISHER_OPTIONS, DEFAULT_RABBITMQ_OPTIONS, DefaultCacheKeyFactory, DefaultIdempotencyFingerprintFactory, DefaultIdempotencyKeyResolver, type Auditable$1 as DomainAuditable, DomainEvent, DomainService, DuplicateHandlerException, EXIUM_HTTP_API_METADATA, EXIUM_HTTP_OPTIONS, EXIUM_REDIS_CLIENT, EXIUM_REDIS_OPTIONS, Entity, ErrorResult, EventBus, EventHandler, type ExistsQuery, type ExiumApp, ExiumApplicationModule, type ExiumCacheInfrastructureDriver, ExiumCacheInfrastructureModule, type ExiumCacheInfrastructureOptions, ExiumConfigModule, ExiumConfigService, ExiumContextService, ExiumEnvironment, ExiumExceptionFilter, type ExiumExecutionContext, type ExiumHttpAdapter, ExiumHttpContextInterceptor, ExiumHttpDiscoveryService, type ExiumHttpHeaderNames, ExiumHttpModule, type ExiumHttpOptions, type ExiumIdempotencyInfrastructureDriver, ExiumIdempotencyInfrastructureModule, type ExiumIdempotencyInfrastructureOptions, ExiumInfrastructureModule, type ExiumInfrastructureOptions, ExiumInternalApiClient, ExiumInternalApiEndpointResolver, ExiumInternalApiRegistry, ExiumLoggerModule, type ExiumMessagingDriver, ExiumMessagingModule, type ExiumMessagingOptions, type ExiumMode, ExiumModule, type ExiumModuleOptions, type ExiumOperationType, type ExiumOptions, type ExiumPersistenceDriver, ExiumPersistenceModule, type ExiumPersistenceOptions, type ExiumPersistenceOutboxOptions, ExiumRedisClient, ExiumRedisModule, type ExiumRedisOptions, type ExiumRedisOptionsInput, ExiumResponseInterceptor, ExternalApi, type ExternalApiOptions, Failure, type FailureKind, type FailureResult, type FailureType, type FindCursorQuery, type FindManyQuery, type FindOneQuery, type FindPageQuery, type Finder, HandleCommand, HandleEvent, HandleInternalApi, HandleQuery, HandlerNotFoundException, type HttpApiExposure, type HttpApiMetadata, type HttpMethod, SuccessResult as HttpSuccessResult, IDEMPOTENT_METADATA, INTEGRATION_EVENT_MAPPER_METADATA, INTERNAL_API_HANDLER_METADATA, INVALIDATE_CACHE_METADATA, Id, type IdempotencyBeginInput, type IdempotencyBeginResult, type IdempotencyBeginStatus, IdempotencyCommandMiddleware, type IdempotencyCompleteInput, IdempotencyException, type IdempotencyExceptionDetails, type IdempotencyFailInput, type IdempotencyFailureReason, IdempotencyFingerprintFactory, type IdempotencyFingerprintFactoryInput, IdempotencyKeyResolver, type IdempotencyKeyResolverInput, IdempotencyStore, Idempotent, type IdempotentMetadata, type IdempotentOptions, type InCriteriaNode, InMemoryCacheVersionService, IntegrationEvent, IntegrationEventMapper, IntegrationEventRegistry, type IntegrationMessageEnvelope, IntegrationMessagePublisher, InternalApi, type InternalApiCall, type InternalApiHandler, type InternalApiHandlerContext, type InternalApiHandlerMetadata, type InternalApiMode, type InternalApiOptions, type InternalApiQueryScalar, type InternalApiQueryValue, InvalidateCache, type InvalidateCacheMetadata, type InvalidateCacheOptions, type IsNotNullCriteriaNode, type IsNullCriteriaNode, Join, JoinBuilder, KyselyReadEngine, LoggingCommandMiddleware, LoggingQueryMiddleware, MikroOrmAggregateRepository, MikroOrmOutboxWriter, MikroOrmRepository, type MikroOrmRepositoryOptions, MikroOrmUnitOfWork, NonAuditable, NonCacheable, NonIdempotent, NonTransactional, NoopAuditWriter, NoopCacheStore, NoopIdempotencyStore, NoopIntegrationMessagePublisher, NoopOutboxWriter, type NotCriteriaNode, OUTBOX_PUBLISHER_OPTIONS, type OrCriteriaNode, OutboxMessageEntity, OutboxMessageStatus, OutboxPublisher, type OutboxPublisherOptions, type OutboxPublisherOptionsInput, OutboxWriter, Page, PageRequest, type PageRequestOptions, type PermissionCheckInput, type PermissionCheckResult, PermissionChecker, type PersistenceMapper, type PersistenceTransactionContext, PersistenceTransactionNotActiveException, PrimitiveValueObject, Query, QueryExecutor, QueryHandler, type QueryMiddleware, QueryResult, type QueryResultOf, RABBITMQ_OPTIONS, type RabbitMqExchangeType, RabbitMqIntegrationMessagePublisher, type RabbitMqOptions, type RabbitMqOptionsInput, type ReadEngine, ReadFieldNotFoundException, type ReadModel, ReadOperationNotSupportedException, ReadQueryException, type ReadSource, RedisCacheStore, RedisCacheVersionService, RedisIdempotencyStore, RegisterCommandMiddleware, RegisterIntegrationEventMapper, RegisterQueryMiddleware, type RegisteredInternalApiHandler, type Repository, RequireAnyPermission, RequireAnyRole, RequirePermission, RequireRole, type ResolvedExiumHttpOptions, Result, type ResultType, type RowMapper, SKIP_VALIDATION_METADATA, SkipValidation, Sort, type SortDirection, SortDirectionBuilder, type SortField, type SortNulls, Specification, type SqlJoin, type SqlJoinOnRef, type SqlJoinOperator, type SqlJoinType, SqlReadSource, type SqlReadSourceDefinition, SuccessCursorResult, SuccessDataResult, SuccessListResult, SuccessPageResult, type SuccessResult$1 as SuccessResult, TRANSACTIONAL_METADATA, TransactionCommandMiddleware, TransactionContext, Transactional, UnitOfWork, ValidationCommandMiddleware, ValidationQueryMiddleware, ValueObject, type Versionable, type View, createExiumApp, defineHttpApiMetadata, getHttpApiMetadata, getInternalApiHandlerMetadata, getTransactionAggregates, getTransactionContext, getTransactionEntityManager, isAuditable, isVersionable, normalizeExiumRedisOptions, normalizeOutboxPublisherOptions, normalizeRabbitMqOptions, resolveExiumHttpOptions };