import { type Option } from "../Option";
import { type Result } from "../Result";
import type { Task } from "./Task";
/**
 *    |-----------------------|-------------------|
 *    | Rust methods          | Perlica           |
 *    |-----------------------|-------------------|
 *    | and                   | and               |
 *    | and_then              | flatMap           |
 *    | expect                | expect            |
 *    | filter                | filter            |
 *    | flatten               | flatten           |
 *    | inspect               | inspect           |
 *    | map                   | map               |
 *    | map_or                | mapOr             |
 *    | map_or_else           | mapOrElse         |
 *    | ok_or                 | okOr              |
 *    | ok_or_else            | okOrElse          |
 *    | or                    | or                |
 *    | or_else               | orElse            |
 *    | unwrap                | unwrap            |
 *    | unwrap_or             | unwrapOr          |
 *    | unwrap_or_else        | unwrapOrElse      |
 *    |                       | toResult          |
 *    |                       | of                |
 *    |                       | safeRun           |
 *    |-----------------------|-------------------|
 */
export declare const of: <T>(value: T) => Task<T>;
export declare const map: <A, B>(f: (a: A) => B) => (task: Task<A>) => Task<B>;
export declare const flatMap: <A, B>(f: (a: A) => Task<B>) => (task: Task<A>) => Task<B>;
export declare const flatten: <T>(task: Task<Task<T>>) => Task<T>;
export declare const okOr: <E>(error: E) => <T>(task: Task<T>) => Task<Result<T, E>>;
export declare const okOrElse: <E>(f: () => E) => <T>(task: Task<T>) => Task<Result<T, E>>;
export declare const and: <B>(that: Task<B>) => <A>(task: Task<A>) => Task<B>;
export declare const expect: (msg: string) => <T>(task: Task<T>) => Task<T>;
export declare const filter: <T>(f: (v: T) => boolean) => (task: Task<T>) => Task<Option<T>>;
export declare const inspect: <T>(f: (v: T) => void) => (task: Task<T>) => Task<T>;
export declare const mapOr: <A, B>(def: B, f: (a: A) => B) => (task: Task<A>) => Task<B>;
export declare const mapOrElse: <A, B>(d: () => B, f: (a: A) => B) => (task: Task<A>) => Task<B>;
export declare const or: <A>(that: Task<A>) => (task: Task<A>) => Task<A>;
export declare const orElse: <A>(f: () => Task<A>) => (task: Task<A>) => Task<A>;
export declare const unwrap: <T>(task: Task<T>) => Task<T>;
export declare const unwrapOr: <A>(def: A) => (task: Task<A>) => Task<A>;
export declare const unwrapOrElse: <A>(f: () => A) => (task: Task<A>) => Task<A>;
export declare const toResult: <T>(task: Task<T>) => Task<Result<T, unknown>>;
export declare const safeRun: <T>(task: Task<T>) => Promise<Result<T, unknown>>;
export declare const bind: <T extends Task<any>, R>(fn: () => Generator<T, R>) => Task<R>;