@tstdl/base 0.92.122 → 0.92.124

package/injector/injector.d.ts

@@ -1,113 +0,0 @@
-import { type AsyncDisposable } from '../disposable/disposable.js';
-import type { OneOrMany, Record, TypedOmit } from '../types.js';
-import { type InjectOptions } from './inject.js';
-import { type ResolveArgument } from './interfaces.js';
-import { type Provider } from './provider.js';
-import { type InjectionToken } from './token.js';
-import type { RegistrationOptions, ResolveOptions } from './types.js';
-export type ProvidersItem<T = any, A = any, D extends Record = Record> = Provider<T, A, D> & {
-    provide: InjectionToken<T, A>;
-    multi?: boolean;
-};
-export type GlobalRegistration<T = any, A = any> = {
-    token: InjectionToken<T, A>;
-    provider: Provider<T, A>;
-    providers: ProvidersItem[];
-    options: RegistrationOptions<T, A>;
-};
-export type Registration<T = any, A = any> = GlobalRegistration<T, A> & {
-    resolutions: Map<any, T>;
-};
-export type GetRegistrationOptions = {
-    skipSelf?: boolean;
-    onlySelf?: boolean;
-};
-export type ResolveManyArrayItem<T, A> = [token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>];
-export type ResolveManyItem<T, A> = InjectionToken<T, A> | ResolveManyArrayItem<T, A>;
-export type ResolveManyItemReturnType<T extends ResolveManyItem<any, any>> = T extends ResolveManyItem<infer U, any> ? U | (T extends (ResolveManyArrayItem<any, any> & [any, any, {
-    optional: true;
-}]) ? undefined : never) : never;
-export type ResolveManyReturnType<T extends ResolveManyItem<any, any>[]> = {
-    [I in keyof T]: ResolveManyItemReturnType<T[I]>;
-};
-export type AddDisposeHandler = (handler: Disposable | AsyncDisposable | (() => any)) => void;
-export declare class Injector implements AsyncDisposable {
-    #private;
-    readonly name: string;
-    get disposed(): boolean;
-    constructor(name: string, parent?: Injector | null);
-    /**
-     * Globally register a provider for a token
-     * @param token token to register
-     * @param provider provider used to resolve the token
-     * @param options registration options
-     */
-    static register<T, A = any, D extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, D>>, options?: RegistrationOptions<T, A, D>): void;
-    /**
-     * Globally register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
-     * @param token token to register
-     * @param provider provider used to resolve the token
-     * @param options registration options
-     */
-    static registerSingleton<T, A = ResolveArgument<T, any>, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: TypedOmit<RegistrationOptions<T, A, C>, 'lifecycle'>): void;
-    dispose(): Promise<void>;
-    [Symbol.asyncDispose](): Promise<void>;
-    fork(name: string): Injector;
-    /**
-     * Register a provider for a token
-     * @param token token to register
-     * @param provider provider used to resolve the token
-     * @param options registration options
-     */
-    register<T, A = any, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: RegistrationOptions<T, A, C>): void;
-    /**
-     * Register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
-     * @param token token to register
-     * @param provider provider used to resolve the token
-     * @param options registration options
-     */
-    registerSingleton<T, A = any, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: TypedOmit<RegistrationOptions<T, A, C>, 'lifecycle'>): void;
-    /**
-     * Check if token has a registered provider
-     * @param token token check
-     */
-    hasRegistration(token: InjectionToken, options?: GetRegistrationOptions): boolean;
-    /**
-     * Try to get registration
-     * @param token token to get registration for
-     */
-    tryGetRegistration<T, A>(token: InjectionToken<T, A>, options?: GetRegistrationOptions): Registration<T, A> | Registration<T, A>[] | undefined;
-    /**
-     * Get registration
-     * @param token token to get registration for
-     */
-    getRegistration<T, A>(token: InjectionToken<T, A>, options?: GetRegistrationOptions): Registration<T, A> | Registration<T, A>[];
-    resolve<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions<T, A> & {
-        optional: true;
-    }): T | undefined;
-    resolve<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): T;
-    resolveAll<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): T[];
-    resolveMany<T extends ResolveManyItem<any, any>[]>(...tokens: T): ResolveManyReturnType<T>;
-    resolveAsync<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions<T, A> & {
-        optional: true;
-    }): Promise<T | undefined>;
-    resolveAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): Promise<T>;
-    resolveAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): Promise<T[]>;
-    resolveManyAsync<T extends ResolveManyItem<any, any>[]>(...tokens: T): Promise<ResolveManyReturnType<T>>;
-    private _resolve;
-    private _resolveAll;
-    private _resolveRegistration;
-    private _resolveProvider;
-    private resolveClassInjection;
-    private resolveInjection;
-    private resolveInjectionAsync;
-    private resolveInjectionAll;
-    private resolveInjectionAllAsync;
-    private getResolveContext;
-    private getAfterResolveContext;
-    private getInjectionContext;
-    private assertNotDisposed;
-}
-export declare function provide<T = any, A = any, D extends Record = Record>(token: InjectionToken<T, A>, provider: Provider<T, A, D> & {
-    multi?: boolean;
-}): ProvidersItem<T, A, D>;

package/injector/interfaces.d.ts

@@ -1,17 +0,0 @@
-import type { Record, Type } from '../types.js';
-import type { ArgumentedInjectionToken, InjectionTokenArgument, ReifyingInjectionToken } from './token.js';
-import type { AfterResolveContext } from './types.js';
-export declare const resolveArgumentType: unique symbol;
-export declare const afterResolve: unique symbol;
-export type ResolveArgumentType = typeof resolveArgumentType;
-export type ResolveArgument<T, Fallback = undefined> = undefined | (T extends Resolvable<infer U> ? (U | undefined) : T extends Type<Resolvable<infer U>> ? (U | undefined) : T extends (ArgumentedInjectionToken<any, any> | ReifyingInjectionToken) ? InjectionTokenArgument<T> : Fallback);
-export interface Resolvable<A = unknown, D extends Record = Record> extends Partial<AfterResolve<A, D>> {
-    /**
-     * Type of resolve argument
-     * @deprecated only used for type inference
-     */
-    readonly [resolveArgumentType]?: A;
-}
-export interface AfterResolve<A = unknown, D extends Record = Record> {
-    [afterResolve](argument: NoInfer<A>, context: AfterResolveContext<NoInfer<D>>): void | Promise<void>;
-}

package/injector/provider.d.ts

@@ -1,57 +0,0 @@
-import type { Constructor, Record, TypedOmit } from '../types.js';
-import type { ResolveArgument } from './interfaces.js';
-import type { InjectionToken } from './token.js';
-import type { AfterResolveContext, ResolveContext } from './types.js';
-export type Factory<T, A = any, D extends Record = Record> = (argument: ResolveArgument<T, A>, context: ResolveContext<D>) => T;
-export type ProviderWithArgument<T, A> = {
-    defaultArgument?: ResolveArgument<T, A>;
-    defaultArgumentProvider?: () => ResolveArgument<T, A>;
-};
-export type ProviderWithInitializer<T, A, D extends Record> = {
-    afterResolve?: (value: T, argument: A, context: AfterResolveContext<D>) => void | Promise<void>;
-};
-export type Provider<T = any, A = any, D extends Record = Record> = ClassProvider<T, A, D> | ValueProvider<T> | TokenProvider<T, A, D> | FactoryProvider<T, A, D>;
-export type ClassProvider<T = any, A = any, D extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, D> & {
-    useClass: Constructor<T>;
-};
-export type ValueProvider<T = any> = {
-    useValue: T;
-};
-export type TokenProvider<T = any, A = any, D extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, D> & ({
-    useToken: InjectionToken<T, A>;
-    useTokenProvider?: undefined;
-    resolveAll?: false;
-} | {
-    useToken?: undefined;
-    useTokenProvider: () => InjectionToken<T, A>;
-    resolveAll?: false;
-} | {
-    useToken: InjectionToken<T extends (infer U)[] ? U : T, A>;
-    useTokenProvider?: undefined;
-    resolveAll: true;
-} | {
-    useToken?: undefined;
-    useTokenProvider: () => InjectionToken<T extends (infer U)[] ? U : T, A>;
-    resolveAll: true;
-});
-export type FactoryProvider<T = any, A = unknown, D extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, D> & {
-    useFactory: Factory<T, A, D>;
-};
-export declare function classProvider<T, A, D extends Record>(constructor: Constructor<T>, options?: TypedOmit<ClassProvider<T, A, D>, 'useClass'>): ClassProvider<T, A, D>;
-export declare function valueProvider<T>(value: T, options?: TypedOmit<ValueProvider<T>, 'useValue'>): ValueProvider<T>;
-export declare function tokenProvider<T, A, D extends Record>(token: InjectionToken<T, A>, options: TypedOmit<TokenProvider<T, A, D>, 'useToken' | 'useTokenProvider'> & {
-    resolveAll: true;
-}): TokenProvider<T[]>;
-export declare function tokenProvider<T, A, D extends Record>(token: InjectionToken<T, A>, options?: TypedOmit<TokenProvider<T, A, D>, 'useToken' | 'useTokenProvider'>): TokenProvider<T>;
-export declare function factoryProvider<T, A, D extends Record>(factory: Factory<T, A, D>, options?: TypedOmit<FactoryProvider<T, A, D>, 'useFactory'>): FactoryProvider<T, A, D>;
-export declare function isClassProvider<T, A>(value: Provider<T, A>): value is ClassProvider<T, A>;
-export declare function isClassProvider<T, A>(value: unknown): value is ClassProvider<T, A>;
-export declare function isValueProvider<T>(value: Provider<T>): value is ValueProvider<T>;
-export declare function isValueProvider<T>(value: unknown): value is ValueProvider<T>;
-export declare function isTokenProvider<T, A>(value: Provider<T, A>): value is TokenProvider<T, A>;
-export declare function isTokenProvider<T, A>(value: unknown): value is TokenProvider<T, A>;
-export declare function isFactoryProvider<T, A>(value: Provider<T, A>): value is FactoryProvider<T, A>;
-export declare function isFactoryProvider<T, A>(value: unknown): value is FactoryProvider<T, A>;
-export declare function isProvider<T, A>(value: Provider<T, A>): value is Provider<T, A>;
-export declare function isProvider<T, A>(value: unknown): value is Provider<T, A>;
-export declare function isProviderWithInitializer<T, A, C extends Record>(value: Provider<T, A, C>): value is Extract<Provider<T, A, C>, ProviderWithInitializer<T, A, C>>;

package/injector/resolution.d.ts

@@ -1,15 +0,0 @@
-import type { Record } from '../types.js';
-import type { Resolvable } from './interfaces.js';
-import type { AfterResolveContext } from './types.js';
-export type AfterResolveHandler<A, D extends Record> = (argument: A, context: AfterResolveContext<D>) => void | Promise<void>;
-export type ResolutionContext<A> = {
-    afterResolveRegistrations: AfterResolveHandler<A, any>[];
-};
-declare const assertInResolutionContext: (debugFnOrMessage: import("../types.js").Function | string) => void, getCurrentResolutionContext: {
-    (required: true, debugFn: import("../types.js").Function): ResolutionContext<any>;
-    (required?: false, debugFn?: import("../types.js").Function): ResolutionContext<any> | null;
-    (required: boolean, debugFn: import("../types.js").Function): ResolutionContext<any> | null;
-}, runInResolutionContext: <ReturnT>(context: ResolutionContext<any>, fn: () => ReturnT) => ReturnT;
-export declare function registerAfterResolve(handler: AfterResolveHandler<unknown, Record>): void;
-export declare function registerAfterResolve<A, D extends Record>(_this: Resolvable<A, D>, handler: AfterResolveHandler<A, D>): void;
-export { assertInResolutionContext, getCurrentResolutionContext, runInResolutionContext };

package/injector/resolve-chain.d.ts

@@ -1,34 +0,0 @@
-import type { AbstractConstructor } from '../types.js';
-import type { InjectionToken } from './token.js';
-export type ResolveChainNodeBase<Type extends string> = {
-    type: Type;
-    forwardRef?: true;
-};
-export type ResolveChainNode = ResolveChainNodeBase<'token'> & {
-    token: InjectionToken;
-} | ResolveChainNodeBase<'inject'> & {
-    token: InjectionToken;
-    index: number;
-} | ResolveChainNodeBase<'parameter'> & {
-    constructor: AbstractConstructor;
-    index: number;
-    token: InjectionToken;
-} | ResolveChainNodeBase<'property'> & {
-    constructor: AbstractConstructor;
-    property: PropertyKey;
-    token: InjectionToken;
-};
-export declare class ResolveChain {
-    readonly nodes: readonly ResolveChainNode[];
-    get length(): number;
-    /** @deprecated internal */
-    constructor(nodes: ResolveChainNode[]);
-    static startWith(token: InjectionToken): ResolveChain;
-    addToken(token: InjectionToken): ResolveChain;
-    addInject(token: InjectionToken, index: number): ResolveChain;
-    addParameter(constructor: AbstractConstructor, index: number, token: InjectionToken): ResolveChain;
-    addProperty(constructor: AbstractConstructor, property: PropertyKey, token: InjectionToken): ResolveChain;
-    markAsForwardRef(forwardToken: InjectionToken): ResolveChain;
-    format(truncate?: number): string;
-    truncate(tokenCount: number): ResolveChain;
-}

package/injector/resolve.error.d.ts

@@ -1,5 +0,0 @@
-import { CustomError } from '../errors/custom.error.js';
-import type { ResolveChain } from './resolve-chain.js';
-export declare class ResolveError extends CustomError {
-    constructor(message: string, chain: ResolveChain, cause?: Error);
-}

package/injector/token.d.ts

@@ -1,25 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

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

package/lock/mongo/module.d.ts

@@ -1,12 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

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