@tstdl/base 0.92.124 → 0.92.126

package/injector/token.d.ts

@@ -0,0 +1,25 @@
+import type { AbstractConstructor } from '../types.js';
+declare const type: unique symbol;
+declare const argument: unique symbol;
+export type SimpleInjectionToken<T> = AbstractConstructor<T>;
+export type ArgumentedInjectionToken<T, A> = SimpleInjectionToken<T> & {
+    [argument]: A;
+};
+export type InjectionToken<T = any, A = any> = SimpleInjectionToken<T> | ArgumentedInjectionToken<T, A> | ReifyingInjectionToken<T, A>;
+export type InjectionTokenArgument<T extends ArgumentedInjectionToken<any, any> | ReifyingInjectionToken> = T[typeof argument];
+export declare class ReifyingInjectionToken<T = any, A = any> {
+    /**
+     * @deprecated for internal typing
+     */
+    readonly [type]: T;
+    /**
+     * @deprecated for internal typing
+     */
+    readonly [argument]: A;
+    readonly description: string;
+    constructor(description: string);
+    toString(): string;
+}
+export declare function injectionToken<T, A = never>(description: string): InjectionToken<T, A>;
+export declare function getTokenName(token: InjectionToken | undefined): string;
+export {};

package/injector/type-info.d.ts

@@ -0,0 +1,22 @@
+import type { ForwardRefTypeHint } from '../utils/object/forward-ref.js';
+import type { InjectionToken } from './token.js';
+import type { ArgumentProvider, ForwardRefInjectionToken, Mapper } from './types.js';
+export type InjectMetadata = {
+    /** Token overwrite by inject decorator */
+    injectToken?: InjectionToken;
+    /** If defined, resolve the token or ForwardRefToken using ForwardRef strategy instead of resolving the token directly */
+    forwardRef?: boolean | ForwardRefInjectionToken;
+    forwardRefTypeHint?: ForwardRefTypeHint;
+    /** Whether injection is optional if token is not registered. Set by optional decorator */
+    optional?: boolean;
+    /** Whether injection should resolve all providers */
+    resolveAll?: boolean;
+    /** Mapper to map resolved value */
+    mapper?: Mapper;
+    /** Provider to get resolve argument */
+    resolveArgumentProvider?: ArgumentProvider;
+    /** If defined, map the resolve argument and use the returned value as the value to inject */
+    injectArgumentMapper?: Mapper;
+    /** If defined, use the provided argument, map it and pass it to the resolution of the token */
+    forwardArgumentMapper?: Mapper;
+};

package/injector/types.d.ts

@@ -0,0 +1,64 @@
+import type { CancellationSignal } from '../cancellation/index.js';
+import type { AsyncDisposeHandler } from '../disposable/async-disposer.js';
+import type { Record } from '../types.js';
+import type { ForwardRefTypeHint } from '../utils/object/forward-ref.js';
+import type { Injector, ProvidersItem } from './injector.js';
+import type { ResolveArgument } from './interfaces.js';
+import type { InjectionToken } from './token.js';
+/**
+ * Transient: new resolution for every resolve
+ * resolution: one resolution per resolve tree
+ * injector: one resolution per injector
+ * singleton: one resolution at injector where token is registered
+ */
+export type Lifecycle = 'transient' | 'resolution' | 'injector' | 'singleton';
+export type ResolveContext<D extends Record> = Pick<Injector, 'resolve' | 'resolveAll'> & {
+    readonly data: ResolveContextData<D>;
+    readonly cancellationSignal: CancellationSignal;
+    addDisposeHandler(handler: AsyncDisposeHandler): void;
+};
+export type AfterResolveContext<D extends Record> = {
+    readonly data: ResolveContextData<D>;
+    readonly cancellationSignal: CancellationSignal;
+    addDisposeHandler(handler: AsyncDisposeHandler): void;
+};
+export type Mapper<T = any, U = unknown> = (value: T) => U;
+export type ArgumentProvider<T = unknown, D extends Record = Record> = (context: ResolveContext<D>) => T;
+export type ForwardRefInjectionToken<T = any, A = any> = Exclude<InjectionToken<T, A>, Function> | (() => InjectionToken<T, A>);
+export type ResolveOptions<T, A> = {
+    optional?: boolean;
+    skipSelf?: boolean;
+    onlySelf?: boolean;
+    /** If defined, resolve the token using ForwardRef strategy instead of resolving the token directly can be used to circumvent circular dependency problems */
+    forwardRef?: boolean | ForwardRefInjectionToken<T, A>;
+    forwardRefTypeHint?: ForwardRefTypeHint;
+};
+/**
+ * Data to store between different stages like resolve and afterResolve
+ */
+export type ResolveContextData<T extends Record> = T;
+export type RegistrationOptions<T, A = unknown, D extends Record = Record> = {
+    lifecycle?: Lifecycle;
+    /** Local providers for inner resolutions */
+    providers?: ProvidersItem[];
+    /** Default resolve argument used when neither token nor explicit resolve argument is provided */
+    defaultArgument?: ResolveArgument<T, A>;
+    /** Default resolve argument used when neither token nor explicit resolve argument is provided */
+    defaultArgumentProvider?: ArgumentProvider<ResolveArgument<T, A>, D>;
+    /**
+     * Value to distinguish scoped and singleton instances based on argument
+     * by default it uses strict equality (===) on the original argument,
+     * so modifications to argument objects and literal objects in the call
+     * may not yield the expected result.
+     *
+     * Hint: {@link JSON.stringify} is a simple solution for many use cases,
+     * but will fail if properties have different order
+     */
+    argumentIdentityProvider?: Mapper<ResolveArgument<T, A>>;
+    /** Function which gets called after a resolve */
+    afterResolve?: (instance: T, argument: ResolveArgument<T, A>, context: AfterResolveContext<D>) => any;
+    /** Whether multiple values can be resolved or not (used with {@link Injector.resolveAll}). If false, previous registrations are removed */
+    multi?: boolean;
+    /** Custom metadata */
+    metadata?: Record;
+};

package/key-value-store/key-value.store.d.ts

@@ -0,0 +1,23 @@
+import { type Resolvable, resolveArgumentType } from '../injector/interfaces.js';
+import type { StringMap } from '../types.js';
+/** Key value store module */
+export type KeyValueStoreArgument = string;
+export declare abstract class KeyValueStore<KV extends StringMap> implements Resolvable<KeyValueStoreArgument> {
+    readonly module: string;
+    readonly [resolveArgumentType]: KeyValueStoreArgument;
+    constructor(module: string);
+    /** Get value of key */
+    abstract get<K extends keyof KV>(key: K): Promise<KV[K] | undefined>;
+    /** Get value of key */
+    abstract get<K extends keyof KV, D>(key: K, defaultValue: D): Promise<KV[K] | D>;
+    /** Set key */
+    abstract set<K extends keyof KV>(key: K, value: KV[K]): Promise<void>;
+    /** Set multiple keys */
+    abstract setMany(keyValues: Partial<KV>): Promise<void>;
+    /** Delete key */
+    abstract delete(key: keyof KV): Promise<boolean>;
+    /** Delete multiple keys */
+    abstract deleteMany(keys: (keyof KV)[]): Promise<void>;
+    /** Delete all keys */
+    abstract clear(): Promise<void>;
+}

package/key-value-store/mongo/module.d.ts

@@ -0,0 +1,8 @@
+import type { MongoRepositoryConfig } from '../../database/mongo/index.js';
+import type { MongoKeyValue } from './mongo-key-value.model.js';
+/**
+ * configure mongo queue module
+ * @param keyValueRepositoryConfig repository configuration for jobs
+ * @param register whether to register for {@link Queue} and {@link QueueProvider}
+ */
+export declare function configureMongoKeyValueStore(keyValueRepositoryConfig: MongoRepositoryConfig<MongoKeyValue>, register?: boolean): void;

package/key-value-store/mongo/mongo-key-value-store.provider.d.ts

@@ -0,0 +1,8 @@
+import type { KeyValueStore, KeyValueStoreProvider } from '../../key-value-store/index.js';
+import type { StringMap } from '../../types.js';
+import { MongoKeyValueRepository } from './mongo-key-value.repository.js';
+export declare class MongoKeyValueStoreProvider implements KeyValueStoreProvider {
+    private readonly keyValueRepository;
+    constructor(keyValueRepository: MongoKeyValueRepository);
+    get<KV extends StringMap>(module: string): KeyValueStore<KV>;
+}

package/key-value-store/mongo/mongo-key-value.model.d.ts

@@ -0,0 +1,7 @@
+import type { Entity } from '../../database/index.js';
+export type MongoKeyValue<T = unknown> = Entity & {
+    module: string;
+    key: string;
+    value: T;
+    updated: number;
+};

package/key-value-store/mongo/mongo-key-value.repository.d.ts

@@ -0,0 +1,10 @@
+import type { CollectionArgument } from '../../database/mongo/index.js';
+import { Collection, MongoEntityRepository } from '../../database/mongo/index.js';
+import { resolveArgumentType } from '../../injector/index.js';
+import type { Resolvable } from '../../injector/interfaces.js';
+import { Logger } from '../../logger/index.js';
+import type { MongoKeyValue } from './mongo-key-value.model.js';
+export declare class MongoKeyValueRepository extends MongoEntityRepository<MongoKeyValue> implements Resolvable<CollectionArgument<MongoKeyValue>> {
+    readonly [resolveArgumentType]: CollectionArgument<MongoKeyValue, MongoKeyValue>;
+    constructor(collection: Collection<MongoKeyValue>, logger: Logger);
+}

package/key-value-store/mongo/mongo-key-value.store.d.ts

@@ -0,0 +1,14 @@
+import { KeyValueStore } from '../../key-value-store/index.js';
+import type { StringMap } from '../../types.js';
+import { MongoKeyValueRepository } from './mongo-key-value.repository.js';
+export declare class MongoKeyValueStore<KV extends StringMap> extends KeyValueStore<KV> {
+    private readonly keyValueRepository;
+    constructor(keyValueRepository: MongoKeyValueRepository, module: string);
+    get<K extends keyof KV>(key: K): Promise<KV[K] | undefined>;
+    get<K extends keyof KV, D>(key: K, defaultValue: D): Promise<D | KV[K]>;
+    set<K extends keyof KV>(key: K, value: KV[K]): Promise<void>;
+    setMany(keyValues: Partial<KV>): Promise<void>;
+    delete(key: keyof KV): Promise<boolean>;
+    deleteMany(keys: (keyof KV)[]): Promise<void>;
+    clear(): Promise<void>;
+}

package/key-value-store/mongo/tokens.d.ts

@@ -0,0 +1,3 @@
+import type { MongoRepositoryConfig } from '../../database/mongo/types.js';
+import type { MongoKeyValue } from './mongo-key-value.model.js';
+export declare const DEFAULT_KEY_VALUE_REPOSITORY_CONFIG: import("../../injector/token.js").InjectionToken<MongoRepositoryConfig<MongoKeyValue>, never>;

package/lock/lock.d.ts

@@ -0,0 +1,48 @@
+import type { Resolvable } from '../injector/index.js';
+import { resolveArgumentType } from '../injector/index.js';
+export type LockedFunction<R> = (controller: LockController) => R | Promise<R>;
+export type AcquireResult<Throw extends boolean> = Throw extends true ? LockController : (LockController | false);
+export type UsingResult<Throw extends boolean, R> = Throw extends true ? ({
+    success: true;
+    result: R;
+}) : ({
+    success: true;
+    result: R;
+} | {
+    success: false;
+    result: undefined;
+});
+export interface LockController {
+    /**
+     * whether the the lock is lost or not. Can happen for example if it couldn't be renewed
+     * because the network connection is lost (depending on implementation)
+     */
+    readonly lost: boolean;
+    /** manually release lock */
+    release(): void | Promise<void>;
+}
+/** resource */
+export type LockArgument = string | {
+    prefix?: string;
+    resource: string;
+};
+export declare abstract class Lock implements Resolvable<LockArgument> {
+    readonly resource: string;
+    readonly [resolveArgumentType]: LockArgument;
+    constructor(resource: string);
+    /**
+     * acquire a lock for the resource, it must be manually released
+     * @param timeout how long to try to get a lock. If undefined it's tries forever
+     * @param throwOnFail throw if resource is locked and we couldn't acquire it in the specified timeout
+     */
+    abstract acquire<Throw extends boolean>(timeout: number | undefined, throwOnFail: Throw): Promise<AcquireResult<Throw>>;
+    /**
+     * acquire a lock for the resource and release it automatically after the provided function has returned or thrown
+     * @param timeout how long to try to get a lock. If undefined it's tries forever
+     * @param throwOnFail throw if resource is locked and we couldn't acquire it in the specified timeout
+     * @param func function to run when lock is acquired
+     */
+    abstract use<Throw extends boolean, R>(timeout: number | undefined, throwOnFail: Throw, func: LockedFunction<R>): Promise<UsingResult<Throw, R>>;
+    /** check if resource is locked */
+    abstract exists(): Promise<boolean>;
+}

package/lock/mongo/lock.d.ts

@@ -0,0 +1,14 @@
+import type { AcquireResult, LockedFunction, UsingResult } from '../../lock/index.js';
+import { Lock } from '../../lock/index.js';
+import { Logger } from '../../logger/index.js';
+import { MongoLockRepository } from './mongo-lock-repository.js';
+export declare class MongoLock extends Lock {
+    #private;
+    constructor(lockRepository: MongoLockRepository, resource: string, logger: Logger);
+    acquire<Throw extends boolean>(timeout: number | undefined, throwOnFail: Throw): Promise<AcquireResult<Throw>>;
+    use<Throw extends boolean, R>(timeout: number | undefined, throwOnFail: Throw, func: LockedFunction<R>): Promise<UsingResult<Throw, R>>;
+    exists(): Promise<boolean>;
+    private tryAcquireOrRefresh;
+    private tryRefresh;
+    private release;
+}

package/lock/mongo/model.d.ts

@@ -0,0 +1,6 @@
+import type { Entity } from '../../database/index.js';
+export type MongoLockEntity = Entity & {
+    resource: string;
+    key: string;
+    expiration: Date;
+};

package/lock/mongo/module.d.ts

@@ -0,0 +1,12 @@
+import type { MongoRepositoryConfig } from '../../database/mongo/index.js';
+import type { MongoLockEntity } from './model.js';
+export type MongoLockModuleConfig = {
+    lockEntityRepositoryConfig: MongoRepositoryConfig<MongoLockEntity> | undefined;
+};
+export declare const mongoLockModuleConfig: MongoLockModuleConfig;
+/**
+ * configure mongo lock module
+ * @param lockRepositoryConfig repository configuration for locks
+ * @param register whether to register for {@link Lock} and {@link LockProvider}
+ */
+export declare function configureMongoLock(lockRepositoryConfig: MongoRepositoryConfig<MongoLockEntity>, register?: boolean): void;

package/lock/mongo/mongo-lock-repository.d.ts

@@ -0,0 +1,14 @@
+import type { CollectionArgument } from '../../database/mongo/index.js';
+import { Collection, MongoEntityRepository } from '../../database/mongo/index.js';
+import { resolveArgumentType } from '../../injector/index.js';
+import type { Resolvable } from '../../injector/interfaces.js';
+import { Logger } from '../../logger/index.js';
+import type { MongoLockEntity } from './model.js';
+export declare class MongoLockRepository extends MongoEntityRepository<MongoLockEntity> implements Resolvable<CollectionArgument<MongoLockEntity>> {
+    readonly [resolveArgumentType]: CollectionArgument<MongoLockEntity>;
+    constructor(collection: Collection<MongoLockEntity>, logger: Logger);
+    tryInsertOrRefresh(resource: string, key: string, newExpirationDate: Date): Promise<false | Date>;
+    exists(resource: string): Promise<boolean>;
+    tryUpdateExpiration(resource: string, key: string, expirationDate: Date): Promise<false | Date>;
+    deleteByResource(resource: string, key: string): Promise<boolean>;
+}

package/lock/mongo/provider.d.ts

@@ -0,0 +1,8 @@
+import type { Lock } from '../../lock/index.js';
+import { LockProvider } from '../../lock/index.js';
+export declare class MongoLockProvider extends LockProvider {
+    #private;
+    prefix(prefix: string): MongoLockProvider;
+    get(resource: string): Lock;
+    private getResourceString;
+}

package/lock/provider.d.ts

@@ -0,0 +1,10 @@
+import type { Resolvable } from '../injector/index.js';
+import { resolveArgumentType } from '../injector/index.js';
+import type { Lock } from './lock.js';
+/** prefix */
+export type LockProviderArgument = string;
+export declare abstract class LockProvider implements Resolvable<LockProviderArgument> {
+    readonly [resolveArgumentType]: LockProviderArgument;
+    abstract prefix(prefix: string): LockProvider;
+    abstract get(resource: string): Lock;
+}

package/lock/web/web-lock.provider.d.ts

@@ -0,0 +1,8 @@
+import type { Lock } from '../../lock/index.js';
+import { LockProvider } from '../../lock/index.js';
+export declare class WebLockProvider extends LockProvider {
+    private readonly _prefix;
+    constructor(prefix?: string);
+    prefix(prefix: string): LockProvider;
+    get(resource: string): Lock;
+}

package/logger/logger.d.ts

@@ -0,0 +1,41 @@
+import type { Resolvable } from '../injector/index.js';
+import { resolveArgumentType } from '../injector/index.js';
+import { LogLevel } from './level.js';
+export type LogEntry = string;
+export type LogEntryProvider = () => LogEntry;
+export type LogEntryOrProvider = LogEntry | LogEntryProvider;
+export type LoggerStatic = new (level: LogLevel) => Logger;
+export type LogErrorOptions = {
+    includeRest?: boolean;
+    includeStack?: boolean;
+};
+/** Either string as a module shorthand or object */
+export type LoggerArgument = string | undefined | {
+    level?: LogLevel;
+    module?: string | string[];
+    prefix?: string;
+};
+export type LoggerForkOptions = {
+    subModule?: string;
+    prefix?: string;
+    level?: LogLevel;
+};
+export declare abstract class Logger implements Resolvable<LoggerArgument> {
+    readonly level: LogLevel;
+    readonly module?: string[];
+    readonly logPrefix: string;
+    readonly [resolveArgumentType]: LoggerArgument;
+    constructor(level: LogLevel, module?: string | string[], prefix?: string);
+    error(entry: LogEntryOrProvider): void;
+    error(error: unknown, options?: LogErrorOptions): void;
+    warn(entry: LogEntryOrProvider): void;
+    info(entry: LogEntryOrProvider): void;
+    verbose(entry: LogEntryOrProvider): void;
+    debug(entry: LogEntryOrProvider): void;
+    trace(entry: LogEntryOrProvider): void;
+    private _log;
+    abstract fork(options: LoggerForkOptions): Logger;
+    abstract subModule(subModule: string): Logger;
+    abstract prefix(prefix: string): Logger;
+    protected abstract log(level: LogLevel, entry: LogEntry | Error, errorOptions?: LogErrorOptions): void;
+}

package/logger/tokens.d.ts

@@ -0,0 +1,2 @@
+import type { LogLevel } from './level.js';
+export declare const LOG_LEVEL: import("../injector/token.js").InjectionToken<LogLevel, never>;

package/mail/clients/nodemailer.mail-client.d.ts

@@ -0,0 +1,13 @@
+import type { Disposable } from '../../disposable/disposable.js';
+import { MailClient, MailClientConfig } from '../mail.client.js';
+import type { MailData, MailSendResult } from '../models/index.js';
+export declare class NodemailerMailClient extends MailClient implements Disposable {
+    #private;
+    [Symbol.dispose](): void;
+    send(data: MailData, clientConfig?: MailClientConfig): Promise<MailSendResult>;
+    private getTransport;
+}
+/**
+ * @param register whether to register for {@link MailClient}
+ */
+export declare function configureNodemailerMailClient(register?: boolean): void;

package/mail/mail.client.d.ts

@@ -0,0 +1,17 @@
+import { resolveArgumentType, type Resolvable } from '../injector/index.js';
+import type { MailData, MailSendResult } from './models/index.js';
+export declare class MailClientAuthConfig {
+    user: string;
+    password: string;
+}
+export declare class MailClientConfig {
+    host: string;
+    port: number;
+    /** Enable TLS (if not defined it is automatically set depending on port) */
+    secure?: boolean;
+    auth?: MailClientAuthConfig;
+}
+export declare abstract class MailClient implements Resolvable<MailClientConfig> {
+    readonly [resolveArgumentType]: MailClientConfig;
+    abstract send(data: MailData, clientConfig?: MailClientConfig): Promise<MailSendResult>;
+}

package/mail/mail.service.d.ts

@@ -0,0 +1,10 @@
+import type { TypedOmit } from '../types.js';
+import { MailClientConfig } from './mail.client.js';
+import { type MailData, type MailSendResult, type MailTemplate } from './models/index.js';
+export declare class MailService {
+    #private;
+    send(mailData: MailData, clientConfig?: MailClientConfig): Promise<MailSendResult>;
+    /** @deprecated internal */
+    send(mailData: MailData, clientConfig?: MailClientConfig, templateName?: string): Promise<MailSendResult>;
+    sendTemplate<Context extends object>(keyOrTemplate: string | MailTemplate<Context>, mailData: TypedOmit<MailData, 'content' | 'subject'>, templateContext?: Context, clientConfig?: MailClientConfig): Promise<MailSendResult>;
+}

package/mail/models/mail-data.model.d.ts

@@ -0,0 +1,21 @@
+import type { OneOrMany } from '../../types.js';
+import type { MailAddress } from './mail-address.model.js';
+import type { MailContent } from './mail-content.model.js';
+export type MailData = {
+    content: MailContent;
+    from?: MailAddress;
+    to?: OneOrMany<MailAddress>;
+    subject?: string;
+    sender?: MailAddress;
+    cc?: OneOrMany<MailAddress>;
+    bcc?: OneOrMany<MailAddress>;
+    replyTo?: MailAddress;
+    inReplyTo?: MailAddress;
+    returnPath?: MailAddress;
+    references?: OneOrMany<string>;
+    /**
+     * If a header has an string array as its value, the header is added multiple times.
+     */
+    headers?: Record<string, string | string[]>;
+};
+export type DefaultMailData = Partial<MailData>;

package/mail/models/mail-log.model.d.ts

@@ -0,0 +1,10 @@
+import { Entity, Json, Timestamp } from '../../orm/index.js';
+import type { MailData } from './mail-data.model.js';
+import type { MailSendResult } from './mail-send-result.model.js';
+export declare class MailLog extends Entity {
+    timestamp: Timestamp;
+    template: string | null;
+    data: Json<MailData>;
+    sendResult: Json<MailSendResult> | null;
+    errors: string[] | null;
+}

package/mail/models/mail-template.model.d.ts

@@ -0,0 +1,14 @@
+import type { Template, TemplateField } from '../../templates/template.model.js';
+import type { Record } from '../../types.js';
+export type MailTemplate<Context extends Record = any> = Template<{
+    subject: false;
+    html: false;
+    text: false;
+}, undefined, Context>;
+type MailTemplateFields<Context extends Record> = {
+    subject?: TemplateField<string, string, any, Context>;
+    html?: TemplateField<string, string, any, Context>;
+    text?: TemplateField<string, string, any, Context>;
+};
+export declare function mailTemplate<Context extends Record>(name: string, fields: MailTemplateFields<Context>): MailTemplate<Context>;
+export {};

package/mail/models/schemas.d.ts

@@ -0,0 +1,3 @@
+import { MailLog } from './mail-log.model.js';
+export declare const mailSchema: import("../../orm/server/database-schema.js").DatabaseSchema<"mail">;
+export declare const mailLog: import("../../orm/server/types.js").PgTableFromType<typeof MailLog, "mail">;

package/mail/module.d.ts

@@ -0,0 +1,15 @@
+import { type DatabaseConfig } from '../orm/server/index.js';
+import type { Type } from '../types.js';
+import { MailClient, MailClientConfig } from './mail.client.js';
+import type { DefaultMailData } from './models/index.js';
+export declare class MailModuleConfig {
+    database?: DatabaseConfig;
+    defaultClientConfig?: MailClientConfig;
+    client?: Type<MailClient>;
+    defaultData?: DefaultMailData;
+}
+/**
+ * configure mail module
+ */
+export declare function configureMail(config: MailModuleConfig): void;
+export declare function migrateMailSchema(): Promise<void>;

package/mail/tokens.d.ts

@@ -0,0 +1 @@
+export declare const MAIL_DEFAULT_DATA: import("../injector/index.js").InjectionToken<Partial<import("./models/mail-data.model.js").MailData>, never>;

package/message-bus/broadcast-channel/broadcast-channel-message-bus-provider.d.ts

@@ -0,0 +1,8 @@
+import { Logger } from '../../logger/index.js';
+import type { MessageBusProvider } from '../message-bus-provider.js';
+import type { MessageBus } from '../message-bus.js';
+export declare class BroadcastChannelMessageBusProvider implements MessageBusProvider {
+    private readonly logger;
+    constructor(logger: Logger);
+    get<T>(channel: string): MessageBus<T>;
+}

package/message-bus/broadcast-channel/broadcast-channel-message-bus.d.ts

@@ -0,0 +1,19 @@
+import type { Observable } from 'rxjs';
+import { Logger } from '../../logger/index.js';
+import { MessageBusBase } from '../message-bus-base.js';
+import type { MessageBus } from '../message-bus.js';
+/** return values wrapped in Promise for polyfills which returns promises */
+interface PromisifiedBroadcastChannel extends BroadcastChannel {
+    close(...args: Parameters<BroadcastChannel['close']>): void | Promise<void>;
+    postMessage(...args: Parameters<BroadcastChannel['postMessage']>): void | Promise<void>;
+}
+export declare class BroadcastChannelMessageBus<T> extends MessageBusBase<T> implements MessageBus<T> {
+    private readonly channelProvider;
+    private _channel;
+    protected readonly _messages$: Observable<T>;
+    get channel(): PromisifiedBroadcastChannel;
+    constructor(channelProvider: () => BroadcastChannel, logger: Logger);
+    protected _publish(message: T): Promise<void>;
+    protected _dispose(): Promise<void>;
+}
+export {};

package/message-bus/local/local-message-bus-provider.d.ts

@@ -0,0 +1,9 @@
+import { Logger } from '../../logger/index.js';
+import { MessageBusProvider } from '../message-bus-provider.js';
+import { LocalMessageBus } from './local-message-bus.js';
+export declare class LocalMessageBusProvider extends MessageBusProvider {
+    private readonly logger;
+    private readonly channelSubjectsMap;
+    constructor(logger: Logger);
+    get<T>(channel: string): LocalMessageBus<T>;
+}

package/message-bus/local/local-message-bus.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import { Subject } from 'rxjs';
+import { Logger } from '../../logger/index.js';
+import { MessageBusBase } from '../message-bus-base.js';
+import type { MessageBus } from '../message-bus.js';
+import type { LocalMessageBusItem } from './types.js';
+export declare class LocalMessageBus<T> extends MessageBusBase<T> implements MessageBus<T> {
+    private readonly subject;
+    private readonly source;
+    protected _messages$: Observable<T>;
+    constructor(subject: Subject<LocalMessageBusItem<T>>, logger: Logger);
+    _publish(message: T): void;
+    _dispose(): void;
+}

package/message-bus/message-bus-base.d.ts

@@ -0,0 +1,26 @@
+import type { Observable } from 'rxjs';
+import type { Logger } from '../logger/index.js';
+import { CancellationToken } from '../cancellation/token.js';
+import { disposeAsync } from '../disposable/disposable.js';
+import { MessageBus } from './message-bus.js';
+export declare abstract class MessageBusBase<T> extends MessageBus<T> {
+    private readonly logger;
+    private readonly publishSubject;
+    protected readonly disposeToken: CancellationToken;
+    readonly messages$: Observable<T>;
+    readonly allMessages$: Observable<T>;
+    /**
+     * observable which emits all messages from *other* instances, but *none* published from itself
+     */
+    protected abstract _messages$: Observable<T>;
+    constructor(logger: Logger);
+    publishAndForget(message: T): void;
+    publish(message: T): Promise<void>;
+    [disposeAsync](): Promise<void>;
+    /**
+     * publish messages to other instances
+     * @param message message to send to other instances
+     */
+    protected abstract _publish(message: T): void | Promise<void>;
+    protected abstract _dispose(): void | Promise<void>;
+}

package/message-bus/message-bus.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import { type Resolvable, resolveArgumentType } from '../injector/interfaces.js';
+import { type AsyncDisposable, disposeAsync } from '../disposable/disposable.js';
+export type MessageBusArgument = string;
+export declare abstract class MessageBus<T> implements AsyncDisposable, Resolvable<MessageBusArgument> {
+    readonly [resolveArgumentType]: string;
+    /** Messages from other instances */
+    abstract readonly messages$: Observable<T>;
+    /** Messages from other instances and itself */
+    abstract readonly allMessages$: Observable<T>;
+    dispose(): Promise<void>;
+    abstract publish(message: T): Promise<void>;
+    abstract publishAndForget(message: T): void;
+    abstract [disposeAsync](): Promise<void>;
+}

package/migration/migration-state-repository.d.ts

@@ -0,0 +1,4 @@
+import { EntityRepository } from '../database/index.js';
+import type { MigrationState } from './migration-state.js';
+export declare abstract class MigrationStateRepository extends EntityRepository<MigrationState> {
+}

package/migration/migration-state.d.ts

@@ -0,0 +1,6 @@
+import type { Entity, NewEntity } from '../database/index.js';
+export type MigrationState = Entity & {
+    name: string;
+    revision: number;
+};
+export type NewMigrationState = NewEntity<MigrationState>;

package/migration/mongo/migration-state-repository.d.ts

@@ -0,0 +1,11 @@
+import type { Resolvable } from '../../injector/index.js';
+import { resolveArgumentType } from '../../injector/index.js';
+import { Logger } from '../../logger/index.js';
+import type { MigrationState, MigrationStateRepository } from '../../migration/index.js';
+import type { CollectionArgument } from '../../database/mongo/classes.js';
+import { Collection } from '../../database/mongo/classes.js';
+import { MongoEntityRepository } from '../../database/mongo/mongo-entity-repository.js';
+export declare class MongoMigrationStateRepository extends MongoEntityRepository<MigrationState> implements MigrationStateRepository, Resolvable<CollectionArgument<MigrationState>> {
+    readonly [resolveArgumentType]: CollectionArgument<MigrationState>;
+    constructor(collection: Collection<MigrationState>, logger: Logger);
+}