interface EventsMap {
    [event: string]: any;
}
interface DefaultEvents extends EventsMap {
    [event: string]: (...args: any) => void;
}
interface EventEmitter<Events extends EventsMap = DefaultEvents> {
    emit<K extends keyof Events>(this: this, event: K, ...args: Parameters<Events[K]>): void;
    events: Partial<{
        [E in keyof Events]: Events[E][];
    }>;
    on<K extends keyof Events>(this: this, event: K, cb: Events[K]): () => void;
}
type DefaultEmitter = EventEmitter<DefaultEvents>;
declare const createEvents: <Events extends EventsMap = DefaultEvents>() => EventEmitter<Events>;
interface CreateResolverOptions {
    emitter: DefaultEmitter;
    evaluate: () => void;
    eventId: string;
    failHandler?: Error | false;
    methodName: string;
    onFallback?: () => void;
}
declare const createResolver: ({ emitter, evaluate, eventId, failHandler, methodName, onFallback, }: CreateResolverOptions) => Promise<unknown>;

declare const createRandomId: (size?: number) => string;

declare const equals: (a: any, b: any) => boolean;

declare const noop: () => void;

declare const removeUndefinedKeys: (obj: Record<string, any>) => Record<string, any>;

declare const timeout: (ms: number, throwOnError?: boolean) => Promise<unknown>;

declare class NativeMethodError extends Error {
    constructor(methodName: string);
}
declare const deserializeError: (value: any, ErrorConstructor?: ErrorConstructor) => any;

export { type CreateResolverOptions, type DefaultEmitter, type DefaultEvents, type EventEmitter, NativeMethodError, createEvents, createRandomId, createResolver, deserializeError, equals, noop, removeUndefinedKeys, timeout };