import { HasMapStore } from "../map";
import { QuerySharedContext } from "./context";
export type QueryOptions = {
    readonly cacheMaxAge: number;
    readonly fetchingInterval: number;
    readonly disableCache: boolean;
};
export declare const defaultOptions: QueryOptions;
export type QueryError<E> = {
    status: number;
    statusText: string;
    message: string;
    data?: E;
};
export type QueryResponse<T> = {
    data: T;
    staled: boolean;
    local: boolean;
    timestamp: number;
};
export interface IObservableQuery<T = unknown, E = unknown> {
    isObserved: boolean;
    isStarted: boolean;
    response?: Readonly<QueryResponse<T>>;
    error?: Readonly<QueryError<E>>;
    isFetching: boolean;
    fetch(): Generator<unknown, any, any> | Promise<void>;
    waitResponse(): Promise<Readonly<QueryResponse<T>> | undefined>;
    waitFreshResponse(): Promise<Readonly<QueryResponse<T>> | undefined>;
}
/**
 * Base of the observable query classes.
 * This recommends to use the fetch to query the response.
 */
export declare abstract class ObservableQuery<T = unknown, E = unknown> implements IObservableQuery<T, E> {
    protected readonly sharedContext: QuerySharedContext;
    protected static suspectedResponseDatasWithInvalidValue: string[];
    protected static guessResponseTruncated(headers: any, data: string): boolean;
    protected readonly options: QueryOptions;
    private _response?;
    protected _isFetching: boolean;
    private _error?;
    private _isStarted;
    private stateQueue;
    private pendingOnStart;
    private readonly queryCanceler;
    private observedCount;
    private intervalId;
    protected baseURL: string;
    protected _url: string;
    protected constructor(sharedContext: QuerySharedContext, baseURL: string, url: string, options?: Partial<QueryOptions>);
    private becomeObserved;
    private becomeUnobserved;
    get isObserved(): boolean;
    private start;
    private stop;
    get isStarted(): boolean;
    private readonly intervalFetch;
    private postStart;
    protected onStart(): void | Promise<void>;
    protected onStop(): void;
    protected canFetch(): boolean;
    get isFetching(): boolean;
    fetch(): Generator<unknown, any, any>;
    get response(): Readonly<QueryResponse<T>> | undefined;
    get error(): Readonly<QueryError<E>> | undefined;
    protected loadStabledResponse(): Promise<boolean>;
    protected setResponse(response: Readonly<QueryResponse<T>>): void;
    protected setError(error: QueryError<E> | undefined): void;
    protected onReceiveResponse(_: Readonly<QueryResponse<T>>): void;
    private cancel;
    get url(): string;
    protected setUrl(url: string): void;
    /**
     * Wait the response and return the response without considering it is staled or fresh.
     */
    waitResponse(): Promise<Readonly<QueryResponse<T>> | undefined>;
    /**
     * Wait the response and return the response until it is fetched.
     */
    waitFreshResponse(): Promise<Readonly<QueryResponse<T>> | undefined>;
    protected getCacheKey(): string;
    protected fetchResponse(abortController: AbortController): Promise<{
        headers: any;
        data: T;
    }>;
    /**
     * Used for saving the last response to disk.
     * This should not make observable state changes.
     * @param response
     * @protected
     */
    protected saveResponse(response: Readonly<QueryResponse<T>>): Promise<void>;
}
export declare class ObservableQueryMap<T = unknown, E = unknown> extends HasMapStore<ObservableQuery<T, E>> {
    constructor(creater: (key: string) => ObservableQuery<T, E>);
}