/**
 * `Op<A, E, R>` — `Effect.Effect` wrapper with named factories.
 *
 * @module
 */
import type { Scope, Result } from 'effect';
import { Effect } from 'effect';
import { IoError } from '@czap/error';
import type { Millis } from './brands.js';
interface OpShape<A, E = never, R = never> {
    readonly _tag: 'Op';
    readonly effect: Effect.Effect<A, E, R>;
    run(): Effect.Effect<A, E, R | Scope.Scope>;
    map<B>(f: (a: A) => B): OpShape<B, E, R>;
    flatMap<B, E2, R2>(f: (a: A) => OpShape<B, E2, R2>): OpShape<B, E | E2, R | R2>;
}
type OpValue<T extends OpShape<unknown, unknown, unknown>> = T extends OpShape<infer A, unknown, unknown> ? A : never;
type OpError<T extends OpShape<unknown, unknown, unknown>> = T extends OpShape<unknown, infer E, unknown> ? E : never;
type OpRequirement<T extends OpShape<unknown, unknown, unknown>> = T extends OpShape<unknown, unknown, infer R> ? R : never;
type OpValues<T extends readonly OpShape<unknown, unknown, unknown>[]> = {
    [K in keyof T]: OpValue<T[K]>;
};
type SettledOpValues<T extends readonly OpShape<unknown, unknown, unknown>[]> = {
    [K in keyof T]: Result.Result<OpValue<T[K]>, OpError<T[K]>>;
};
/**
 * Op -- Effect.Effect wrapper providing named factories and combinators
 * for async operations with retry, timeout, race, and parallel execution.
 *
 * @example
 * ```ts
 * const op = Op.succeed(42).map(n => n * 2);
 * const result = Effect.runSync(op.run()); // 84
 *
 * const tasks = Op.all([Op.succeed(1), Op.succeed(2)] as const);
 * const [a, b] = Effect.runSync(tasks.run()); // [1, 2]
 * ```
 */
export declare const Op: {
    make: <A, E = never, R = never>(effect: Effect.Effect<A, E, R>) => OpShape<A, E, R>;
    fromPromise: <A>(f: () => Promise<A>) => OpShape<A, Error>;
    succeed: <A>(value: A) => OpShape<A>;
    fail: <E>(error: E) => OpShape<never, E>;
    all: <T extends readonly OpShape<unknown, unknown, unknown>[]>(tasks: T) => OpShape<OpValues<T>, OpError<T[number]>, OpRequirement<T[number]>>;
    allSettled: <T extends readonly OpShape<unknown, unknown, unknown>[]>(tasks: T) => OpShape<SettledOpValues<T>, never, OpRequirement<T[number]>>;
    race: <A, E, R>(tasks: ReadonlyArray<OpShape<A, E, R>>) => OpShape<A, E | Error, R>;
    retry: <A, E, R>(task: OpShape<A, E, R>, options: {
        times: number;
        delay?: Millis;
        factor?: number;
    }) => OpShape<A, E, R>;
    timeout: <A, E, R>(task: OpShape<A, E, R>, ms: Millis) => OpShape<A, E | IoError, R>;
};
export declare namespace Op {
    /** Structural shape of an {@link Op}: a thin alias over `Effect.Effect<A, E, R>` produced by the `Op.*` factories. */
    type Shape<A, E = never, R = never> = OpShape<A, E, R>;
}
export {};
//# sourceMappingURL=op.d.ts.map