fp-ts-zio/lib/ZIO.d.ts

fp-ts bindings for Scala ZIO

import { Alt3 } from 'fp-ts/lib/Alt';
import { Bifunctor3 } from 'fp-ts/lib/Bifunctor';
import * as Et from 'fp-ts/lib/Either';
import { Monad3 } from 'fp-ts/lib/Monad';
import { MonadTask3 } from 'fp-ts/lib/MonadTask';
import { MonadThrow3 } from 'fp-ts/lib/MonadThrow';
import * as O from 'fp-ts/lib/Option';
import * as TE from 'fp-ts/lib/TaskEither';
import TaskEither = TE.TaskEither;
import Either = Et.Either;
declare module 'fp-ts/lib/HKT' {
    interface URItoKind3<R, E, A> {
        ZIO: ZIO<R, E, A>;
    }
}
export declare const URI = "ZIO";
export declare type URI = typeof URI;
export declare type ZIO<R, E, A> = (r: R) => TaskEither<E, A>;
export declare const zio: Monad3<URI> & Bifunctor3<URI> & Alt3<URI> & MonadTask3<URI> & MonadThrow3<URI>;
export declare const zioSeq: typeof zio;
declare function foldM<R, E, A, B>(onError: (e: E) => ZIO<R, never, B>, onSuccess: (a: A) => ZIO<R, never, B>): (ma: ZIO<R, E, A>) => ZIO<R, never, B>;
declare function fold<R, E, A, B>(onError: (e: E) => B, onSuccess: (a: A) => B): (ma: ZIO<R, E, A>) => ZIO<R, never, B>;
declare function getOrElseM<R, E, A>(onError: (e: E) => ZIO<R, never, A>): (ma: ZIO<R, E, A>) => ZIO<R, never, A>;
declare function orElse<R, E, A, M>(onError: (e: E) => ZIO<R, M, A>): (ma: ZIO<R, E, A>) => ZIO<R, M, A>;
/**
 * Maps the success value of this effect to the specified constant value.
 */
declare function as<B>(b: B): <R, E, A>(ma: ZIO<R, E, A>) => ZIO<R, E, B>;
/**
 * Maps the error value of this effect to the specified constant value.
 */
declare function asError<E1>(e1: E1): <R, E, A>(ma: ZIO<R, E, A>) => ZIO<R, E1, A>;
/**
 * Make sure that a resource is cleaned up in the event of an exception. The
 * release action is called regardless of whether the body action throws or
 * returns.
 */
declare function bracket<R, E, A, B>(acquire: ZIO<R, E, A>, use: (a: A) => ZIO<R, E, B>, release: (a: A, e: Either<E, B>) => ZIO<R, E, void>): ZIO<R, E, B>;
export interface ZIORef<A> {
    get: ZIO<any, never, A>;
    set: (a: A) => ZIO<any, never, void>;
    update: (f: (a: A) => A) => ZIO<any, never, void>;
}
export declare const newZIORef: <A>(initial: A) => ZIORef<A>;
export declare function swap<R, E, A>(ma: ZIO<R, E, A>): ZIO<R, A, E>;
export declare const ZIO: {
    unsafeRun: <R>(r: R) => <E, A>(ma: ZIO<R, E, A>) => Promise<Et.Either<E, A>>;
    run: <R_1>(r: R_1) => <A_1>(ma: ZIO<R_1, never, A_1>) => Promise<A_1>;
    succeed: <R_2 = any, E_1 = never, A_2 = never>(a: A_2) => ZIO<R_2, E_1, A_2>;
    fail: <R_3 = any, E_2 = never, A_3 = never>(e: E_2) => ZIO<R_3, E_2, A_3>;
    succeedLazy: <R_4 = any, E_3 = never, A_4 = never>(ma: () => A_4) => ZIO<R_4, E_3, A_4>;
    failLazy: <R_5 = any, E_4 = never, A_5 = never>(me: () => E_4) => ZIO<R_5, E_4, A_5>;
    succeedPromise: <R_6 = any, E_5 = never, A_6 = never>(ma: () => Promise<A_6>) => ZIO<R_6, E_5, A_6>;
    failPromise: <R_7 = any, E_6 = never, A_7 = never>(me: () => Promise<E_6>) => ZIO<R_7, E_6, A_7>;
    tryCatch: <R_8 = any, E_7 = never, A_8 = never>(f: () => Promise<A_8>, onRejected: (reason: unknown) => E_7) => ZIO<any, E_7, A_8>;
    fromTaskEither: <R_9 = any, E_8 = never, A_9 = never>(ma: TE.TaskEither<E_8, A_9>) => ZIO<R_9, E_8, A_9>;
    fromOption: <E_9>(onNone: () => E_9) => <R_10, A_10>(ma: O.Option<A_10>) => ZIO<R_10, E_9, A_10>;
    fromEither: <R_11, E_10, A_11>(ma: Et.Either<E_10, A_11>) => ZIO<R_11, E_10, A_11>;
    fromPredicate: {
        <E_11, A_12, B extends A_12>(refinement: import("fp-ts/lib/function").Refinement<A_12, B>, onFalse: (a: A_12) => E_11): <U>(a: A_12) => ZIO<U, E_11, B>;
        <E_12, A_13>(predicate: import("fp-ts/lib/function").Predicate<A_13>, onFalse: (a: A_13) => E_12): <R_12>(a: A_13) => ZIO<R_12, E_12, A_13>;
    };
    filterOrElse: {
        <E_13, A_14, B_1 extends A_14>(refinement: import("fp-ts/lib/function").Refinement<A_14, B_1>, onFalse: (a: A_14) => E_13): <R_13>(ma: ZIO<R_13, E_13, A_14>) => ZIO<R_13, E_13, B_1>;
        <E_14, A_15>(predicate: import("fp-ts/lib/function").Predicate<A_15>, onFalse: (a: A_15) => E_14): <R_14>(ma: ZIO<R_14, E_14, A_15>) => ZIO<R_14, E_14, A_15>;
    };
    map: <A_16, B_2>(f: (a: A_16) => B_2) => <R_15, E_15>(fa: ZIO<R_15, E_15, A_16>) => ZIO<R_15, E_15, B_2>;
    bimap: <E_16, G, A_17, B_3>(f: (e: E_16) => G, g: (a: A_17) => B_3) => <R_16>(fa: ZIO<R_16, E_16, A_17>) => ZIO<R_16, G, B_3>;
    mapError: <E_17, G_1>(f: (e: E_17) => G_1) => <R_17, A_18>(fa: ZIO<R_17, E_17, A_18>) => ZIO<R_17, G_1, A_18>;
    flatMap: <R_18, E_18, A_19, B_4>(f: (a: A_19) => ZIO<R_18, E_18, B_4>) => (ma: ZIO<R_18, E_18, A_19>) => ZIO<R_18, E_18, B_4>;
    orElse: typeof orElse;
    foldM: typeof foldM;
    fold: typeof fold;
    getOrElseM: typeof getOrElseM;
    getOrElse: <R_19, E_19, A_20>(onError: (e: E_19) => A_20) => (ma: ZIO<R_19, E_19, A_20>) => ZIO<R_19, never, A_20>;
    cached: <R_20, E_20, A_21>(ma: ZIO<R_20, E_20, A_21>) => ZIO<R_20, E_20, A_21>;
    tap: <R_21, E_21, A_22>(onSuccess: (a: A_22) => ZIO<R_21, E_21, any>) => (ma: ZIO<R_21, E_21, A_22>) => ZIO<R_21, E_21, A_22>;
    tapError: <R_22, E_22, A_23>(onError: (e: E_22) => ZIO<R_22, E_22, any>) => (ma: ZIO<R_22, E_22, A_23>) => ZIO<R_22, E_22, A_23>;
    tapBoth: <R_23, E_23, A_24>(onError: (e: E_23) => ZIO<R_23, E_23, any>, onSuccess: (a: A_24) => ZIO<R_23, E_23, any>) => (ma: ZIO<R_23, E_23, A_24>) => ZIO<R_23, E_23, A_24>;
    bracket: typeof bracket;
    as: typeof as;
    asError: typeof asError;
    asVoid: <R_24, E_24, A_25>(ma: ZIO<R_24, E_24, A_25>) => ZIO<R_24, E_24, void>;
    asErrorVoid: <R_25, E_25, A_26>(ma: ZIO<R_25, E_25, A_26>) => ZIO<R_25, void, A_26>;
    accessM: <R_26>() => <E_26, A_27>(f: (r: R_26) => ZIO<R_26, E_26, A_27>) => ZIO<R_26, E_26, A_27>;
    access: <R_27>() => <A_28>(f: (r: R_27) => A_28) => ZIO<R_27, never, A_28>;
    environment: <R_28>() => ZIO<R_28, never, R_28>;
    provide: <R_29, E_27, A_29>(r: R_29) => (ma: ZIO<R_29, E_27, A_29>) => ZIO<any, E_27, A_29>;
    zip: <R_30, E_28, T extends ZIO<R_30, E_28, any>[]>(...t: T & {
        0: ZIO<R_30, E_28, any>;
    }) => ZIO<R_30, E_28, { [K in keyof T]: [T[K]] extends [ZIO<R_30, E_28, infer A_30>] ? A_30 : never; }>;
    zipPar: <R_30, E_28, T extends ZIO<R_30, E_28, any>[]>(...t: T & {
        0: ZIO<R_30, E_28, any>;
    }) => ZIO<R_30, E_28, { [K in keyof T]: [T[K]] extends [ZIO<R_30, E_28, infer A_30>] ? A_30 : never; }>;
    zipWith: <R_31, E_29, B_5>(mb: ZIO<R_31, E_29, B_5>) => <A_31>(ma: ZIO<R_31, E_29, A_31>) => ZIO<R_31, E_29, [A_31, B_5]>;
    sequence: <R_32, E_30, A_32>(ta: ZIO<R_32, E_30, A_32>[]) => ZIO<R_32, E_30, A_32[]>;
    sequencePar: <R_32, E_30, A_32>(ta: ZIO<R_32, E_30, A_32>[]) => ZIO<R_32, E_30, A_32[]>;
    swap: typeof swap;
    succeedVoid: ZIO<any, never, void>;
    failVoid: ZIO<any, void, never>;
    either: <R_33, E_31, A_33>(ma: ZIO<R_33, E_31, A_33>) => ZIO<R_33, never, Et.Either<E_31, A_33>>;
    option: <R_34, E_32, A_34>(ma: ZIO<R_34, E_32, A_34>) => ZIO<R_34, never, O.Option<A_34>>;
    nullable: <R_35, E_33, A_35>(ma: ZIO<R_35, E_33, A_35>) => ZIO<R_35, never, A_35 | null>;
    undefined: <R_36, E_34, A_36>(ma: ZIO<R_36, E_34, A_36>) => ZIO<R_36, never, A_36 | undefined>;
    absolve: <R_37, E_35, A_37>(ma: ZIO<R_37, never, Et.Either<E_35, A_37>>) => ZIO<R_37, E_35, A_37>;
    absolveOption: <R_38, E_36, A_38>(onNone: () => E_36) => (ma: ZIO<R_38, never, O.Option<A_38>>) => ZIO<R_38, E_36, A_38>;
    absolveNullable: <R_39, E_37, A_39>(onNull: () => E_37) => (ma: ZIO<R_39, never, A_39 | null>) => ZIO<R_39, E_37, A_39>;
    absolveUndefined: <R_40, E_38, A_40>(onUndefined: () => E_38) => (ma: ZIO<R_40, never, A_40 | null>) => ZIO<R_40, E_38, A_40>;
};
export {};