export declare type UnpackPromise<T> = T extends Promise<infer U> ? U : T;
export declare type ArgumentType<F extends Function> = F extends (arg: infer A) => any ? A : never;
export declare type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any;
export declare class BifrostSubscription<T> {
    dispose: () => void;
    onData: (fn: (a: T) => void) => void;
    onError: (fn: (a: Error) => void) => void;
    nextData: (a: T, opts?: {
        ensureSequentialTimestamp?: number;
    }) => void;
    nextError: (e: Error) => void;
    constructor(p: SubProps<T>);
}
export declare type UnpackBifrostSubscription<T> = T extends BifrostSubscription<infer U> ? U : T;
export declare type BifrostInstance<FunctionsType extends Record<string, Function>> = {
    [K in keyof FunctionsType]: BifrostInstanceFn<ArgumentType<FunctionsType[K]>, UnpackPromise<ReturnType<FunctionsType[K]>>>;
};
export interface UseCacheFns {
    getCachedFnResult: (p: {
        key: string;
    }) => {
        cachedDateMS: number;
        value: any;
    } | void;
    setCachedFnResult: (p: {
        key: string;
        value: any;
    }) => void;
}
export declare type SubProps<T> = {
    dispose: () => void;
    onData: (fn: (a: T) => void) => void;
    onError: (fn: (a: Error) => void) => void;
    nextData: (a: T, opts?: {
        ensureSequentialTimestamp?: number;
    }) => void;
    nextError: (e: Error) => void;
};
export interface BifrostInstanceFn<ParamType, ResponseType> {
    getClientSubscription: (p: ParamType, options?: SubscriptionHelperOptions) => {
        subscribe: (fn: (p: {
            data: UnpackBifrostSubscription<ResponseType>;
            isFromCache: boolean;
        }) => void) => {
            unsubscribe: () => void;
        };
    };
    useClient: (p: ParamType, memoizationArr: any[], options?: HelperOptions) => {
        isLoading: boolean;
        error: Error;
        data: ResponseType | undefined;
        isFromCache: boolean;
    };
    fetchClient: (p: ParamType, options?: HelperOptions) => Promise<{
        data: ResponseType;
        isFromCache: boolean;
    }>;
    useClientSubscription: (p: ParamType, memoizationArr: any[], options?: SubscriptionHelperOptions) => {
        isLoading: boolean;
        error: Error;
        data: UnpackBifrostSubscription<ResponseType> | undefined;
        isFromCache: boolean;
    };
    useServer: (p: ParamType, memoizationArr: any[], options?: HelperOptions) => {
        isLoading: boolean;
        error: Error;
        data: ResponseType | undefined;
        isFromCache: boolean;
    };
    fetchServer: (p: ParamType, options?: HelperOptions) => Promise<{
        data: ResponseType;
        isFromCache: boolean;
    }>;
}
export declare type HttpProcessor = (p: {
    fnName: string;
    payload: any;
}) => Promise<any>;
export declare type Logger = (p: {
    fnName: string;
    details: any;
    error?: Error;
}) => any;
export interface HelperOptions {
    useCacheOnlyWithinMS?: number;
    disableCache?: boolean;
}
export interface SubscriptionHelperOptions {
    disableCache?: boolean;
}
//# sourceMappingURL=models.d.ts.map