export declare function pFinally<T>(promise: Promise<T> | (() => Promise<T>), onFinally?: () => void): Promise<T | (() => Promise<T>)>;
export declare const pReflect: <T>(promise: Promise<T>) => Promise<{
    isFulfilled: boolean;
    isRejected: boolean;
    value: T;
    reason?: undefined;
} | {
    isFulfilled: boolean;
    isRejected: boolean;
    reason: any;
    value?: undefined;
}>;
export declare const pTry: <TArgs, TResult>(fn: (...args: TArgs[]) => TResult, ...args: TArgs[]) => Promise<unknown>;
export declare const pLimit: (concurrency: number) => Promise<never> | (<T, TArgs extends any[]>(fn: () => Promise<T>, ...args: TArgs) => Promise<unknown>);
export declare const pSettle: <T>(promises: Promise<T>[], options?: {}) => Promise<TypeError | ({
    isFulfilled: boolean;
    isRejected: boolean;
    value: unknown;
    reason?: undefined;
} | {
    isFulfilled: boolean;
    isRejected: boolean;
    reason: any;
    value?: undefined;
})[]>;
declare type TheMapper<Element = any, NewElement = any> = (element: Element, index: number) => NewElement | PromiseLike<NewElement>;
export declare const pMap: <T, NewT>(iterable: Iterable<T>, mapper: TheMapper<T, NewT>, { concurrency, stopOnError }?: {
    concurrency?: number | undefined;
    stopOnError?: boolean | undefined;
}) => Promise<NewT[]>;
interface PMapOptions {
    concurrency?: number;
    stopOnError?: boolean;
}
declare type PromiseResult<Value> = Value extends PromiseLike<infer Result> ? Result : Value;
declare type Mapper<ValueType, KeyType, MappedValueType> = (value: ValueType, key: KeyType) => MappedValueType | PromiseLike<MappedValueType>;
export declare function pProps<KeyType, ValueType, MappedValueType = PromiseResult<ValueType>>(map: Map<KeyType, ValueType>, mapper?: Mapper<PromiseResult<ValueType>, KeyType, MappedValueType>, options?: PMapOptions): Promise<Map<KeyType, MappedValueType>>;
export {};