/**
 * Binds all methods of an object to this object
 * @param  {any} self - object reference
 */
export declare const autoBind: (self: any) => void;

export declare type Cancelable<T> = Executed<T> | Canceled<T>;

declare type Canceled<T> = {
    type: 'canceled';
    prevValue?: T;
};

declare type Context = {
    checkCanceled: () => boolean;
    executeCount: number;
};

export declare function debounce<ResT, ArgsT extends any[]>(fn: (...args: ArgsT) => ResT, time: number, memoLastResult?: boolean): ResultFunction<ResT, ArgsT>;

export declare function debounceWithTeardown<ResT, ArgsT extends any[]>(fn: (...args: ArgsT) => ResT, time: number, memoLastResult?: boolean): TeardownTuple<ResT, ArgsT>;

export declare function deepFreeze<T extends Record<any, any>>(o: T): T;

declare type EmitterHandler<PayloadT> = (payload: PayloadT) => void;

declare type EventId = {
    eventId: number;
};

declare type Executed<T> = {
    type: 'executed';
    value: T;
    prevValue?: T;
};

export declare function getterAndSetter<T>(initValue: T): [() => T, (newValue: T) => void];

export declare interface IEmitEvent<T> {
    emit(data: T): void;
}

export declare interface IEvent<T> extends ISubscribeEvent<T>, IEmitEvent<T> {
}

export declare interface IExecuteHandler<ParamsT, ResT> {
    execute(params: ParamsT): Promise<ResT>;
}

export declare function ignoreFirstArg<ResT, ArgsT extends any[]>(fn: (...args: ArgsT) => ResT): (_first: any, ...args: ArgsT) => ResT;

export declare interface IHandler<ParamsT, ResT> extends IRegiterHandler<ParamsT, ResT>, IExecuteHandler<ParamsT, ResT> {
}

export declare interface IReadState<T> {
    get(): T;
    subscribe(callback: SubscribeCallback<T>): UnsubscribeFunction;
}

export declare interface IRegiterHandler<ParamsT, ResT> {
    regiter(handler: (params: ParamsT) => ResT | Promise<ResT>): () => void;
}

export declare interface IState<T> extends IReadState<T>, IWriteState<T> {
}

export declare interface IStopwatchPerformance {
    now(): number;
}

export declare interface ISubscribeEvent<T> {
    on(handler: (data: T) => void): () => void;
    off(handler: (data: T) => void): void;
    once(handler: (data: T) => void): () => void;
}

export declare interface IWriteState<T> {
    set(newValue: T): void;
}

/**
 * Binds all methods of an class to this class
 * @example class SomeClass extends LiteAutoBind
 */
export declare abstract class LiteAutoBind {
    constructor();
}

export declare class LiteCache<T> extends LiteAutoBind {
    private readonly _get;
    private readonly _set;
    constructor(_get: () => Promise<string | null>, _set: (value: string) => Promise<void>);
    setCache(value: T): Promise<void>;
    getCache(maxDiffMs: number): Promise<T | null>;
    getCacheIgnoringMaxDiffMs(): Promise<T | null>;
}

export declare class LiteCancelableWaiting {
    private resolve;
    private reject;
    private promise;
    private timer;
    constructor();
    wait(delay: number): Promise<void>;
    cancel(): void;
}

export declare class LiteCanceledError implements Error {
    name: string;
    message: string;
    stack?: string;
    constructor(message?: string);
}

/**
 * @deprecated use nextCancelsPrev instead
 */
export declare class LiteCancellationOperation<ParamsT, ResultT> extends LiteAutoBind {
    private readonly name;
    private readonly operation;
    private readonly writeLog;
    private cancelToken;
    private executeCount;
    private working;
    get executing(): boolean;
    constructor(name: string, operation: (params: ParamsT, cancelToken: LiteCancellationToken, executeCount: number) => Promise<ResultT>, writeLog?: (text: string) => void);
    doOperation(params: ParamsT): Promise<ResultT>;
}

export declare class LiteCancellationToken {
    private canceled;
    readonly onCanceled: LiteEvent<void>;
    get isCanceled(): boolean;
    cancel(): void;
    throwIfCanceled(): void;
}

export declare class LiteEndlesslyTimer extends LiteAutoBind {
    private readonly fun;
    private readonly timeMs;
    private readonly params;
    private _tmId;
    private _started;
    constructor(fun: () => void, timeMs: number, params: TimerParams_2);
    start(): void;
    stop(): void;
    restart(): void;
    private _createTimeout;
    private _run;
}

export declare class LiteEvent<T> extends LiteAutoBind implements IEvent<T> {
    private readonly params;
    private handlers;
    private onceHandlers;
    constructor(params?: {
        quiet: boolean;
    });
    on(handler: (data: T) => void): () => void;
    off(handler: (data: T) => void): void;
    private execute;
    emit(data: T): void;
    once(handler: (data: T) => void): () => void;
    unsubscribeAll(): void;
}

export declare class LiteEventEmitter<EventsT extends Record<string, any>> extends LiteAutoBind {
    private readonly params;
    constructor(params?: {
        quiet: boolean;
    });
    readonly onEmit: LiteEvent<{
        eventName: string;
        payload: any;
    }>;
    private readonly _handlersMap;
    private readonly _onceHandlersMap;
    on<E extends keyof EventsT>(eventName: E, handler: EmitterHandler<EventsT[E]>): () => void;
    once<E extends keyof EventsT>(eventName: E, handler: EmitterHandler<EventsT[E]>): () => void;
    off<E extends keyof EventsT>(eventName: E, handler: (payload: EventsT[E]) => void): void;
    emit<E extends keyof EventsT>(eventName: E, event: EventsT[E]): void;
    emit<E extends keyof EventsT>(eventName: undefined extends EventsT[E] ? E : never): void;
    unsubscribeAll(): void;
    private _unsubscribe;
    private _subscribe;
    private _execute;
}

export declare class LiteHandler<ParamsT, ResT> extends LiteAutoBind implements IHandler<ParamsT, ResT> {
    private eventId;
    protected readonly requestEvent: LiteEvent<RequestParams<ParamsT>>;
    protected readonly responseEvent: LiteEvent<ResponseParams<ResT>>;
    regiter(handler: (params: ParamsT) => ResT | Promise<ResT>): () => void;
    execute(params: ParamsT): Promise<ResT>;
}

export declare class LitePromise<T> extends LiteAutoBind {
    private _resolve;
    private _reject;
    readonly instance: Promise<T>;
    get resolve(): Resolve<T>;
    get reject(): Reject;
    constructor();
}

export declare class LiteRepeatTimer extends LiteAutoBind {
    private readonly fun;
    private readonly timeMs;
    private readonly params;
    private _tmId;
    private _runCount;
    private _started;
    get runCount(): number;
    constructor(fun: () => void, timeMs: number | RangeTimes, params: TimerParams_4);
    start(): void;
    stop(): void;
    restart(): void;
    private _createTimeout;
    private _run;
}

export declare class LiteRetryTimer extends LiteAutoBind {
    private readonly fun;
    private readonly timeMs;
    private readonly params;
    private _tmId;
    private _runCount;
    private _started;
    get runCount(): number;
    constructor(fun: () => void, timeMs: number | RangeTimes, params: TimerParams_3);
    start(): void;
    stop(): void;
    restart(): void;
    private _createTimeout;
    private _run;
}

export declare class LiteSlider<SlideT> extends LiteAutoBind {
    private slides;
    private index;
    constructor(slides: SlideT[]);
    /**
     * Get current position
     * @returns number Current position
     */
    get position(): number;
    /**
     * Get current slide
     * @returns any Current slide
     */
    get current(): SlideT | null;
    /**
     * Return current slide and then go to the next slide
     * After that current slide will be next
     * @returns any Current slide
     */
    next(): SlideT | null;
    /**
     * Set slides position to 0
     */
    reset(): void;
    /**
     * Set slides position
     * @param  {number} position
     */
    set(position: number): void;
}

export declare class LiteState<T> extends LiteAutoBind implements IState<T> {
    private value;
    private subscribers;
    constructor(initValue: T);
    get(): T;
    set(newValue: T): void;
    subscribe(callback: SubscribeCallback<T>): UnsubscribeFunction;
}

export declare class LiteStopwatch extends LiteAutoBind {
    private performance;
    private pausedTime;
    private startTime;
    private _elapsedTime;
    private stoped;
    private paused;
    constructor(performance?: IStopwatchPerformance);
    get elapsedTime(): number;
    start(): void;
    clear(): void;
    restart(): void;
    pause(): number;
    private _calcElapsedTime;
    stop(): number;
}

export declare class LiteTimer extends LiteAutoBind {
    private readonly fun;
    private readonly timeMs;
    private readonly params?;
    private _tmId;
    constructor(fun: () => void, timeMs: number, params?: TimerParams | undefined);
    start(): void;
    stop(): void;
    restart(): void;
    private _run;
}

export declare function nextCancelsPrev<ResT, ArgsT extends any[]>(fn: (ctx: Context, ...args: ArgsT) => ResT, memoLastResult?: boolean): ResultFunction<ResT, ArgsT>;

export declare function nextCancelsPrevWithTeardown<ResT, ArgsT extends any[]>(fn: (ctx: Context, ...args: ArgsT) => ResT, memoLastResult?: boolean): TeardownTuple<ResT, ArgsT>;

export declare function nextWaitsPrev<ResT, ArgsT extends any[]>(fn: (...args: ArgsT) => ResT, memoLastResult?: boolean): ResultFunction<ResT, ArgsT>;

export declare function nextWaitsPrevWithTeardown<ResT, ArgsT extends any[]>(fn: (...args: ArgsT) => ResT, memoLastResult?: boolean): TeardownTuple<ResT, ArgsT>;

export declare function noThrow<T extends any[]>(fn: (...args: T) => void): (...args: T) => void;

/**
 * Performs left-to-right function composition. The first argument may have any arity, the remaining arguments must be unary.
 *
 * @example
 * import { pipeFn } from 'lite-utility/function'
 *
 * const len = (s: string): number => s.length
 * const double = (n: number): number => n * 2
 *
 * const f = pipeFn(len, double)
 *
 * assert.strictEqual(f('aaa'), 6)
 *
 */
export declare function pipeFn<A extends ReadonlyArray<unknown>, B>(ab: (...a: A) => B): (...a: A) => B;

export declare function pipeFn<A extends ReadonlyArray<unknown>, B, C>(ab: (...a: A) => B, bc: (b: B) => C): (...a: A) => C;

export declare function pipeFn<A extends ReadonlyArray<unknown>, B, C, D>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...a: A) => D;

export declare function pipeFn<A extends ReadonlyArray<unknown>, B, C, D, E>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): (...a: A) => E;

export declare function pipeFn<A extends ReadonlyArray<unknown>, B, C, D, E, F>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): (...a: A) => F;

export declare function pipeFn<A extends ReadonlyArray<unknown>, B, C, D, E, F, G>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): (...a: A) => G;

export declare function pipeFn<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H): (...a: A) => H;

export declare function pipeFn<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H, I>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I): (...a: A) => I;

export declare function pipeFn<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H, I, J>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J): (...a: A) => J;

export declare function promisifyFn<R, T extends any[]>(fn: (...args: T) => R | Promise<R>): (...args: T) => Promise<R>;

declare type RangeTimes = Record<number, number>;

declare type ReceiveError = EventId & {
    type: 'error';
    name: string | null;
    message: string;
    payload: any | null;
};

declare type ReceiveResult<T> = EventId & {
    type: 'result';
    result: T;
};

declare type Reject = (reason?: any) => void;

export declare type ReplaceEmitEvents<PresenterT> = ReplaceKeyTypes<PresenterT, LiteEvent<any>, IEmitEvent<any>>;

declare type ReplaceKeyTypes<Type, OldKeyType, NewKeyType> = {
    [Key in keyof Type]: Type[Key] extends OldKeyType ? NewKeyType : Type[Key];
};

export declare type ReplaceSubscribeEvents<PresenterT> = ReplaceKeyTypes<PresenterT, LiteEvent<any>, ISubscribeEvent<any>>;

declare type RequestParams<T> = EventId & {
    params: T;
};

declare type Resolve<T> = (value: T | PromiseLike<T>) => void;

declare type ResponseParams<T> = ReceiveError | ReceiveResult<T>;

declare type ResultFunction<ResT, ArgsT extends any[]> = (...args: ArgsT) => Promise<Cancelable<Awaited<ResT>>>;

export declare function runFn<U, T extends any[]>(args: T, fn: (...args: T) => U): U;

export declare function runNoThrow(fn: () => void): void;

declare type SubscribeCallback<T> = (newValue: T) => void;

declare type TeardownTuple<ResT, ArgsT extends any[]> = [ResultFunction<ResT, ArgsT>, () => void];

export declare function throttle<ResT, ArgsT extends any[]>(fn: (...args: ArgsT) => ResT, time: number, memoLastResult?: boolean): ResultFunction<ResT, ArgsT>;

export declare function throttleWithTeardown<ResT, ArgsT extends any[]>(fn: (...args: ArgsT) => ResT, time: number, memoLastResult?: boolean): TeardownTuple<ResT, ArgsT>;

declare type TimerParams = {
    logError?: (...args: any[]) => void;
};

declare type TimerParams_2 = {
    instantStart: boolean;
    logError?: (...args: any[]) => void;
};

declare type TimerParams_3 = {
    instantStart: boolean;
    maxTryCount: number;
    logError?: (...args: any[]) => void;
};

declare type TimerParams_4 = {
    instantStart: boolean;
    runCount: number;
    logError?: (...args: any[]) => void;
};

export declare function tryCatch<U, T extends any[]>(fn: (...args: T) => U, onCatch: (err: unknown) => U): (...args: T) => U;

declare type UnsubscribeFunction = () => void;

export declare function wait(delay: number): Promise<void>;

export declare function withStopwatch<U, T extends any[]>(fn: (...args: T) => U, onElapsedTime: (elapsedTime: number) => void): (...args: T) => U | void;

export { }