@tstdl/base 0.92.124 → 0.92.126

package/types/http/http-value-map.d.ts

@@ -1,36 +0,0 @@
-import type { OneOrMany, Record } from '../../types.js';
-import type { HttpValue, NormalizedHttpValue, NormalizedHttpValueObject } from './types.js';
-export type HttpValueMapInput = Record<string, OneOrMany<HttpValue> | undefined> | Iterable<[string, OneOrMany<HttpValue> | undefined]>;
-export declare abstract class HttpValueMap<TThis extends HttpValueMap<any>> implements Iterable<[string, OneOrMany<HttpValue>]> {
-    private readonly valueType;
-    private readonly caseInsensitive;
-    private readonly map;
-    constructor(valueType: string, caseInsensitive: boolean, input?: HttpValueMapInput);
-    /** check if entry is available */
-    has(key: string): boolean;
-    /** get value. Throws if entry not set */
-    get(key: string): OneOrMany<HttpValue>;
-    /** try to get value */
-    tryGet(key: string): OneOrMany<HttpValue> | undefined;
-    /** get single value, throws if multiple values are set */
-    getSingle(key: string): HttpValue;
-    /** try to get single value, throws if multiple values are set */
-    tryGetSingle(key: string): HttpValue | undefined;
-    /** replace entry */
-    set(key: string, value: OneOrMany<HttpValue> | undefined): void;
-    /** set entry if missing */
-    setIfMissing(key: string, value: OneOrMany<HttpValue> | undefined): void;
-    setMany(input: HttpValueMapInput): void;
-    /** add value to existing entry or create new entry */
-    append(key: string, value: OneOrMany<HttpValue>): void;
-    /** remove entry */
-    remove(key: string): void;
-    /** remove all entries */
-    clear(): void;
-    asObject(): Record<string, OneOrMany<HttpValue>>;
-    asNormalizedObject(): NormalizedHttpValueObject;
-    normalizedEntries(): Iterable<[string, OneOrMany<NormalizedHttpValue>]>;
-    [Symbol.iterator](): Iterator<[string, OneOrMany<HttpValue>]>;
-    private normalizeKey;
-    abstract clone(): TThis;
-}

package/types/http/http.error.d.ts

@@ -1,28 +0,0 @@
-import type { TypedOmit, UndefinableJson } from '../../types.js';
-import type { ErrorExtraInfo } from '../../utils/format-error.js';
-import { CustomError } from '../errors/custom.error.js';
-import type { HttpClientRequest, HttpClientRequestObject, HttpClientResponse, HttpClientResponseObject } from './client/index.js';
-export declare enum HttpErrorReason {
-    Unknown = "Unknown",
-    Cancelled = "Cancelled",
-    Network = "Network",
-    InvalidRequest = "InvalidRequest",
-    StatusCode = "StatusCode",
-    /** Valid http response containing an error */
-    ErrorResponse = "ErrorResponse",
-    /** Invalid http response */
-    ResponseError = "ResponseError",
-    Timeout = "Timeout"
-}
-export declare class HttpError extends CustomError implements ErrorExtraInfo {
-    static readonly errorName = "HttpError";
-    readonly reason: HttpErrorReason;
-    readonly request: HttpClientRequestObject;
-    readonly response: TypedOmit<HttpClientResponseObject, 'request'> | undefined;
-    readonly responseBody: UndefinableJson | Uint8Array;
-    readonly requestInstance: HttpClientRequest;
-    readonly responseInstance: HttpClientResponse | undefined;
-    constructor(reason: HttpErrorReason, request: HttpClientRequest, response?: HttpClientResponse, responseBody?: UndefinableJson | Uint8Array, cause?: Error | string);
-    static create(reason: HttpErrorReason, request: HttpClientRequest, response: HttpClientResponse | undefined, cause?: Error | string): Promise<HttpError>;
-    getExtraInfo(): UndefinableJson | undefined;
-}

package/types/http/server/http-server-request.d.ts

@@ -1,23 +0,0 @@
-import type { StringMap } from '../../../types.js';
-import { CookieParser } from '../cookie-parser.js';
-import type { HttpBodySource } from '../http-body.js';
-import { HttpBody } from '../http-body.js';
-import type { HttpHeaders } from '../http-headers.js';
-import type { HttpQuery } from '../http-query.js';
-import type { HttpMethod } from '../types.js';
-export type HttpServerRequestObject = Pick<HttpServerRequest, 'url' | 'method' | 'headers' | 'query' | 'ip'> & {
-    body: HttpBody | HttpBodySource;
-    context?: StringMap;
-};
-export declare class HttpServerRequest {
-    readonly url: URL;
-    readonly method: HttpMethod;
-    readonly headers: HttpHeaders;
-    readonly cookies: CookieParser;
-    readonly query: HttpQuery;
-    readonly body: HttpBody;
-    readonly ip: string;
-    context: StringMap;
-    get hasBody(): boolean;
-    constructor(data: HttpServerRequestObject);
-}

package/types/http/server/http-server-response.d.ts

@@ -1,38 +0,0 @@
-import type { SetCookieOptions } from '../../../cookie/cookie.js';
-import type { ServerSentEventsSource } from '../../../sse/server-sent-events-source.js';
-import type { Record } from '../../../types.js';
-import type { HttpHeadersInput } from '../http-headers.js';
-import { HttpHeaders } from '../http-headers.js';
-export type SetCookieObject = SetCookieOptions & {
-    value: string;
-};
-export type HttpServerResponseOptions = {
-    statusCode?: number | undefined;
-    statusMessage?: string | undefined;
-    headers?: HttpHeadersInput | HttpHeaders;
-    cookies?: Record<string, SetCookieObject>;
-    body?: {
-        stream?: ReadableStream<Uint8Array>;
-        buffer?: Uint8Array;
-        text?: string;
-        json?: unknown;
-        events?: ServerSentEventsSource;
-    };
-};
-export declare class HttpServerResponse {
-    statusCode: number | undefined;
-    statusMessage: string | undefined;
-    headers: HttpHeaders;
-    body: undefined | {
-        stream?: ReadableStream<Uint8Array>;
-        buffer?: Uint8Array;
-        text?: string;
-        json?: unknown;
-        events?: ServerSentEventsSource;
-    };
-    constructor(response?: HttpServerResponseOptions);
-    static fromObject(options?: HttpServerResponseOptions): HttpServerResponse;
-    static redirect(url: string, options?: HttpServerResponseOptions): HttpServerResponse;
-    update(options: HttpServerResponseOptions): void;
-}
-export declare function redirect(url: string, options?: HttpServerResponseOptions): HttpServerResponse;

package/types/http/server/http-server.d.ts

@@ -1,16 +0,0 @@
-import type { AsyncDisposable } from '../../../disposable/index.js';
-import { disposeAsync } from '../../../disposable/index.js';
-import type { HttpServerRequest, HttpServerResponse } from '../../../http/server/index.js';
-export type HttpServerRequestContext<Context = unknown> = {
-    request: HttpServerRequest;
-    context: Context;
-    respond(response: HttpServerResponse): Promise<void>;
-    close(): Promise<void>;
-};
-export declare abstract class HttpServer<Context = unknown> implements AsyncIterable<HttpServerRequestContext<Context>>, AsyncDisposable {
-    abstract readonly connectedSocketsCount: number;
-    abstract listen(port: number): Promise<void>;
-    abstract close(timeout: number): Promise<void>;
-    abstract [Symbol.asyncIterator](): AsyncIterator<HttpServerRequestContext<Context>>;
-    abstract [disposeAsync](): Promise<void>;
-}

package/types/http/server/node/node-http-server.d.ts

@@ -1,22 +0,0 @@
-import * as Http from 'node:http';
-import { disposeAsync, type AsyncDisposable } from '../../../../disposable/index.js';
-import { Logger } from '../../../../logger/index.js';
-import { HttpServer, type HttpServerRequestContext } from '../http-server.js';
-export type NodeHttpServerContext = {
-    nodeRequest: Http.IncomingMessage;
-    nodeResponse: Http.ServerResponse;
-};
-export declare class NodeHttpServer extends HttpServer<NodeHttpServerContext> implements AsyncDisposable {
-    private readonly httpServer;
-    private readonly sockets;
-    private readonly requestIterable;
-    private readonly logger;
-    private untrackConnectedSockets?;
-    get connectedSocketsCount(): number;
-    constructor(logger: Logger);
-    [disposeAsync](): Promise<void>;
-    listen(port: number): Promise<void>;
-    close(timeout: number): Promise<void>;
-    [Symbol.asyncIterator](): AsyncIterator<HttpServerRequestContext<NodeHttpServerContext>>;
-    private handleRequest;
-}

package/types/http/types.d.ts

@@ -1,10 +0,0 @@
-import type { OneOrMany, WritableOneOrMany } from '../../types.js';
-export type HttpValue = string | number | boolean | null;
-export type NormalizedHttpValue = string;
-export type HttpValueObject = Record<string, OneOrMany<HttpValue>>;
-export type NormalizedHttpValueObject = Record<string, WritableOneOrMany<string>>;
-export type HttpMethod = 'HEAD' | 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS';
-export declare function normalizeHttpValue(value: OneOrMany<HttpValue>): WritableOneOrMany<string>;
-export declare function normalizeSingleHttpValue(value: HttpValue): string;
-export declare function denormalizeHttpValue(value: OneOrMany<HttpValue>): OneOrMany<HttpValue>;
-export declare function denormlizeSingleHttpValue(value: HttpValue): HttpValue;

package/types/http/utils.d.ts

@@ -1,18 +0,0 @@
-import type { HttpHeaders } from '../../http/http-headers.js';
-import type { UndefinableJson } from '../../types.js';
-import type { AnyIterable } from '../../utils/any-iterable-iterator.js';
-type Body = Uint8Array | Blob | AnyIterable<Uint8Array> | ReadableStream<Uint8Array>;
-export type ReadBodyOptions = {
-    maxBytes?: number;
-};
-export type ReadBodyAsJsonOptions = ReadBodyOptions & {
-    fallbackToText?: boolean;
-};
-export declare function readBodyAsBinaryStream(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): ReadableStream<Uint8Array>;
-export declare function readBodyAsBuffer(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): Promise<Uint8Array>;
-export declare function readBodyAsText(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): Promise<string>;
-export declare function readBodyAsTextStream(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): ReadableStream<string>;
-export declare function readBodyAsJson(body: Body, headers: HttpHeaders, options?: ReadBodyAsJsonOptions): Promise<UndefinableJson>;
-export declare function readBody(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): Promise<string | UndefinableJson | Uint8Array>;
-export declare function readBodyAsStream(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): ReadableStream<string> | ReadableStream<Uint8Array>;
-export {};

package/types/image-service/imgproxy/imgproxy-image-service.d.ts

@@ -1,24 +0,0 @@
-import { resolveArgumentType } from '../../../injector/index.js';
-import type { Resolvable } from '../../../injector/interfaces.js';
-import type { ImageOptions } from '../image-service.js';
-import { ImageService } from '../image-service.js';
-export type ImgproxyImageServiceConfig = {
-    endpoint: string;
-    key: string;
-    salt: string;
-    signatureSize: number;
-};
-export declare const IMGPROXY_IMAGE_SERVICE_CONFIG: import("../../../injector/index.js").InjectionToken<ImgproxyImageServiceConfig, never>;
-export declare class ImgproxyImageService extends ImageService implements Resolvable<ImgproxyImageServiceConfig> {
-    #private;
-    readonly endpoint: string;
-    readonly [resolveArgumentType]: ImgproxyImageServiceConfig;
-    constructor(endpoint: string, key: string, salt: string, signatureSize: number);
-    getUrl(resourceUri: string, options?: ImageOptions): Promise<string>;
-}
-/**
- * configure imgproxy image service module
- * @param defaultConfig default configuration
- * @param register whether to register for {@link ImageService}
- */
-export declare function configureImgproxyImageService(defaultConfig: ImgproxyImageServiceConfig, register?: boolean): void;

package/types/injector/decorators.d.ts

@@ -1,82 +0,0 @@
-import { type Decorator } from '../../reflection/index.js';
-import type { Constructor, OneOrMany, Record, Simplify, TypedOmit } from '../../types.js';
-import type { Provider } from './provider.js';
-import type { InjectionToken } from './token.js';
-import type { InjectMetadata } from './type-info.js';
-import type { ArgumentProvider, ForwardRefInjectionToken, Mapper, RegistrationOptions } from './types.js';
-export type InjectDecorator = Decorator<'accessor' | 'constructorParameter'>;
-export type InjectableOptions<T, A, C extends Record = Record> = RegistrationOptions<T, A, C> & {
-    /** Aliases (tokens) for the class. Useful for example for circular dependencies when you can't use the class itself as a token */
-    alias?: OneOrMany<InjectionToken>;
-    /** Custom provider. Useful for example if initialization is required */
-    provider?: Provider<T, A, C>;
-};
-export type InjectableOptionsWithoutLifecycle<T, A> = Simplify<TypedOmit<InjectableOptions<T, A>, 'lifecycle'>>;
-/**
- * Helper decorator to replace a class definition with an other
- * can be used for example to type external classes with the {@link Resolvable} interface
- * @param constructor class to replace with
- */
-export declare function ReplaceClass<T>(constructor: Constructor<T>): ClassDecorator;
-/**
- * Globally registers the class for injection
- * @param options registration options
- */
-export declare function Injectable<T = any, A = any, C extends Record = Record>(options?: InjectableOptions<T, A, C>): ClassDecorator;
-/**
- * Registers the class in the global container with singleton lifecycle. Decorated class is not modified in any way
- * @param options registration options
- */
-export declare function Singleton<T = any, A = any>(options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
-/**
- * Registers the class in the global container with scoped lifecycle. Decorated class is not modified in any way
- * @param options registration options
- */
-export declare function Scoped<T = any, A = any>(lifecycle: 'resolution' | 'injector', options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
-/**
- * Sets the token used to resolve the parameter
- * @param token token used for resolving
- * @param argument resolve argument
- * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
- */
-export declare function Inject<T, A>(token?: InjectionToken<T, A>, argument?: A, mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
-/**
- * Sets the token used to resolve the parameter. Resolves all providers
- * @param token token used for resolving
- * @param argument resolve argument
- * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
- */
-export declare function InjectAll<T, A>(token?: InjectionToken<T, A>, argument?: A, mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
-/**
- * Sets the argument used for resolving the parameter
- * @param argument
- */
-export declare function ResolveArg<T>(argument: T): InjectDecorator;
-/**
- * Sets the argument provider used for resolving the parameter
- * @param argumentProvider
- */
-export declare function ResolveArgProvider<T>(argumentProvider: ArgumentProvider<T>): InjectDecorator;
-/**
- * Injects the argument used for resolving the class instead of resolving the parameter
- * @param argument
- * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
- */
-export declare function InjectArg<T>(mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
-/**
- * Sets the argument used for resolving the decorated parameter to the the argument provided for parent resolve
- * @param mapper map the argument (for example to select a property instead of forwarding the whole object)
- */
-export declare function ForwardArg(): InjectDecorator;
-export declare function ForwardArg<T, U>(mapper: Mapper<T, U>): InjectDecorator;
-/**
- * Marks the argument as optional
- * @param argument
- */
-export declare function Optional(): InjectDecorator;
-/**
- * Resolve using ForwardRef to handle circular dependencies. Resolve logic derefs all ForwardRefs which are direct properties of resolved instances automatically
- * @param token token to resolve
- * @param argument resolve argument
- */
-export declare function ForwardRef<T extends object, A>(token?: ForwardRefInjectionToken<T>, argument?: A, options?: Pick<InjectMetadata, 'forwardRefTypeHint'>): InjectDecorator;

package/types/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/types/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/types/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/types/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/types/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/types/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/types/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/types/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;
-};