export interface CursorPageItem {
    id: string;
    [key: string]: unknown;
}
export interface CursorPagerOptions<T extends CursorPageItem> {
    items: T[];
    pageSize: number;
    /** Encode page index into opaque token. */
    encodeToken?: (pageIndex: number) => string;
    decodeToken?: (token: string) => number;
}
export interface CursorPageResult<T> {
    items: T[];
    nextCursor: string | null;
    pageIndex: number;
    totalPages: number;
    emptyTerminal: boolean;
}
/**
 * Stable cursor pagination with an empty terminal page after the last data page.
 * Token format default: `p:<index>` (opaque to consumers).
 */
export declare const createCursorPager: <T extends CursorPageItem>(options: CursorPagerOptions<T>) => {
    page(cursor: string | null | undefined): CursorPageResult<T>;
    encode: (pageIndex: number) => string;
    decode: (token: string) => number;
    totalPages: number;
};
export interface WatermarkItem {
    id: string;
    watermark: string;
    [key: string]: unknown;
}
export interface WatermarkPagerOptions<T extends WatermarkItem> {
    items: T[];
    pageSize: number;
    /** Inclusive overlap window in ms (or string compare window size via duplicate watermark rows). */
    overlapCount?: number;
}
export interface WatermarkPageResult<T> {
    items: T[];
    nextWatermark: string | null;
    hasMore: boolean;
}
/**
 * Watermark pagination with deterministic tie-break on (watermark, id) and configurable overlap.
 */
export declare const createWatermarkPager: <T extends WatermarkItem>(options: WatermarkPagerOptions<T>) => {
    page(afterWatermark: string | null | undefined, afterId?: string | null): WatermarkPageResult<T>;
    allSorted: () => T[];
};
export interface InventoryItem {
    id: string;
    content: string;
    [key: string]: unknown;
}
export interface HashedInventoryItem extends InventoryItem {
    contentHash: string;
}
export declare const contentHash: (content: string) => string;
/**
 * Full-scan inventory with stable identities and content hashes.
 */
export declare const createFullScanInventory: <T extends InventoryItem>(items: T[]) => {
    list(offset?: number, limit?: number): {
        items: HashedInventoryItem[];
        total: number;
        nextOffset: number | null;
    };
    all: () => {
        [key: string]: unknown;
        contentHash: string;
        id: string;
        content: string;
    }[];
    get: (id: string) => HashedInventoryItem | undefined;
};
export type ExportJobStatus = 'queued' | 'running' | 'ready' | 'failed';
export interface ExportJob {
    id: string;
    status: ExportJobStatus;
    pollCount: number;
    pollsUntilReady: number;
    collectPath: string;
    result: unknown;
}
/**
 * Command → poll → collect state machine for export-style workflows.
 */
export declare const createExportWorkflow: (options?: {
    pollsUntilReady?: number;
    result?: unknown;
}) => {
    command(): ExportJob;
    poll(jobId: string): ExportJob | undefined;
    collect(jobId: string): {
        status: number;
        body: unknown;
    };
    reset(): void;
    get(jobId: string): {
        id: string;
        status: ExportJobStatus;
        pollCount: number;
        pollsUntilReady: number;
        collectPath: string;
        result: unknown;
    } | undefined;
};
//# sourceMappingURL=sequences.d.ts.map