import { OrderedMap, Map } 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";
import { Guid, PredicateValue, ValueOrErrors, ValueRecord } from "../../main";
export type ValueStreamingStatus = "reload" | "loadMore" | false;
export type ValueStreamPosition = {
    nextStart: number;
    chunkSize: number;
    chunkIndex: ValueChunkIndex;
    shouldLoad: ValueStreamingStatus;
    lastModifiedTime: number;
    disallowParamsChange: boolean;
};
export declare const ValueStreamPosition: {
    Default: (initialChunkSize: number, shouldLoad?: ValueStreamingStatus) => ValueStreamPosition;
    Updaters: {
        Template: {
            changeChunkSize: (chunkSize: number) => Updater<ValueStreamPosition>;
            reload: () => Updater<ValueStreamPosition>;
            loadMore: () => Updater<ValueStreamPosition>;
            initLoad: () => Updater<ValueStreamPosition>;
        };
        Core: {
            nextStart: import("../../main").Widening<ValueStreamPosition, "nextStart">;
            chunkSize: import("../../main").Widening<ValueStreamPosition, "chunkSize">;
            chunkIndex: import("../../main").Widening<ValueStreamPosition, "chunkIndex">;
            shouldLoad: import("../../main").Widening<ValueStreamPosition, "shouldLoad">;
            lastModifiedTime: import("../../main").Widening<ValueStreamPosition, "lastModifiedTime">;
            disallowParamsChange: import("../../main").Widening<ValueStreamPosition, "disallowParamsChange">;
        };
        Coroutine: {};
    };
};
export type ValueChunk = {
    hasMoreValues: boolean;
    data: OrderedMap<Guid, ValueRecord>;
    from: number;
    to: number;
};
export declare const ValueChunk: {
    Default: (hasMoreValues: boolean, data: OrderedMap<Guid, ValueRecord>, from: number, to: number) => ValueChunk;
    Updaters: {
        Core: {
            to: import("../../main").Widening<ValueChunk, "to">;
            from: import("../../main").Widening<ValueChunk, "from">;
            data: import("../../main").Widening<ValueChunk, "data">;
            hasMoreValues: import("../../main").Widening<ValueChunk, "hasMoreValues">;
        };
        Template: {
            updateValue: (valueId: Guid, valueUpdater: BasicUpdater<ValueRecord>) => Updater<ValueChunk>;
            updateValueItem: (valueId: Guid, itemId: Guid, valueUpdater: BasicUpdater<PredicateValue>) => Updater<ValueChunk>;
        };
    };
};
export type ValueChunkIndex = number;
export type StateChunkIndex = number;
export type StateChunkValue = Map<string, unknown>;
export declare const StateChunkItem: {
    Default: (state: Record<string, unknown>) => StateChunkValue;
};
export type StateChunk = Map<string, StateChunkValue>;
export declare const StateChunk: {
    Default: (state: Record<string, StateChunkValue>) => StateChunk;
};
export type ValueInfiniteStreamState = {
    loadingMore: AsyncState<Unit>;
    loadedElements: OrderedMap<ValueChunkIndex, ValueChunk>;
    position: ValueStreamPosition;
    getChunk: BasicFun<[ValueStreamPosition], Promise<ValueChunk>>;
};
export declare const ValueInfiniteStreamState: {
    Default: (initialChunkSize: number, getChunk: ValueInfiniteStreamState["getChunk"], shouldLoad?: ValueStreamingStatus) => ValueInfiniteStreamState;
    Operations: {
        shouldCoroutineRun: (current: ValueInfiniteStreamState) => boolean;
        loadNextPage: (current: ValueInfiniteStreamState) => boolean;
        getChunkIndexForValue: (current: ValueInfiniteStreamState, valueId: Guid) => ValueOrErrors<number, string>;
    };
    Updaters: {
        Coroutine: {
            addLoadedChunk: (chunkIndex: number, newChunk: ValueChunk) => Updater<ValueInfiniteStreamState>;
        };
        Core: {
            whenNotAlreadyLoading: (_: BasicUpdater<ValueInfiniteStreamState>) => Updater<ValueInfiniteStreamState>;
            position: (positionUpdater: Updater<ValueInfiniteStreamState["position"]>) => Updater<ValueInfiniteStreamState>;
            clearLoadedElements: () => Updater<ValueInfiniteStreamState>;
            loadedElements: import("../../main").Widening<ValueInfiniteStreamState, "loadedElements">;
            loadingMore: import("../../main").Widening<ValueInfiniteStreamState, "loadingMore">;
            getChunk: import("../../main").Widening<ValueInfiniteStreamState, "getChunk">;
        };
        Template: {
            reload: (getChunk: ValueInfiniteStreamState["getChunk"]) => Updater<ValueInfiniteStreamState>;
            loadMore: () => Updater<ValueInfiniteStreamState>;
            initLoad: () => Updater<ValueInfiniteStreamState>;
            updateChunkValue: (chunkIndex: number, chunkValueKey: Guid) => (valueUpdater: BasicUpdater<ValueRecord>) => Updater<ValueInfiniteStreamState>;
            updateChunkValueItem: (chunkIndex: number, chunkValueKey: Guid, chunkValueItemKey: Guid) => (valueUpdater: BasicUpdater<PredicateValue>) => Updater<ValueInfiniteStreamState>;
        };
    };
};
export type ValueInfiniteStreamReadonlyContext = Unit;
export type ValueInfiniteStreamWritableState = ValueInfiniteStreamState;
//# sourceMappingURL=state.d.ts.map