import { OrderedMap } from "immutable";
import { BasicUpdater, Updater } from "../fun/domains/updater/state";
import { AsyncState } from "../async/state";
import { Unit } from "../fun/domains/unit/state";
import { BasicFun } from "../fun/state";
export type StreamingStatus = "reload" | "loadMore" | false;
type Identifiable = {
    Id: string;
};
export type StreamPosition = {
    chunkSize: number;
    chunkIndex: number;
    shouldLoad: StreamingStatus;
    lastModifiedTime: number;
};
export declare const StreamPosition: {
    Default: (initialChunkSize: number, shouldLoad?: StreamingStatus) => StreamPosition;
    Updaters: {
        Template: {
            loadInitial: () => Updater<StreamPosition>;
            changeChunkSize: (chunkSize: number) => Updater<StreamPosition>;
            reload: () => Updater<StreamPosition>;
            loadMore: () => Updater<StreamPosition>;
        };
        Core: {
            chunkSize: import("../../main").Widening<StreamPosition, "chunkSize">;
            chunkIndex: import("../../main").Widening<StreamPosition, "chunkIndex">;
            shouldLoad: import("../../main").Widening<StreamPosition, "shouldLoad">;
            lastModifiedTime: import("../../main").Widening<StreamPosition, "lastModifiedTime">;
        };
        Coroutine: {};
    };
};
export type Chunk<Element extends Identifiable> = {
    hasMoreValues: boolean;
    data: OrderedMap<Element["Id"], Element>;
};
export declare const Chunk: <Element extends Identifiable>() => {
    Default: (hasMoreValues: boolean, data: OrderedMap<Element["Id"], Element>) => Chunk<Element>;
};
export type InfiniteStreamState<Element extends Identifiable> = {
    loadingMore: AsyncState<Unit>;
    loadedElements: OrderedMap<StreamPosition["chunkIndex"], Chunk<Element>>;
    position: StreamPosition;
    getChunk: BasicFun<[StreamPosition], Promise<Chunk<Element>>>;
};
export declare const InfiniteStreamState: <Element extends Identifiable>() => {
    Default: (initialChunkSize: number, getChunk: InfiniteStreamState<Element>["getChunk"], shouldLoad?: StreamingStatus) => InfiniteStreamState<Element>;
    Operations: {
        shouldCoroutineRun: (current: InfiniteStreamState<Element>) => boolean;
        loadNextPage: (current: InfiniteStreamState<Element>) => boolean;
    };
    Updaters: {
        Coroutine: {
            addLoadedChunk: (chunkIndex: number, newChunk: Chunk<Element>) => Updater<InfiniteStreamState<Element>>;
        };
        Core: {
            whenNotAlreadyLoading: (_: BasicUpdater<InfiniteStreamState<Element>>) => Updater<InfiniteStreamState<Element>>;
            position: (positionUpdater: Updater<InfiniteStreamState<Element>["position"]>) => Updater<InfiniteStreamState<Element>>;
            clearLoadedElements: () => Updater<InfiniteStreamState<Element>>;
            loadedElements: import("../../main").Widening<InfiniteStreamState<Element>, "loadedElements">;
            loadingMore: import("../../main").Widening<InfiniteStreamState<Element>, "loadingMore">;
            getChunk: import("../../main").Widening<InfiniteStreamState<Element>, "getChunk">;
        };
        Template: {
            loadInitial: () => Updater<InfiniteStreamState<Element>>;
            reload: (getChunk: InfiniteStreamState<Element>["getChunk"]) => Updater<InfiniteStreamState<Element>>;
            loadMore: () => Updater<InfiniteStreamState<Element>>;
        };
    };
};
export type InfiniteStreamReadonlyState = Unit;
export type InfiniteStreamWritableState<Element extends {
    Id: string;
}> = InfiniteStreamState<Element>;
export {};
//# sourceMappingURL=state.d.ts.map