import * as Chunk from "effect/Chunk";
import * as Data from "effect/Data";
import * as Option from "effect/Option";
import * as Result from "effect/Result";
import * as Schema from "effect/Schema";
import type * as QueryStreamKey from "./QueryStreamKey";
declare const PageSize: Schema.brand<Schema.Natural, "~@confect/server/QueryStreamPagination/PageSize">;
type PageSize = typeof PageSize.Type;
declare const InvalidPageSizeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "InvalidPageSizeError";
} & Readonly<A>;
/**
 * @experimental
 */
export declare class InvalidPageSizeError extends InvalidPageSizeError_base<{
    readonly numItems: number;
}> {
    get message(): string;
}
declare const EmptyInitialPageError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "EmptyInitialPageError";
} & Readonly<A>;
/**
 * @experimental
 */
export declare class EmptyInitialPageError extends EmptyInitialPageError_base {
    get message(): string;
}
/**
 * @experimental
 */
export type Range = Data.TaggedEnum<{
    Unpinned: {};
    ThroughKey: {
        readonly key: QueryStreamKey.Complete;
    };
    ThroughEnd: {};
}>;
/**
 * @experimental
 */
export declare const Range: {
    readonly $is: <Tag extends "ThroughEnd" | "ThroughKey" | "Unpinned">(tag: Tag) => (u: unknown) => u is Extract<{
        readonly _tag: "ThroughEnd";
    }, {
        readonly _tag: Tag;
    }> | Extract<{
        readonly _tag: "ThroughKey";
        readonly key: QueryStreamKey.Complete;
    }, {
        readonly _tag: Tag;
    }> | Extract<{
        readonly _tag: "Unpinned";
    }, {
        readonly _tag: Tag;
    }>;
    readonly $match: {
        <Cases extends { readonly [Tag in "ThroughEnd" | "ThroughKey" | "Unpinned"]: (args: Extract<{
            readonly _tag: "ThroughEnd";
        } | {
            readonly _tag: "ThroughKey";
            readonly key: QueryStreamKey.Complete;
        } | {
            readonly _tag: "Unpinned";
        }, {
            readonly _tag: Tag;
        }>) => any; }>(cases: Cases): (value: {
            readonly _tag: "ThroughEnd";
        } | {
            readonly _tag: "ThroughKey";
            readonly key: QueryStreamKey.Complete;
        } | {
            readonly _tag: "Unpinned";
        }) => import("effect/Unify").Unify<ReturnType<Cases["ThroughEnd" | "ThroughKey" | "Unpinned"]>>;
        <Cases extends { readonly [Tag in "ThroughEnd" | "ThroughKey" | "Unpinned"]: (args: Extract<{
            readonly _tag: "ThroughEnd";
        } | {
            readonly _tag: "ThroughKey";
            readonly key: QueryStreamKey.Complete;
        } | {
            readonly _tag: "Unpinned";
        }, {
            readonly _tag: Tag;
        }>) => any; }>(value: {
            readonly _tag: "ThroughEnd";
        } | {
            readonly _tag: "ThroughKey";
            readonly key: QueryStreamKey.Complete;
        } | {
            readonly _tag: "Unpinned";
        }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["ThroughEnd" | "ThroughKey" | "Unpinned"]>>;
    };
    readonly ThroughEnd: Data.TaggedEnum.ConstructorFrom<{
        readonly _tag: "ThroughEnd";
    }, "_tag">;
    readonly ThroughKey: Data.TaggedEnum.ConstructorFrom<{
        readonly _tag: "ThroughKey";
        readonly key: QueryStreamKey.Complete;
    }, "_tag">;
    readonly Unpinned: Data.TaggedEnum.ConstructorFrom<{
        readonly _tag: "Unpinned";
    }, "_tag">;
};
/**
 * @experimental
 */
export type Start = Data.TaggedEnum<{
    Beginning: {};
    After: {
        readonly key: QueryStreamKey.Complete;
        readonly cursor: string;
    };
}>;
/**
 * @experimental
 */
export declare const Start: {
    readonly $is: <Tag extends "After" | "Beginning">(tag: Tag) => (u: unknown) => u is Extract<{
        readonly _tag: "After";
        readonly key: QueryStreamKey.Complete;
        readonly cursor: string;
    }, {
        readonly _tag: Tag;
    }> | Extract<{
        readonly _tag: "Beginning";
    }, {
        readonly _tag: Tag;
    }>;
    readonly $match: {
        <Cases extends { readonly [Tag in "After" | "Beginning"]: (args: Extract<{
            readonly _tag: "After";
            readonly key: QueryStreamKey.Complete;
            readonly cursor: string;
        } | {
            readonly _tag: "Beginning";
        }, {
            readonly _tag: Tag;
        }>) => any; }>(cases: Cases): (value: {
            readonly _tag: "After";
            readonly key: QueryStreamKey.Complete;
            readonly cursor: string;
        } | {
            readonly _tag: "Beginning";
        }) => import("effect/Unify").Unify<ReturnType<Cases["After" | "Beginning"]>>;
        <Cases extends { readonly [Tag in "After" | "Beginning"]: (args: Extract<{
            readonly _tag: "After";
            readonly key: QueryStreamKey.Complete;
            readonly cursor: string;
        } | {
            readonly _tag: "Beginning";
        }, {
            readonly _tag: Tag;
        }>) => any; }>(value: {
            readonly _tag: "After";
            readonly key: QueryStreamKey.Complete;
            readonly cursor: string;
        } | {
            readonly _tag: "Beginning";
        }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["After" | "Beginning"]>>;
    };
    readonly After: Data.TaggedEnum.ConstructorFrom<{
        readonly _tag: "After";
        readonly key: QueryStreamKey.Complete;
        readonly cursor: string;
    }, "_tag">;
    readonly Beginning: Data.TaggedEnum.ConstructorFrom<{
        readonly _tag: "Beginning";
    }, "_tag">;
};
/**
 * @experimental
 */
export interface ScanRequest {
    readonly numItems: PageSize;
    readonly after: Option.Option<QueryStreamKey.Complete>;
    readonly range: Range;
}
/**
 * @experimental
 */
export type Request = Data.TaggedEnum<{
    Unchanged: {
        readonly cursor: string;
    };
    Scan: ScanRequest;
}>;
/**
 * @experimental
 */
export declare const parseRequest: (numItems: number, start: Start, range: Range) => Result.Result<Request, InvalidPageSizeError | EmptyInitialPageError>;
/**
 * A nonempty scan, including filtered markers.
 */
type Progress = Chunk.NonEmptyChunk<QueryStreamKey.Complete>;
interface Stopped<Doc> {
    readonly page: Chunk.Chunk<Doc>;
    readonly progress: Progress;
}
/**
 * @experimental
 */
export type QueryStreamPagination<Doc> = Data.TaggedEnum<{
    Reading: {
        readonly page: Chunk.Chunk<Doc>;
        readonly progress: Option.Option<Progress>;
    };
    ItemLimit: Stopped<Doc>;
    ReadLimit: Stopped<Doc>;
}>;
/**
 * @experimental
 */
export declare const initial: <Doc>() => QueryStreamPagination<Doc>;
/**
 * @experimental
 */
export declare const record: <Doc>(request: ScanRequest, self: QueryStreamPagination<Doc>, doc: Option.Option<Doc>, key: QueryStreamKey.Complete, readLimit: boolean) => QueryStreamPagination<Doc>;
/**
 * @experimental
 */
export type Continuation = Data.TaggedEnum<{
    End: {};
    Key: {
        readonly key: QueryStreamKey.Complete;
    };
}>;
interface Split<Doc> {
    readonly page: ReadonlyArray<Doc>;
    readonly continuation: Continuation;
    readonly splitKey: QueryStreamKey.Complete;
}
/**
 * @experimental
 */
export type Outcome<Doc> = Data.TaggedEnum<{
    Done: {
        readonly page: ReadonlyArray<Doc>;
    };
    Continue: {
        readonly page: ReadonlyArray<Doc>;
        readonly key: QueryStreamKey.Complete;
    };
    SplitRequired: Split<Doc>;
    SplitRecommended: Split<Doc>;
}>;
declare const UnsafePageBoundaryError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "UnsafePageBoundaryError";
} & Readonly<A>;
/**
 * @experimental
 */
export declare class UnsafePageBoundaryError extends UnsafePageBoundaryError_base<{
    readonly reason: "NoProgress" | "NoInteriorSplit";
}> {
    get message(): string;
}
/**
 * Decide the page result without reading a stream or serializing a cursor.
 *
 * @experimental
 */
export declare const finish: <Doc>(request: ScanRequest, self: QueryStreamPagination<Doc>, upstreamStopped: boolean) => Result.Result<Outcome<Doc>, UnsafePageBoundaryError>;
export {};
//# sourceMappingURL=QueryStreamPagination.d.ts.map