import { Task } from './Task';
import { Either } from './Either';
/**
 * Represents an asynchronous computation that can fail with `L` or succeed with `R`.
 * 非同期計算を表し、失敗時は `L`、成功時は `R` を返します。
 */
export type TaskEither<L, R> = {
    readonly isTaskEither: true;
    /**
     * Maps the `Right` value with the provided function.
     * 右側の値に関数を適用します。
     * @param fn - A function to transform the `Right` value. / `Right` の値を変換する関数。
     */
    readonly map: <U>(fn: (value: R) => U) => TaskEither<L, U>;
    /**
     * Alias of `map`.
     * `map` のエイリアス。
     * @param fn - A function to transform the `Right` value. / `Right` の値を変換する関数。
     */
    readonly "<$>": <U>(fn: (value: R) => U) => TaskEither<L, U>;
    /**
     * Applies a function inside `Right` to a value inside another `TaskEither`.
     * 右側に入った関数を別の `TaskEither` の右側の値に適用します。
     * @param boxValue - A `TaskEither` containing the value. / 値を含む `TaskEither`。
     */
    readonly apply: <A, B>(this: TaskEither<L, (a: A) => B>, boxValue: TaskEither<L, A>) => TaskEither<L, B>;
    /**
     * Alias of `apply`.
     * `apply` のエイリアス。
     * @param boxValue - A `TaskEither` containing the value. / 値を含む `TaskEither`。
     */
    readonly "<*>": <A, B>(this: TaskEither<L, (a: A) => B>, boxValue: TaskEither<L, A>) => TaskEither<L, B>;
    /**
     * Binds the `Right` value to the next computation.
     * 右側の値を次の計算へ渡します。
     * @param fn - A function returning `TaskEither`. / `TaskEither` を返す関数。
     */
    readonly flatMap: <U>(fn: (value: R) => TaskEither<L, U>) => TaskEither<L, U>;
    /**
     * Alias of `flatMap`.
     * `flatMap` のエイリアス。
     * @param fn - A function returning `TaskEither`. / `TaskEither` を返す関数。
     */
    readonly ">>=": <U>(fn: (value: R) => TaskEither<L, U>) => TaskEither<L, U>;
    /**
     * Runs the computation and returns a Promise of `Either<L, R>`.
     * 計算を実行し、`Either<L, R>` の `Promise` を返します。
     */
    readonly run: () => Promise<Either<L, R>>;
    /**
     * Returns the underlying `Task<Either<L, R>>` value.
     * 内部の `Task<Either<L, R>>` を返します。
     */
    readonly toTask: () => Task<Either<L, R>>;
    /**
     * Pattern matches on `Left` or `Right` asynchronously, returning a `Task<U>`.
     * `Left` または `Right` をパターンマッチし、`Task<U>` を返します。
     * @param onLeft - Handler for `Left`. / `Left` の処理関数。
     * @param onRight - Handler for `Right`. / `Right` の処理関数。
     */
    readonly match: <U>(onLeft: (l: L) => U, onRight: (r: R) => U) => Task<U>;
};
/**
 * Adapter type for Do's `$` parameter.
 * `$` は `yield* $(TaskEither.right(...))` のためのアダプタ関数です。
 */
export type $TaskEither<L> = <A>(fa: TaskEither<L, A>) => Generator<any, A, any>;
/**
 * Creates a `TaskEither` from a `Task<Either<L, R>>`.
 * `Task<Either<L, R>>` から `TaskEither<L, R>` を作成します。
 * @param fa - A task producing an Either. / `Either` を生成する `Task`。
 */
declare const from: <L, R>(fa: Task<Either<L, R>>) => TaskEither<L, R>;
/**
 * Lifts a value into `TaskEither` as `Right`.
 * 値を `Right` として `TaskEither` に持ち上げます。
 * @param value - The value to lift. / 持ち上げる値。
 */
declare const right: <L, R>(value: R) => TaskEither<L, R>;
/**
 * Lifts an error into `TaskEither` as `Left`.
 * エラーを `Left` として `TaskEither` に持ち上げます。
 * @param value - The error value. / エラー値。
 */
declare const left: <L, R = never>(value: L) => TaskEither<L, R>;
/**
 * Lifts a `Task<R>` into `TaskEither<L, R>` as `Right`.
 * `Task<R>` を `Right` として `TaskEither<L, R>` に持ち上げます。
 * @param task - The task to lift. / 持ち上げる `Task`。
 */
declare const fromTask: <L, R>(task: Task<R>) => TaskEither<L, R>;
/**
 * Lifts an `Either<L, R>` into `TaskEither<L, R>`.
 * `Either<L, R>` を `TaskEither<L, R>` に持ち上げます。
 * @param e - The either to lift. / 持ち上げる `Either`。
 */
declare const fromEither: <L, R>(e: Either<L, R>) => TaskEither<L, R>;
/**
 * Runs TaskEithers in parallel and combines results.
 * If any result is Left, returns the first Left (by array order) after all complete.
 * 複数の TaskEither を並列実行し、結果を結合します。1つでも Left があれば、配列順で最初の Left を返します（全完了後判定）。
 * @param tasks - TaskEithers to run in parallel. / 並列実行する TaskEither 配列。
 */
declare const all: <L, R>(tasks: readonly TaskEither<L, R>[]) => TaskEither<L, R[]>;
/**
 * Runs TaskEithers in parallel and returns all raw results without short-circuiting.
 * Promise.all に類似し、全件の `Either` を `Task` で返します（ショートサーキットなし）。
 * @param tasks - TaskEithers to run in parallel. / 並列実行する TaskEither 配列。
 */
declare const allSettled: <L, R>(tasks: readonly TaskEither<L, R>[]) => Task<Either<L, R>[]>;
/**
 * Partitions results into lefts and rights without short-circuiting.
 * 結果を Left/Right に仕分けして返します（ショートサーキットなし）。
 * @param tasks - TaskEithers to run in parallel. / 並列実行する TaskEither 配列。
 */
declare const partition: <L, R>(tasks: readonly TaskEither<L, R>[]) => Task<[L[], R[]]>;
/**
 * Validates all TaskEithers: accumulates all errors if any, otherwise returns all successes.
 * すべて成功すれば `Right(values[])`、1件以上失敗があれば `Left(errors[])` を返します。
 * @param tasks - TaskEithers to run in parallel. / 並列実行する TaskEither 配列。
 */
declare const validateAll: <L, R>(tasks: readonly TaskEither<L, R>[]) => TaskEither<L[], R[]>;
/**
 * Traverses an array with a TaskEither-returning function and sequences the results.
 * 配列の各要素に関数を適用し、`TaskEither` を順に合成します。
 * @param as - Input array. / 入力配列。
 * @param f - Mapping function returning TaskEither. / TaskEither を返す関数。
 */
declare const traverse: <L, A, B>(as: readonly A[], f: (a: A) => TaskEither<L, B>) => TaskEither<L, B[]>;
/**
 * Sequences a record of TaskEithers into a TaskEither of record.
 * レコードの TaskEither を、同構造の値のレコードへ順序付けします。
 * @param obj - A record of TaskEithers. / TaskEither のレコード。
 */
declare const struct: <L, T extends Record<string, TaskEither<L, any>>>(obj: T) => TaskEither<L, { [K in keyof T]: T[K] extends TaskEither<L, infer R> ? R : never; }>;
/**
 * Creates a `TaskEither` that runs the computation, capturing thrown/rejected errors as `Left` via `onError`.
 * 計算を実行し、投げられた/拒否されたエラーを `onError` で `Left` に変換します。
 */
declare const tryCatch: <L, R>(fn: () => R | Promise<R>, onError: (error: any) => L) => TaskEither<L, R>;
/**
 * Type guard to check if a value is `TaskEither`.
 * 値が `TaskEither` かどうかを判定します。
 */
declare const isTaskEither: <L, R>(value: any) => value is TaskEither<L, R>;
declare function Do<L, R, U>(generatorFunc: () => Generator<TaskEither<L, R>, U | TaskEither<L, U>, R>): TaskEither<L, U>;
declare function Do<L, R>(g: ($: <A>(fa: TaskEither<L, A>) => Generator<any, A, any>) => Generator<any, R, any>): TaskEither<L, R>;
/**
 * Utility object for `TaskEither` constructors and helpers.
 * `TaskEither` のコンストラクタとヘルパーをまとめたユーティリティ。
 */
export declare const TaskEither: {
    do: typeof Do;
    from: typeof from;
    pack: typeof right;
    right: typeof right;
    left: typeof left;
    all: typeof all;
    allSettled: typeof allSettled;
    partition: typeof partition;
    validateAll: typeof validateAll;
    traverse: typeof traverse;
    struct: typeof struct;
    fromTask: typeof fromTask;
    fromEither: typeof fromEither;
    tryCatch: typeof tryCatch;
    isTaskEither: typeof isTaskEither;
};
export {};