import { BehaviorSubject, Observable } from 'rxjs';
import { IProstoreSsrContext } from './IProstoreSsrContext';
import { BehaviorStore } from './BehaviorStore';
import { SubscriptionManager } from './SubscriptionManager';
export interface IRequestState<Vars, Data> {
    /** Request result */
    data: Data | null;
    /** Whether the request is ongoing */
    loading: boolean;
    /** Whether the request has been completed at least once */
    loaded: boolean;
    /** If request errored out, holds the error */
    error: any;
    /** Latest variables used for requesting the data */
    variables: Vars | null;
}
export declare const initialRequestState: IRequestState<any, any>;
export declare type ISkipQueryFn<Vars, Data> = (vars: Vars) => Data | null | undefined;
export declare type IUpdateDataFn<Vars, Data> = (data: Data | null, oldData: Data | null, params: {
    store: any;
    variables: Vars;
    options: any;
}) => Data | null;
export interface IVariablesSubjectType<Vars, Options> {
    variables: Vars;
    options?: Options;
}
export interface IRxRequestStoreParams<Vars, Data, Options> {
    /** Initial data to be held in the store state as the request result */
    initialData?: Data | null;
    /**
     * This function may be used to skip the request based on the variable values.
     *
     * It should return undefined if the request should go as usual.
     * If something else is returned, the request is skipped and the result of the function
     * is saved as the store state.
     */
    skipQuery?: ISkipQueryFn<Vars, Data>;
    /**
     * This function may be used to customize the store state after the request is completed.
     *
     * It accepts new request result, old saved data and request params and should return
     * new data to be saved in the store state.
     *
     * Can be used for paginated requests (see example in the docs)
     */
    updateData?: IUpdateDataFn<Vars, Data>;
    /** Global SsrContext which contains states of all stores */
    ssrContext?: IProstoreSsrContext | null;
    /** Store identifier which is used to store data in the SsrContext */
    ssrId?: string | null;
    /** Observable which provides variables and options to the request */
    variables$?: Observable<IVariablesSubjectType<Vars, Options>>;
}
export interface IRequestStoreOptions<Vars = any, Data = any> {
    /** Optional state overrides */
    changeState?: Partial<IRequestState<Vars, Data>>;
}
export declare type IObservableData<Data> = Promise<Data> | Observable<Data>;
export declare type IVariablesObservable<Vars, Options> = Observable<IVariablesSubjectType<Vars, Options>> | undefined;
export declare class RxRequestStore<Vars = any, Data = any, Options extends IRequestStoreOptions<Vars, Data> = any> extends BehaviorStore<IRequestState<Vars, Data>> {
    /** Identifies the store in the SsrContext */
    ssrId?: string | null;
    /** SsrContext to be used in the SSR-enabled environments */
    ssrContext?: IProstoreSsrContext | null;
    /** Subject which holds the variables Observable */
    variables$$: BehaviorSubject<IVariablesObservable<Vars, Options>>;
    /** Observable of the request state */
    state$: BehaviorSubject<IRequestState<Vars, Data>>;
    /** Skip query callback. See docs for IRequestStoreParams */
    protected skipQuery: ISkipQueryFn<Vars, Data>;
    /** Update data callback. See docs for IRequestStoreParams */
    protected updateData: IUpdateDataFn<Vars, Data>;
    /** Indicates whether the request data was loaded from SsrContext */
    protected loadedValueFromContext: boolean;
    /** Tracks all subscriptions during onSubscribe and cancels them in onUnsubscribe */
    _sub: SubscriptionManager;
    constructor({ initialData, skipQuery, ssrId, updateData, ssrContext, variables$ }: IRxRequestStoreParams<Vars, Data, Options>);
    get state(): IRequestState<Vars, Data>;
    set state(newValue: IRequestState<Vars, Data>);
    setVariables$(variables$: IVariablesObservable<Vars, Options>): void;
    onSubscribe(): void;
    onUnsubscribe(): void;
    projectVariables: (variables$: IVariablesObservable<Vars, Options>) => Observable<IRequestState<Vars, Data>>;
    projectRequest: ({ variables, options: optionsProp }: IVariablesSubjectType<Vars, Options>) => Observable<Partial<IRequestState<Vars, Data>>>;
    performSkippableRequest(variables: Vars, options: Options): IObservableData<Data | null>;
    performRequest(variables: Vars, options: Options): IObservableData<Data | null>;
    mapRequestResult: (variables: Vars, options: Options) => (data: Data) => IRequestState<Vars, Data>;
    handleError: (error: any) => Partial<IRequestState<Vars, Data>>;
    tryLoadContextState(): void;
    updateContextState(state?: IRequestState<Vars, Data>): void;
    registerSsrPromise(promise: Promise<IRequestState<Vars, Data>>): void;
}
export declare type GetRxRequestStoreVars<Store> = Store extends RxRequestStore<infer Vars, any, any> ? Vars : never;
export declare type GetRxRequestStoreData<Store> = Store extends RxRequestStore<any, infer Data, any> ? Data : never;
export declare type GetRxRequestStoreOptions<Store> = Store extends RxRequestStore<any, any, infer Options> ? Options : never;
export declare type GetRxRequestStoreState<Store> = IRequestState<GetRxRequestStoreVars<Store>, GetRxRequestStoreData<Store>>;