import Future from './Future';
declare const symbol: unique symbol;
export declare abstract class Result<T = undefined, E = unknown> {
	abstract is_ok(): this is OkResult<T, E>;
	abstract is_err(): this is ErrResult<T, E>;
	abstract unwrap(): T;
	abstract into(): T | E;
	abstract map<Ook, Oerr = E>(
		ok: (value: T) => Ook,
		err?: (error: E) => Oerr
	): Result<Ook, Oerr>;
	abstract map_async<Ook, Oerr = E>(
		ok: (value: T) => Ook | PromiseLike<Ook>,
		err?: (error: E) => Oerr | PromiseLike<Oerr>
	): FutureResult<Ook, Oerr>;
	abstract map_err<Oerr>(err: (error: E) => Oerr): Result<T, Oerr>;
	abstract map_err_async<Oerr>(
		err: (error: E) => Oerr | PromiseLike<Oerr>
	): FutureResult<T, Oerr>;
	abstract toJSON():
		| {
				ok: T;
		  }
		| {
				error: E;
		  };
	protected abstract [symbol]: T | E;
	static unwrap<T>(result: T | Result<T>): T;
	static from<T, E = never>(value: T | Result<T, E>): Result<T, unknown>;
	static try<T>(cb: () => T): Result<T, unknown>;
	abstract or<A>(value: A): T | A;
	abstract or_else<A>(err: (error: E) => A): T | A;
	abstract or_else_async<A>(
		err: (error: E) => A | PromiseLike<A>
	): Future<T | A>;
	abstract map_or<Ook, A>(ok: (value: T) => Ook, value: A): Ook | A;
	abstract map_or_else<Ook, A>(
		ok: (value: T) => Ook,
		err: (error: E) => A
	): Ook | A;
	map_or_async<Ook, A>(
		ok: (value: T) => Ook | PromiseLike<Ook>,
		value: A | PromiseLike<A>
	): Future<Ook | A>;
	map_or_else_async<Ook, A>(
		ok: (value: T) => Ook | PromiseLike<Ook>,
		err: (error: E) => A | PromiseLike<A>
	): Future<Ook | A>;
}
export declare class OkResult<T = undefined, E = unknown> extends Result<T, E> {
	protected [symbol]: T;
	constructor(value: T);
	is_ok(): this is OkResult<T, E>;
	is_err(): this is ErrResult<T, E>;
	unwrap(): T;
	into(): T;
	map<Ook, Oerr = E>(
		ok: (value: T) => Ook,
		_err?: (error: E) => Oerr
	): OkResult<Ook, Oerr>;
	map_async<Ook, Oerr = E>(
		ok: (value: T) => Ook | PromiseLike<Ook>,
		_err?: (error: E) => Oerr | PromiseLike<Oerr>
	): FutureResult<Ook, Oerr>;
	map_err<Oerr>(_err: (error: E) => Oerr): OkResult<T, Oerr>;
	map_err_async<Oerr>(
		_err: (error: E) => Oerr | PromiseLike<Oerr>
	): FutureResult<T, Oerr>;
	toJSON(): {
		ok: T;
	};
	or(): T;
	or_else(): T;
	or_else_async<A>(): Future<T | A>;
	map_or<Ook, A>(ok: (value: T) => Ook): Ook | A;
	map_or_else<Ook, A>(ok: (value: T) => Ook): Ook | A;
}
export declare class ErrResult<T = undefined, E = unknown> extends Result<
	T,
	E
> {
	protected [symbol]: E;
	constructor(error: E);
	is_ok(): this is OkResult<T, E>;
	is_err(): this is ErrResult<T, E>;
	unwrap(): never;
	into(): E;
	map<Ook, Oerr = E>(
		_ok: (value: T) => Ook,
		err?: (error: E) => Oerr
	): Result<Ook, Oerr>;
	map_async<Ook, Oerr = E>(
		_ok: (value: T) => Ook | PromiseLike<Ook>,
		err?: (error: E) => Oerr | PromiseLike<Oerr>
	): FutureResult<Ook, Oerr>;
	map_err<Oerr>(err: (error: E) => Oerr): Result<T, Oerr>;
	map_err_async<Oerr>(
		err: (error: E) => Oerr | PromiseLike<Oerr>
	): FutureResult<T, Oerr>;
	toJSON(): {
		error: E;
	};
	or<A>(value: A): A;
	or_else<A>(err: (error: E) => A): A;
	or_else_async<A>(err: (error: E) => A | PromiseLike<A>): Future<T | A>;
	map_or<Ook, A>(_ok: (value: T) => Ook, value: A): Ook | A;
	map_or_else<Ook, A>(_ok: (value: T) => Ook, err: (error: E) => A): Ook | A;
}
export declare class FutureResult<T, E = unknown> extends Future<Result<T, E>> {
	constructor(resolver: () => T | PromiseLike<T>);
	map_async<Ook, Oerr = E>(
		ok: (value: T) => Ook | PromiseLike<Ook>,
		err?: (error: E) => Oerr | PromiseLike<Oerr>
	): FutureResult<Ook, Oerr>;
	map_err_async<Oerr>(
		err: (error: E) => Oerr | PromiseLike<Oerr>
	): FutureResult<T, Oerr>;
	unwrap(): Future<T>;
	or<A>(value: A | PromiseLike<A>): Future<T | A>;
	or_else<A>(err: (error: E) => A): Future<T | A>;
	or_else_async<A>(err: (error: E) => A | PromiseLike<A>): Future<T | A>;
	map_or<Ook, A>(
		ok: (value: T) => Ook,
		value: A | PromiseLike<A>
	): Future<Ook | A>;
	map_or_else<Ook, A>(
		ok: (value: T) => Ook,
		err: (error: E) => A
	): Future<Ook | A>;
	map_or_async<Ook, A>(
		ok: (value: T) => Ook | PromiseLike<Ook>,
		value: A | PromiseLike<A>
	): Future<Ook | A>;
	map_or_else_async<Ook, A>(
		ok: (value: T) => Ook | PromiseLike<Ook>,
		err: (error: E) => A | PromiseLike<A>
	): Future<Ook | A>;
}
export type OkFactory = <T, E = never>(value: T) => OkResult<T, E>;
export type ErrFactory = <T = never, E = void>(error: E) => ErrResult<T, E>;
export declare const Ok: typeof OkResult & OkFactory & (() => OkResult);
export declare const Err: typeof ErrResult & ErrFactory & (() => ErrResult);
export default Result;