import { Effect, Mappable, UnboxPromise } from "./types";
export interface ErrorLog<T> {
    _: <U>(f: Mappable<T, U>) => ErrorLog<U>;
    effect: (f: Effect<T>) => ErrorLog<T>;
    try: <U>(f: Mappable<T, U>, alt: U) => ErrorLog<U>;
    getErrors: () => Error[];
    getValue: () => T;
    getValueOr: <U>(alt: U) => NonNullable<T> | U;
    hasErrors: () => boolean;
}
export interface FutureErrorLog<T> {
    _: <U>(f: Mappable<T, U>) => FutureErrorLog<U>;
    effect: (f: Effect<T>) => FutureErrorLog<T>;
    try: <U>(f: Mappable<T, U>, alt: UnboxPromise<U>) => FutureErrorLog<U>;
    getErrors: () => Promise<Error[]>;
    getValue: () => Promise<UnboxPromise<T>>;
    getValueOr: <U extends T>(alt: U) => Promise<NonNullable<UnboxPromise<T>>>;
    hasErrors: () => Promise<boolean>;
}
export declare const errorLogged: <T>(value: T) => {
    _: <U>(f: Mappable<T, U>) => {
        _: <U_1>(f: Mappable<U, U_1>) => {
            _: <U_2>(f: Mappable<U_1, U_2>) => {
                _: <U_3>(f: Mappable<U_2, U_3>) => {
                    _: <U_4>(f: Mappable<U_3, U_4>) => {
                        _: <U_5>(f: Mappable<U_4, U_5>) => {
                            _: <U_6>(f: Mappable<U_5, U_6>) => {
                                _: <U_7>(f: Mappable<U_6, U_7>) => {
                                    _: <U_8>(f: Mappable<U_7, U_8>) => {
                                        _: <U_9>(f: Mappable<U_8, U_9>) => {
                                            _: <U_10>(f: Mappable<U_9, U_10>) => any;
                                            try: <U_11>(f: Mappable<U_9, U_11>, alt: U_11) => ErrorLog<U_11>;
                                            effect: (f: Effect<U_9>) => ErrorLog<U_9>;
                                            getErrors: () => Error[];
                                            getValue: () => U_9;
                                            getValueOr: <U_12>(alt: U_9 | U_12) => U_12 | NonNullable<U_9>;
                                            hasErrors: () => boolean;
                                        };
                                        try: <U_13>(f: Mappable<U_8, U_13>, alt: U_13) => ErrorLog<U_13>;
                                        effect: (f: Effect<U_8>) => ErrorLog<U_8>;
                                        getErrors: () => Error[];
                                        getValue: () => U_8;
                                        getValueOr: <U_14>(alt: U_8 | U_14) => U_14 | NonNullable<U_8>;
                                        hasErrors: () => boolean;
                                    };
                                    try: <U_15>(f: Mappable<U_7, U_15>, alt: U_15) => ErrorLog<U_15>;
                                    effect: (f: Effect<U_7>) => ErrorLog<U_7>;
                                    getErrors: () => Error[];
                                    getValue: () => U_7;
                                    getValueOr: <U_16>(alt: U_7 | U_16) => U_16 | NonNullable<U_7>;
                                    hasErrors: () => boolean;
                                };
                                try: <U_17>(f: Mappable<U_6, U_17>, alt: U_17) => ErrorLog<U_17>;
                                effect: (f: Effect<U_6>) => ErrorLog<U_6>;
                                getErrors: () => Error[];
                                getValue: () => U_6;
                                getValueOr: <U_18>(alt: U_6 | U_18) => U_18 | NonNullable<U_6>;
                                hasErrors: () => boolean;
                            };
                            try: <U_19>(f: Mappable<U_5, U_19>, alt: U_19) => ErrorLog<U_19>;
                            effect: (f: Effect<U_5>) => ErrorLog<U_5>;
                            getErrors: () => Error[];
                            getValue: () => U_5;
                            getValueOr: <U_20>(alt: U_5 | U_20) => U_20 | NonNullable<U_5>;
                            hasErrors: () => boolean;
                        };
                        try: <U_21>(f: Mappable<U_4, U_21>, alt: U_21) => ErrorLog<U_21>;
                        effect: (f: Effect<U_4>) => ErrorLog<U_4>;
                        getErrors: () => Error[];
                        getValue: () => U_4;
                        getValueOr: <U_22>(alt: U_4 | U_22) => U_22 | NonNullable<U_4>;
                        hasErrors: () => boolean;
                    };
                    try: <U_23>(f: Mappable<U_3, U_23>, alt: U_23) => ErrorLog<U_23>;
                    effect: (f: Effect<U_3>) => ErrorLog<U_3>;
                    getErrors: () => Error[];
                    getValue: () => U_3;
                    getValueOr: <U_24>(alt: U_3 | U_24) => U_24 | NonNullable<U_3>;
                    hasErrors: () => boolean;
                };
                try: <U_25>(f: Mappable<U_2, U_25>, alt: U_25) => ErrorLog<U_25>;
                effect: (f: Effect<U_2>) => ErrorLog<U_2>;
                getErrors: () => Error[];
                getValue: () => U_2;
                getValueOr: <U_26>(alt: U_2 | U_26) => U_26 | NonNullable<U_2>;
                hasErrors: () => boolean;
            };
            try: <U_27>(f: Mappable<U_1, U_27>, alt: U_27) => ErrorLog<U_27>;
            effect: (f: Effect<U_1>) => ErrorLog<U_1>;
            getErrors: () => Error[];
            getValue: () => U_1;
            getValueOr: <U_28>(alt: U_1 | U_28) => U_28 | NonNullable<U_1>;
            hasErrors: () => boolean;
        };
        try: <U_29>(f: Mappable<U, U_29>, alt: U_29) => ErrorLog<U_29>;
        effect: (f: Effect<U>) => ErrorLog<U>;
        getErrors: () => Error[];
        getValue: () => U;
        getValueOr: <U_30>(alt: U | U_30) => U_30 | NonNullable<U>;
        hasErrors: () => boolean;
    };
    try: <U_31>(f: Mappable<T, U_31>, alt: U_31) => ErrorLog<U_31>;
    effect: (f: Effect<T>) => ErrorLog<T>;
    getErrors: () => Error[];
    getValue: () => T;
    getValueOr: <U_32>(alt: T | U_32) => U_32 | NonNullable<T>;
    hasErrors: () => boolean;
};
export declare const errorLoggedFuture: <T>(value: T) => FutureErrorLog<T>;