export type Result<T, E = unknown> = {
    isSuccess: true;
    value: T;
} | {
    isSuccess: false;
    error: E;
};
/**
 * Runs a closure and wraps the return value in a Result<T>. The `isSuccess`
 * value is `false` if the close throws, otherwise it's `true`.
 */
export declare function Result<T>(block: () => T | Promise<T>): Promise<Result<T>>;
/**
 * The difference between this and `Promise.all` is that `Promise.all` rejects
 * when any promise rejects, and this resolves when all promises resolve _or_
 * reject.
 *
 * This function returns an array of results, each of which is either a success
 * result containing the resolved promise, or an error result containing the
 * value that was passed to `reject()`.
 *
 * This function itself never throws or rejects.
 */
export declare const allToResolveOrReject: <T>(promises: Promise<T>[]) => Promise<Result<T>[]>;
/**
 * Attach a dummy rejection handler to a promise and return the original
 * promise. Used to prevent unhandled rejections in the background.
 *
 * To use this, wrap any `async` or `Promise`-returning function with this
 * function and use it as you otherwise would.
 *
 * Calling this multiple times for the same promise should have no ill effect.
 *
 * @example
 * // Before
 * await fetch('https://hevy.com/blabla');
 *
 * // After
 * await handleRejection(fetch('https://hevy.com/blabla'));
 */
export declare const handleRejection: <T>(p: Promise<T>) => Promise<T>;
type Stage3MethodDecorator<T> = (value: (...args: any[]) => T, context: ClassMemberDecoratorContext) => (...args: any[]) => T;
export declare function _synchronized_3(queue: boolean): Stage3MethodDecorator<Promise<any>>;
export declare function _synchronized_3(queue: boolean, id: any): Stage3MethodDecorator<Promise<any>>;
export declare function _synchronized_3(value: (...args: any[]) => any, context: ClassMemberDecoratorContext): void;
type LegacyMethodDecorator<T> = (target: unknown, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<(...args: any[]) => T>) => void;
export declare function synchronized(queue: boolean): LegacyMethodDecorator<Promise<any>>;
export declare function synchronized(queue: boolean, id: any): LegacyMethodDecorator<Promise<any>>;
export declare function synchronized(target: unknown, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<any>>): void;
export declare abstract class LockError extends Error {
    abstract readonly propertyKey: string | symbol;
    abstract readonly lockId: unknown;
    protected constructor(...args: any);
}
export {};