import type { EventEmitter } from 'events';
import type { CallOptions, CallOptionsFactory } from '../base/options';
import type { CallContext, IServices } from './iapi';
export declare const zeroKey: Buffer<ArrayBuffer>;
export declare const emptyKey: Buffer<ArrayBuffer>;
export declare function toBuffer(input: string | Buffer | number): Buffer;
export declare function endRangeForPrefix(prefix: Buffer): Buffer;
export declare class NSApplicator {
    private readonly prefix;
    static readonly default: NSApplicator;
    private endRange;
    constructor(prefix: Buffer);
    applyKey(buf?: Buffer): Buffer<ArrayBufferLike> | undefined;
    applyRangeEnd(buf?: Buffer): Buffer<ArrayBufferLike> | undefined;
    applyToRequest<T extends {
        key?: Buffer;
        range_end?: Buffer;
    }>(req: T): T;
    unprefix(buf: Buffer): Buffer;
}
export declare function minBy<T>(items: T[], prop: (x: T) => number): T[];
export declare function sample<T>(items: T[]): T;
export declare function delay(duration: number): Promise<void>;
export declare function forOwn<T extends object>(obj: T, iterator: <K extends keyof T>(value: T[K], key: K) => void): void;
export declare function onceEvent(emitter: EventEmitter, ...events: string[]): Promise<any>;
export declare function debounce(duration: number, fn: () => void): {
    (): void;
    cancel(): void;
};
export declare abstract class PromiseWrap<T> implements PromiseLike<T> {
    then<R, V>(onFulfilled: (value: T) => R | Promise<R>, onRejected?: (err: any) => V | Promise<V>): Promise<R | V>;
    catch<R>(onRejected: (err: any) => R | Promise<R>): Promise<T | R>;
    protected abstract createPromise(): Promise<T>;
}
export interface ICallContext {
    service: keyof IServices;
    method: string;
    params: unknown;
}
export declare const resolveCallOptions: (callOptions: CallOptions | undefined, defaultOptions: undefined | CallOptionsFactory, context: CallContext) => CallOptions | undefined;
export interface IDeferred<T> {
    resolve: (value: T) => void;
    reject: (error: unknown) => void;
    promise: Promise<T>;
}
export declare const getDeferred: <T>() => {
    promise: Promise<T>;
    res: (value: T) => void;
    rej: (error: unknown) => void;
};