API @deepkit/core

export class Timer {
    setTimeout(cb: () => void, timeout: number): any;
    /**
     * Clears all timers at once.
     */
    clear();
}

export class ProcessLock {
    constructor(public readonly id: string);
    async acquire(ttl: number = , timeout: number = );
    isLocked();
    tryLock(ttl: number = );
    unlock();
}

export class ProcessLocker {
    /**
     *
     * @param id
     * @param ttl optional defines when the times automatically unlocks.
     * @param timeout if after `timeout` seconds the lock isn't acquired, it throws an error.
     */
    async acquireLock(id: string, ttl: number = , timeout: number = ): Promise<ProcessLock>;
    async tryLock(id: string, ttl: number = ): Promise<ProcessLock | undefined>;
    isLocked(id: string): boolean;
}

export class Mutex {
    unlock(): void;
    async lock(): Promise<void>;
}

export class ParsedHost {
    host: string;
    port: number;
    unixSocket: string;
    get isUnixSocket(): boolean;
    get isHostname(): boolean;
    get hostWithIp(): string;
    toString(): string;
    getWebSocketUrl(secure: boolean = false);
    getHttpUrl(secure: boolean = false);
}

export class CompilerContext {
    readonly context;
    maxReservedVariable: number;
    /**
     * Code that is executed in the context, but before the actual function is generated.
     * This helps for example to initialize dynamically some context variables.
     */
    preCode: string;
    initialiseVariables: string[];
    config: {
        indent: boolean;
    };
    constructor(config: Partial<CompilerContext[]> = {});
    reserveName(name: string): string;
    set(values: {
        [name: string]: any;
    });
    /**
     * Returns always the same variable name for the same value.
     * The variable name should not be set afterwards.
     */
    reserveConst(value: any, name: string = ): string;
    reserveVariable(name: string = , value?: any): string;
    raw(functionCode: string): Function;
    build(functionCode: string, ...args: string[]): any;
    buildAsync(functionCode: string, ...args: string[]): Function;
}

export class EmitterEvent {
    readonly id;
    stopped;
    propagationStopped;
    /**
     * Stop propagating the event to subsequent event listeners.
     */
    stopPropagation();
    /**
     * Signal the emitter that you want to abort.
     * Subsequent event listeners will still be called.
     */
    stop();
}

export class EventEmitter<T extends EmitterEvent> {
    constructor(protected parent?: EventEmitter<any>);
    subscribe(callback: Subscriber<T>): EventSubscription;
    emit(event: T): void;
    hasSubscriptions(): boolean;
}

export class AsyncEventEmitter<T extends EmitterEvent> {
    constructor(protected parent?: AsyncEventEmitter<any>);
    subscribe(callback: AsyncSubscriber<T>): AsyncEventSubscription;
    async emit(event: T): Promise<void>;
    hasSubscriptions(): boolean;
}

new (...args: string[]) => Function

<T>(classTypeOrInstance: ClassType<T> | Object): string

<T>(classType: ClassType<T> | Object, propertyName: string): string

<T>(classType: ClassType<T>, target: { [k: string]: any; }): T

(obj: any): any

<T>(target: T): ClassType<T>

(value: any, depth?: number): string

<T>(value: object, newClass: ClassType<T>): T

(object: object, depth?: number): string

<T>(array: T[], item: T): number

(seconds: number): Promise<void>

<T>(v: T[]): T[]

<T>(value?: T[] | object | {}): boolean

<T>(array: T[] | { [key: string]: T; }): number

(v: { [key: string]: any; } | object): string | undefined

(v: { [key: string]: any; } | object): string | undefined

<T>(v: { [key: string]: T; } | T[]): T | undefined

<T>(v: { [key: string]: T; } | T[]): T | undefined

(array: number[]): number

(o: { [k: string]: any; }, prependText: string): { [k: string]: any; }

(origin: { [k: string]: any; }, extend: { [k: string]: any; }, prependKeyName?: string): void

<T>(executor: (resolve: (value: T) => void, reject: (error: any) => void) => void | Promise<void>): Promise<T>

<T>(promise: Promise<T>): Promise<T>

<T>(promise: Promise<T>, stack?: string): Promise<T>

(removeCallee?: boolean): string

(error: Error, stack: string): void

(error?: any, classType?: ClassType): Error

<T>(callback: (args: T[]) => void): (arg: T) => void

(bag: { [field: string]: any; }, parameterPath: string, defaultValue?: any): any

(bag: object, parameterPath: string, value: any): void

(bag: object, parameterPath: string): void

(bytes: number, si?: boolean): string

(obj: object): number

(classType: ClassType): ClassType | undefined

(classType: ClassType): ClassType[]

(): boolean

(name: string, base?: ClassType): ClassType

(value: Array<unknown> | Set<unknown> | Map<unknown, unknown>): number

(offset?: number): string

(): string

(string: string): string

(object: any, property: any): boolean

(startOrLength: number, stop?: number, step?: number): IterableIterator<number>

(startOrLength: number, stop?: number, step?: number): number[]

<T extends (readonly unknown[])[]>(...args: T): { [K in keyof T]: T[K] extends (infer V)[] ? V : never; }[]

(x: any, y: any): void

(error: any, withStack?: boolean): string

<T>(object: any, constructor: { new (...args: any[]): T; }): asserts object is T

<T>(value: T): asserts value is NonNullable<T>

(): (target: object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => PropertyDescriptor

(): (target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<any>>) => void

(): (target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<any>>) => void

(enumType: { [field: string]: any; }, id: any): any

(enumDefinition: any): string[]

(enumDefinition: any): any[]

(enumDefinition: any): Map<any, string>

(enumDefinition: any, value: any, allowLabelsAsValue?: boolean): boolean

(enumDefinition: any, value: any, allowLabelsAsValue?: boolean): any

(hostWithIpOrUnixPath: string): ParsedHost

(obj: any): void

(indentation: number, prefix?: string): (str?: string) => string

(string: string): string

(call: Function, cps?: number): (...args: any[]) => void

<T>(callback: (arg: T) => any): { activate: () => void; call: (i: T) => void; }

(cb: () => void) => any

(id: any) => any

(fn: string | Function | ClassType): string[]

(classCode: string, name: string): string

(code: string): string

(...path: string[]): string

<T>(array: T[], item: T): boolean

<T>(array: T[]): number

<T>(array: T[], item: T): boolean

<A extends T[], T>(array: A, item: T, move: number): A

(chunks: Uint8Array[], length?: number): Uint8Array

(buffer: string | Uint8Array): string

(base64: string): Uint8Array

(size: number) => Uint8Array<ArrayBufferLike>

(buffer: Uint8Array<ArrayBufferLike>) => any

(v: string) => Uint8Array<ArrayBufferLike>

(obj: any): obj is object

(target: any): boolean

(obj: any): obj is Function

(obj: any): obj is (...args: any[]) => Promise<any>

<T>(obj: any | Promise<T>): obj is Promise<T>

(obj: any): obj is AbstractClassType

(obj: any): obj is AbstractClassType

(obj: any): obj is { [key: string]: any; }

(obj: any): obj is { [key: string]: any; }

(obj: any): obj is null

(obj: any): obj is undefined

(obj: any): boolean

(obj: any): obj is number

(s: string | number): boolean

(obj: any): obj is string

(fn: any): boolean

(prototype: AbstractClassType | undefined, base: ClassType): boolean

(value: any): boolean

(obj: any) => obj is any[]

(obj: any) => obj is number

(path: string): string

(path: string): string

(path: string): string

(path: string): string

(path: string): string

(...paths: string[]): string

interface ClassType<T = any> {
    new(...args: any[]): T;
}

type AbstractClassType<T = any> = abstract new (...args: any[]) => T;

type ExtractClassType<T> = T extends AbstractClassType<infer K> ? K : never;

type AsyncEventSubscription = { unsubscribe: () => void };

type EventSubscription = { unsubscribe: () => void };

type TypeAnnotation<T extends string, Options = never> = unknown;

type InjectMeta<T = never> = TypeAnnotation<'inject', T>;

type Inject<Type, Token = never> = Type & InjectMeta<Token>;