export declare type ResultHandlers<T, S = void> = {
    success: (res: T) => S;
    invalid: (details: ValidErrorDetails) => S;
    denied: (details: AuthErrorDetails) => S;
    unreachable: () => S;
    error: (res: string) => S;
};
export declare type PreResultHandlers = {
    loading?: () => void;
};
export declare type FutureResultHandlers<T> = ResultHandlers<T> & PreResultHandlers;
export interface FutureResult<T> {
    promise(): Promise<Result<T>>;
    then<S>(fun: (res: Result<T>) => S | PromiseLike<S>): Promise<S>;
    handle(handlers: FutureResultHandlers<T>): void;
}
export declare function futureResultFromPromise<T>(promise: Promise<Result<T>>): FutureResult<T>;
export declare abstract class Result<T> {
    res: ADT.Result<T>;
    protected constructor(res: ADT.Result<T>);
    handle(handlers: ResultHandlers<T>): void;
    match<S>(handlers: ResultHandlers<T, S>): S;
    isSuccess(): boolean;
    isError(): boolean;
}
export declare class Success<T> extends Result<T> {
    constructor(response: T);
}
export declare class ValidError extends Result<never> {
    constructor(details: ValidErrorDetails);
}
export declare class AuthError extends Result<never> {
    constructor(details: AuthErrorDetails);
}
export declare class InternalError extends Result<never> {
    constructor(errorMsg: string);
}
export declare class UnreachableError extends Result<never> {
    constructor();
}
export declare type ValidErrorDetails = {
    errorCodes: string[];
};
export declare type AuthErrorDetails = {};
declare namespace ADT {
    type Result<T> = Success<T> | ValidError | AuthError | InternalError | UnreachableError;
    interface Success<T> {
        kind: "success";
        success: true;
        response: T;
    }
    interface ValidError {
        kind: "validation-error";
        success: false;
        details: ValidErrorDetails;
    }
    interface AuthError {
        kind: "authentication-error";
        success: false;
        details: AuthErrorDetails;
    }
    interface InternalError {
        kind: "internal-error";
        success: false;
        errorMsg: string;
    }
    interface UnreachableError {
        kind: "unreachable-error";
        success: false;
    }
}
export {};