import type { GenericDocument, FieldTypeFromFieldPath, IndexRange as ConvexIndexRange, IndexRangeBuilder as ConvexIndexRangeBuilder } from "convex/server";
import * as Data from "effect/Data";
import * as Option from "effect/Option";
import * as Result from "effect/Result";
import type * as Types from "effect/Types";
import * as QueryStreamIndexPrefix from "./QueryStreamIndexPrefix";
import * as QueryStreamKeyBounds from "./QueryStreamKeyBounds";
import * as QueryStreamKeyValues from "./QueryStreamKeyValues";
import type * as QueryStreamOrderDirection from "./QueryStreamOrderDirection";
type Head<FieldPaths extends ReadonlyArray<string>> = FieldPaths extends readonly [infer H extends string, ...ReadonlyArray<string>] ? H : never;
type Tail<FieldPaths extends ReadonlyArray<string>> = FieldPaths extends readonly [
    string,
    ...infer Rest extends ReadonlyArray<string>
] ? Rest : ReadonlyArray<string>;
declare const TypeId = "~@confect/server/QueryStreamIndexRange";
interface Equality {
    readonly fieldPath: string;
    readonly value: QueryStreamKeyValues.KeyValue;
}
interface Endpoint {
    readonly value: QueryStreamKeyValues.KeyValue;
    readonly inclusive: boolean;
}
type Interval = Data.TaggedEnum<{
    Lower: {
        readonly lower: Endpoint;
    };
    Upper: {
        readonly upper: Endpoint;
    };
    Between: {
        readonly lower: Endpoint;
        readonly upper: Endpoint;
    };
}>;
declare const Interval: {
    readonly $is: <Tag extends "Between" | "Lower" | "Upper">(tag: Tag) => (u: unknown) => u is Extract<{
        readonly _tag: "Between";
        readonly lower: Endpoint;
        readonly upper: Endpoint;
    }, {
        readonly _tag: Tag;
    }> | Extract<{
        readonly _tag: "Lower";
        readonly lower: Endpoint;
    }, {
        readonly _tag: Tag;
    }> | Extract<{
        readonly _tag: "Upper";
        readonly upper: Endpoint;
    }, {
        readonly _tag: Tag;
    }>;
    readonly $match: {
        <Cases extends { readonly [Tag in "Between" | "Lower" | "Upper"]: (args: Extract<{
            readonly _tag: "Between";
            readonly lower: Endpoint;
            readonly upper: Endpoint;
        } | {
            readonly _tag: "Lower";
            readonly lower: Endpoint;
        } | {
            readonly _tag: "Upper";
            readonly upper: Endpoint;
        }, {
            readonly _tag: Tag;
        }>) => any; }>(cases: Cases): (value: {
            readonly _tag: "Between";
            readonly lower: Endpoint;
            readonly upper: Endpoint;
        } | {
            readonly _tag: "Lower";
            readonly lower: Endpoint;
        } | {
            readonly _tag: "Upper";
            readonly upper: Endpoint;
        }) => import("effect/Unify").Unify<ReturnType<Cases["Between" | "Lower" | "Upper"]>>;
        <Cases extends { readonly [Tag in "Between" | "Lower" | "Upper"]: (args: Extract<{
            readonly _tag: "Between";
            readonly lower: Endpoint;
            readonly upper: Endpoint;
        } | {
            readonly _tag: "Lower";
            readonly lower: Endpoint;
        } | {
            readonly _tag: "Upper";
            readonly upper: Endpoint;
        }, {
            readonly _tag: Tag;
        }>) => any; }>(value: {
            readonly _tag: "Between";
            readonly lower: Endpoint;
            readonly upper: Endpoint;
        } | {
            readonly _tag: "Lower";
            readonly lower: Endpoint;
        } | {
            readonly _tag: "Upper";
            readonly upper: Endpoint;
        }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Between" | "Lower" | "Upper"]>>;
    };
    readonly Between: Data.TaggedEnum.ConstructorFrom<{
        readonly _tag: "Between";
        readonly lower: Endpoint;
        readonly upper: Endpoint;
    }, "_tag">;
    readonly Lower: Data.TaggedEnum.ConstructorFrom<{
        readonly _tag: "Lower";
        readonly lower: Endpoint;
    }, "_tag">;
    readonly Upper: Data.TaggedEnum.ConstructorFrom<{
        readonly _tag: "Upper";
        readonly upper: Endpoint;
    }, "_tag">;
};
interface Constraints {
    readonly equalities: ReadonlyArray<Equality>;
    readonly bounded: Option.Option<{
        readonly fieldPath: string;
        readonly interval: Interval;
    }>;
}
/**
 * The equality prefix followed by at most one bounded field.
 *
 * @experimental
 */
export interface QueryStreamIndexRange<out RemainingFieldPaths extends ReadonlyArray<string> = ReadonlyArray<string>> {
    readonly [TypeId]: Constraints & {
        readonly _Remaining: Types.Covariant<RemainingFieldPaths>;
    };
}
/**
 * @experimental
 */
export type Remaining<IndexRange> = IndexRange extends QueryStreamIndexRange<infer RemainingFieldPaths> ? RemainingFieldPaths : never;
/**
 * A typed index-range builder. `eq` must target the next unpinned index field,
 * and consumes it; `gt`/`gte`/`lt`/`lte` bound the next field without consuming
 * it (bounded field paths still vary within the range).
 *
 * @experimental
 */
export interface Builder<ConvexDoc extends GenericDocument, FieldPaths extends ReadonlyArray<string>> extends QueryStreamIndexRange<FieldPaths> {
    readonly eq: (fieldPath: Head<FieldPaths>, value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>) => Builder<ConvexDoc, Tail<FieldPaths>>;
    readonly gt: (fieldPath: Head<FieldPaths>, value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>) => LowerBoundedBuilder<ConvexDoc, FieldPaths>;
    readonly gte: (fieldPath: Head<FieldPaths>, value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>) => LowerBoundedBuilder<ConvexDoc, FieldPaths>;
    readonly lt: (fieldPath: Head<FieldPaths>, value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>) => QueryStreamIndexRange<FieldPaths>;
    readonly lte: (fieldPath: Head<FieldPaths>, value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>) => QueryStreamIndexRange<FieldPaths>;
}
/**
 * After `gt`/`gte`, only an upper bound on the same field may follow.
 *
 * @experimental
 */
export interface LowerBoundedBuilder<ConvexDoc extends GenericDocument, FieldPaths extends ReadonlyArray<string>> extends QueryStreamIndexRange<FieldPaths> {
    readonly lt: (fieldPath: Head<FieldPaths>, value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>) => QueryStreamIndexRange<FieldPaths>;
    readonly lte: (fieldPath: Head<FieldPaths>, value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>) => QueryStreamIndexRange<FieldPaths>;
}
/**
 * The initial builder handed to a range callback.
 *
 * @experimental
 */
export declare const builder: <ConvexDoc extends GenericDocument, FieldPaths extends ReadonlyArray<string>>() => Builder<ConvexDoc, FieldPaths>;
/**
 * Number of index fields pinned by equality constraints.
 *
 * @experimental
 */
export declare const equalityPrefixLength: (self: QueryStreamIndexRange) => number;
/**
 * Apply one range to Convex's index-range builder.
 *
 * @experimental
 */
export declare const apply: (self: QueryStreamIndexRange, q: ConvexIndexRangeBuilder<GenericDocument, string[]>) => ConvexIndexRange;
/**
 * Decompose the range between `indexBounds.lower` and `indexBounds.upper` (over
 * the complete index `fieldPaths`, `_id` tiebreaker included) into a sequence
 * of Convex-expressible ranges, ordered for the given direction.
 *
 * @experimental
 */
export declare const fromBounds: (fieldPaths: ReadonlyArray<string>, orderDirection: QueryStreamOrderDirection.QueryStreamOrderDirection, indexBounds: QueryStreamKeyBounds.IndexBounds) => Result.Result<ReadonlyArray<QueryStreamIndexRange>, QueryStreamIndexPrefix.IndexPrefixWidthMismatchError>;
/**
 * Derive full-index bounds directly from the structural range.
 *
 * @experimental
 */
export declare const toBounds: (self: QueryStreamIndexRange) => QueryStreamKeyBounds.IndexBounds;
export {};
//# sourceMappingURL=QueryStreamIndexRange.d.ts.map