import { ClassMethodDecorator } from "./decorators/types";
export interface AsyncLimiterState {
    readonly key: string;
    working: boolean;
    nextCallParams: any;
    nextCallTimer: any;
    last_call: number;
    initial_call: number;
    last_exec: number;
}
export interface LimiterFunction {
    (state: AsyncLimiterState): number;
}
interface GenericLimiterOptions<P extends any[] = any[]> {
    key_on?: number[] | ((params: P) => string);
    /** If using NodeJS, whether `unref()` should be called on any timers. Basically, if set to `true`, NodeJS will be allowed to exit without calling the function */
    unref?: boolean;
    limiter_logic: (options: any) => LimiterFunction;
}
type LimitableFunction = (...params: any[]) => void;
export declare const async_limiter: <T extends LimitableFunction>(options: GenericLimiterOptions, func: T) => {
    (...args: Parameters<T>): void;
    cancel_pending(...args: Parameters<T>): void;
};
export declare function limiter_decorator_combo<T extends (options: any) => LimiterFunction>(limiter: T): {
    <P extends any[]>(options: Parameters<T>[0] & Omit<GenericLimiterOptions<P>, "limiter_logic">): ClassMethodDecorator<any, (...p: P) => any>;
    <P_1 extends any[], T_1 extends (...params: P_1) => void>(options: Parameters<T>[0] & Omit<GenericLimiterOptions<P_1>, "limiter_logic">, func: T_1): {
        (...args: Parameters<T_1>): void;
        cancel_pending(...args: Parameters<T_1>): void;
    };
    limiting_logic: T;
};
/** First call goes through, next call waits until `interval` after the first call */
export declare const throttle: {
    <P extends any[]>(options: {
        interval: number;
    } & Omit<GenericLimiterOptions<P>, "limiter_logic">): ClassMethodDecorator<any, (...p: P) => any>;
    <P_1 extends any[], T extends (...params: P_1) => void>(options: {
        interval: number;
    } & Omit<GenericLimiterOptions<P_1>, "limiter_logic">, func: T): {
        (...args: Parameters<T>): void;
        cancel_pending(...args: Parameters<T>): void;
    };
    limiting_logic: ({ interval }: {
        interval: number;
    }) => LimiterFunction;
};
/** All calls are delayed until no call has been received for `timeToStability` (or until `maxTime` after the first call) */
export declare const debounce: {
    <P extends any[]>(options: {
        timeToStability: number;
        maxTime?: number;
    } & Omit<GenericLimiterOptions<P>, "limiter_logic">): ClassMethodDecorator<any, (...p: P) => any>;
    <P_1 extends any[], T extends (...params: P_1) => void>(options: {
        timeToStability: number;
        maxTime?: number;
    } & Omit<GenericLimiterOptions<P_1>, "limiter_logic">, func: T): {
        (...args: Parameters<T>): void;
        cancel_pending(...args: Parameters<T>): void;
    };
    limiting_logic: ({ timeToStability, maxTime }: {
        timeToStability: number;
        maxTime?: number;
    }) => LimiterFunction;
};
/** Debounce _then_ throttle - `debounce(throttle(X))` */
export declare const limit: {
    <P extends any[]>(options: {
        interval: number;
        timeToStability: number;
        maxTime?: number;
    } & Omit<GenericLimiterOptions<P>, "limiter_logic">): ClassMethodDecorator<any, (...p: P) => any>;
    <P_1 extends any[], T extends (...params: P_1) => void>(options: {
        interval: number;
        timeToStability: number;
        maxTime?: number;
    } & Omit<GenericLimiterOptions<P_1>, "limiter_logic">, func: T): {
        (...args: Parameters<T>): void;
        cancel_pending(...args: Parameters<T>): void;
    };
    limiting_logic: ({ interval, timeToStability, maxTime }: {
        interval: number;
        timeToStability: number;
        maxTime?: number;
    }) => LimiterFunction;
};
export {};