@reifydb/core 0.0.1-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,1280 @@
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+declare const UNDEFINED_VALUE = "\u27EAundefined\u27EB";
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+/**
+ * A binary large object (BLOB) value that can hold arbitrary byte data.
+ */
+declare class BlobValue implements Value {
+    readonly type: Type;
+    private readonly bytes?;
+    constructor(value?: Uint8Array | ArrayBuffer | string | number[]);
+    /**
+     * Create a new BLOB from raw bytes
+     */
+    static new(bytes: Uint8Array | number[]): BlobValue;
+    /**
+     * Create an empty BLOB
+     */
+    static empty(): BlobValue;
+    /**
+     * Create a BLOB from a byte array
+     */
+    static fromBytes(bytes: number[]): BlobValue;
+    /**
+     * Create a BLOB from a hex string
+     */
+    static fromHex(hex: string): BlobValue;
+    /**
+     * Create a BLOB from a base64 string
+     */
+    static fromBase64(base64: string): BlobValue;
+    /**
+     * Create a BLOB from a UTF-8 string
+     */
+    static fromUtf8(str: string): BlobValue;
+    /**
+     * Parse a blob string (hex or undefined)
+     */
+    static parse(str: string): BlobValue;
+    /**
+     * Get the raw bytes
+     */
+    asBytes(): Uint8Array | undefined;
+    /**
+     * Get the length in bytes
+     */
+    length(): number;
+    /**
+     * Check if the BLOB is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Convert to hex string with 0x prefix
+     */
+    toHex(): string | undefined;
+    /**
+     * Convert to base64 string
+     */
+    toBase64(): string | undefined;
+    /**
+     * Convert to UTF-8 string
+     */
+    toUtf8(): string | undefined;
+    /**
+     * Format as hex string with 0x prefix
+     */
+    toString(): string;
+    valueOf(): Uint8Array | undefined;
+    /**
+     * Get the internal representation
+     */
+    get value(): Uint8Array | undefined;
+    /**
+     * Compare two blobs for equality
+     */
+    equals(other: Value): boolean;
+    /**
+     * Helper to parse a string as hex
+     */
+    private static parseString;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+declare class BoolValue implements Value {
+    readonly type: Type;
+    readonly value?: boolean;
+    constructor(value?: boolean);
+    static parse(str: string): BoolValue;
+    valueOf(): boolean | undefined;
+    toString(): string;
+    /**
+     * Compare two boolean values for equality
+     */
+    equals(other: Value): boolean;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+/**
+ * A date value representing a calendar date (year, month, day) without time information.
+ * Always interpreted in UTC.
+ * Internally stored as months and days.
+ */
+declare class DateValue implements Value {
+    readonly type: Type;
+    private readonly months?;
+    private readonly days?;
+    constructor(value?: Date | string | number);
+    /**
+     * Create a DateValue from year, month (1-12), and day (1-31)
+     */
+    static fromYMD(year: number, month: number, day: number): DateValue;
+    /**
+     * Get today's date (in UTC)
+     */
+    static today(): DateValue;
+    /**
+     * Parse a date string in YYYY-MM-DD format
+     */
+    static parse(str: string): DateValue;
+    /**
+     * Convert to days since Unix epoch (1970-01-01) for storage
+     */
+    toDaysSinceEpoch(): number | undefined;
+    /**
+     * Create from days since Unix epoch
+     */
+    static fromDaysSinceEpochToComponents(days: number): {
+        months: number;
+        days: number;
+    } | null;
+    /**
+     * Get the year component
+     */
+    year(): number | undefined;
+    /**
+     * Get the month component (1-12)
+     */
+    month(): number | undefined;
+    /**
+     * Get the day component (1-31)
+     */
+    day(): number | undefined;
+    /**
+     * Format as YYYY-MM-DD string
+     */
+    toString(): string;
+    valueOf(): Date | undefined;
+    /**
+     * Get the internal representation
+     */
+    get value(): Date | undefined;
+    /**
+     * Helper to parse YYYY-MM-DD format
+     */
+    private static parseDate;
+    /**
+     * Helper to validate a date
+     */
+    private static isValidDate;
+    /**
+     * Compare two dates for equality
+     */
+    equals(other: Value): boolean;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+/**
+ * A time value representing time of day (hour, minute, second, nanosecond) without date information.
+ * Internally stored as nanoseconds since midnight.
+ */
+declare class TimeValue implements Value {
+    readonly type: Type;
+    readonly value?: bigint;
+    private static readonly NANOS_PER_SECOND;
+    private static readonly NANOS_PER_MINUTE;
+    private static readonly NANOS_PER_HOUR;
+    private static readonly NANOS_PER_DAY;
+    constructor(value?: bigint | string | number);
+    /**
+     * Create a TimeValue from hour, minute, second, and nanosecond
+     */
+    static fromHMSN(hour: number, minute: number, second: number, nano?: number): TimeValue;
+    /**
+     * Create a TimeValue from hour, minute, and second (no fractional seconds)
+     */
+    static fromHMS(hour: number, minute: number, second: number): TimeValue;
+    /**
+     * Create midnight (00:00:00.000000000)
+     */
+    static midnight(): TimeValue;
+    /**
+     * Create noon (12:00:00.000000000)
+     */
+    static noon(): TimeValue;
+    /**
+     * Parse a time string in HH:MM:SS[.nnnnnnnnn] format
+     */
+    static parse(str: string): TimeValue;
+    /**
+     * Get the hour component (0-23)
+     */
+    hour(): number | undefined;
+    /**
+     * Get the minute component (0-59)
+     */
+    minute(): number | undefined;
+    /**
+     * Get the second component (0-59)
+     */
+    second(): number | undefined;
+    /**
+     * Get the nanosecond component (0-999999999)
+     */
+    nanosecond(): number | undefined;
+    /**
+     * Convert to nanoseconds since midnight for storage
+     */
+    toNanosSinceMidnight(): bigint | undefined;
+    /**
+     * Create from nanoseconds since midnight
+     */
+    static fromNanosSinceMidnight(nanos: bigint | number): TimeValue;
+    /**
+     * Format as HH:MM:SS.nnnnnnnnn string
+     */
+    toString(): string;
+    valueOf(): bigint | undefined;
+    /**
+     * Helper to parse HH:MM:SS[.nnnnnnnnn] format
+     */
+    private static parseTime;
+    /**
+     * Compare two Time values for equality
+     */
+    equals(other: Value): boolean;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+/**
+ * A date and time value with nanosecond precision.
+ * Always in UTC timezone.
+ * Internally stored as months, days, and nanoseconds.
+ */
+declare class DateTimeValue implements Value {
+    readonly type: Type;
+    private readonly months?;
+    private readonly days?;
+    private readonly nanos?;
+    constructor(value?: Date | string | number | bigint);
+    /**
+     * Create a DateTimeValue from year, month, day, hour, minute, second, nanosecond
+     */
+    static fromYMDHMSN(year: number, month: number, day: number, hour: number, minute: number, second: number, nano?: number): DateTimeValue;
+    /**
+     * Create a DateTimeValue from year, month, day, hour, minute, second (no fractional)
+     */
+    static fromYMDHMS(year: number, month: number, day: number, hour: number, minute: number, second: number): DateTimeValue;
+    /**
+     * Create from Unix timestamp in seconds
+     */
+    static fromTimestamp(seconds: number): DateTimeValue;
+    /**
+     * Create from Unix timestamp in milliseconds
+     */
+    static fromTimestampMillis(millis: number): DateTimeValue;
+    /**
+     * Create from nanoseconds since Unix epoch
+     */
+    static fromNanosSinceEpoch(nanos: bigint): DateTimeValue;
+    /**
+     * Create from separate seconds and nanoseconds
+     */
+    static fromParts(seconds: number, nanos: number): DateTimeValue;
+    /**
+     * Get current datetime
+     */
+    static now(): DateTimeValue;
+    /**
+     * Get default datetime (Unix epoch)
+     */
+    static default(): DateTimeValue;
+    /**
+     * Parse a datetime string in ISO 8601 format
+     */
+    static parse(str: string): DateTimeValue;
+    /**
+     * Get Unix timestamp in seconds
+     */
+    timestamp(): number | undefined;
+    /**
+     * Get Unix timestamp in nanoseconds
+     */
+    timestampNanos(): bigint | undefined;
+    /**
+     * Convert to nanoseconds since Unix epoch for storage
+     */
+    toNanosSinceEpoch(): bigint | undefined;
+    /**
+     * Get separate seconds and nanoseconds for storage
+     */
+    toParts(): [number, number] | undefined;
+    /**
+     * Get the date component
+     */
+    date(): DateValue | undefined;
+    /**
+     * Get the time component
+     */
+    time(): TimeValue | undefined;
+    /**
+     * Format as ISO 8601 string with nanosecond precision and Z suffix
+     */
+    toString(): string;
+    valueOf(): Date | undefined;
+    /**
+     * Get the internal representation as a Date
+     */
+    get value(): Date | undefined;
+    /**
+     * Helper to parse ISO 8601 datetime format
+     */
+    private static parseDateTime;
+    /**
+     * Helper to validate a date
+     */
+    private static isValidDate;
+    /**
+     * Compare two datetimes for equality
+     */
+    equals(other: Value): boolean;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+declare class Float4Value implements Value {
+    private static readonly MAX_VALUE;
+    private static readonly MIN_VALUE;
+    private static readonly MIN_POSITIVE;
+    readonly type: Type;
+    readonly value?: number;
+    constructor(value?: number);
+    static parse(str: string): Float4Value;
+    valueOf(): number | undefined;
+    toString(): string;
+    /**
+     * Compare two Float4 values for equality with limited precision
+     */
+    equals(other: Value): boolean;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+declare class Float8Value implements Value {
+    readonly type: Type;
+    readonly value?: number;
+    constructor(value?: number);
+    static parse(str: string): Float8Value;
+    valueOf(): number | undefined;
+    toString(): string;
+    /**
+     * Compare two Float8 values for equality
+     */
+    equals(other: Value): boolean;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+declare class Int1Value implements Value {
+    readonly type: Type;
+    readonly value?: number;
+    private static readonly MIN_VALUE;
+    private static readonly MAX_VALUE;
+    constructor(value?: number);
+    static parse(str: string): Int1Value;
+    valueOf(): number | undefined;
+    toString(): string;
+    /**
+     * Compare two Int1 values for equality
+     */
+    equals(other: Value): boolean;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+declare class Int2Value implements Value {
+    readonly type: Type;
+    readonly value?: number;
+    private static readonly MIN_VALUE;
+    private static readonly MAX_VALUE;
+    constructor(value?: number);
+    static parse(str: string): Int2Value;
+    valueOf(): number | undefined;
+    toString(): string;
+    /**
+     * Compare two Int2 values for equality
+     */
+    equals(other: Value): boolean;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+declare class Int4Value implements Value {
+    readonly type: Type;
+    readonly value?: number;
+    private static readonly MIN_VALUE;
+    private static readonly MAX_VALUE;
+    constructor(value?: number);
+    static parse(str: string): Int4Value;
+    valueOf(): number | undefined;
+    toString(): string;
+    /**
+     * Compare two Int4 values for equality
+     */
+    equals(other: Value): boolean;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+declare class Int8Value implements Value {
+    readonly type: Type;
+    readonly value?: bigint;
+    private static readonly MIN_VALUE;
+    private static readonly MAX_VALUE;
+    constructor(value?: bigint | number);
+    static parse(str: string): Int8Value;
+    valueOf(): bigint | undefined;
+    toString(): string;
+    /**
+     * Compare two Int8 values for equality
+     */
+    equals(other: Value): boolean;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+declare class Int16Value implements Value {
+    readonly type: Type;
+    readonly value?: bigint;
+    private static readonly MIN_VALUE;
+    private static readonly MAX_VALUE;
+    constructor(value?: bigint | number | string);
+    static parse(str: string): Int16Value;
+    valueOf(): bigint | undefined;
+    toString(): string;
+    /**
+     * Compare two Int16 values for equality
+     */
+    equals(other: Value): boolean;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+/**
+ * An interval value representing a duration between two points in time.
+ * Internally stored as months, days, and nanoseconds.
+ */
+declare class IntervalValue implements Value {
+    readonly type: Type;
+    private readonly months?;
+    private readonly days?;
+    private readonly nanos?;
+    constructor(value?: {
+        months: number;
+        days: number;
+        nanos: bigint;
+    } | string);
+    /**
+     * Create a new interval from months, days, and nanoseconds
+     */
+    static new(months: number, days: number, nanos: bigint): IntervalValue;
+    /**
+     * Create an interval from seconds
+     */
+    static fromSeconds(seconds: number): IntervalValue;
+    /**
+     * Create an interval from milliseconds
+     */
+    static fromMilliseconds(milliseconds: number): IntervalValue;
+    /**
+     * Create an interval from microseconds
+     */
+    static fromMicroseconds(microseconds: number): IntervalValue;
+    /**
+     * Create an interval from nanoseconds
+     */
+    static fromNanoseconds(nanoseconds: bigint): IntervalValue;
+    /**
+     * Create an interval from minutes
+     */
+    static fromMinutes(minutes: number): IntervalValue;
+    /**
+     * Create an interval from hours
+     */
+    static fromHours(hours: number): IntervalValue;
+    /**
+     * Create an interval from days
+     */
+    static fromDays(days: number): IntervalValue;
+    /**
+     * Create an interval from weeks
+     */
+    static fromWeeks(weeks: number): IntervalValue;
+    /**
+     * Create an interval from months
+     */
+    static fromMonths(months: number): IntervalValue;
+    /**
+     * Create an interval from years
+     */
+    static fromYears(years: number): IntervalValue;
+    /**
+     * Create a zero interval
+     */
+    static zero(): IntervalValue;
+    /**
+     * Get default interval (zero)
+     */
+    static default(): IntervalValue;
+    /**
+     * Parse an interval string in ISO 8601 duration format
+     */
+    static parse(str: string): IntervalValue;
+    /**
+     * Get total seconds (truncated)
+     */
+    seconds(): bigint | undefined;
+    /**
+     * Get total milliseconds (truncated)
+     */
+    milliseconds(): bigint | undefined;
+    /**
+     * Get total microseconds (truncated)
+     */
+    microseconds(): bigint | undefined;
+    /**
+     * Get total nanoseconds
+     */
+    nanoseconds(): bigint | undefined;
+    /**
+     * Get months component
+     */
+    getMonths(): number | undefined;
+    /**
+     * Get days component
+     */
+    getDays(): number | undefined;
+    /**
+     * Get nanoseconds component
+     */
+    getNanos(): bigint | undefined;
+    /**
+     * Check if interval is positive (any component > 0)
+     */
+    isPositive(): boolean;
+    /**
+     * Check if interval is negative (any component < 0)
+     */
+    isNegative(): boolean;
+    /**
+     * Get absolute value of interval
+     */
+    abs(): IntervalValue;
+    /**
+     * Negate the interval
+     */
+    negate(): IntervalValue;
+    /**
+     * Format as ISO 8601 duration string
+     */
+    toString(): string;
+    valueOf(): {
+        months: number;
+        days: number;
+        nanos: bigint;
+    } | undefined;
+    /**
+     * Get the internal representation
+     */
+    get value(): {
+        months: number;
+        days: number;
+        nanos: bigint;
+    } | undefined;
+    /**
+     * Helper to parse ISO 8601 duration format
+     */
+    private static parseDuration;
+    /**
+     * Compare two intervals for equality
+     */
+    equals(other: Value): boolean;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+declare class Uint1Value implements Value {
+    readonly type: Type;
+    readonly value?: number;
+    private static readonly MIN_VALUE;
+    private static readonly MAX_VALUE;
+    constructor(value?: number);
+    static parse(str: string): Uint1Value;
+    valueOf(): number | undefined;
+    toString(): string;
+    /**
+     * Compare two Uint1 values for equality
+     */
+    equals(other: Value): boolean;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+declare class Uint2Value implements Value {
+    readonly type: Type;
+    readonly value?: number;
+    private static readonly MIN_VALUE;
+    private static readonly MAX_VALUE;
+    constructor(value?: number);
+    static parse(str: string): Uint2Value;
+    valueOf(): number | undefined;
+    toString(): string;
+    /**
+     * Compare two Uint2 values for equality
+     */
+    equals(other: Value): boolean;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+declare class Uint4Value implements Value {
+    readonly type: Type;
+    readonly value?: number;
+    private static readonly MIN_VALUE;
+    private static readonly MAX_VALUE;
+    constructor(value?: number);
+    static parse(str: string): Uint4Value;
+    valueOf(): number | undefined;
+    toString(): string;
+    /**
+     * Compare two Uint4 values for equality
+     */
+    equals(other: Value): boolean;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+declare class Uint8Value implements Value {
+    readonly type: Type;
+    readonly value?: bigint;
+    private static readonly MIN_VALUE;
+    private static readonly MAX_VALUE;
+    constructor(value?: bigint | number);
+    static parse(str: string): Uint8Value;
+    valueOf(): bigint | undefined;
+    toNumber(): number | undefined;
+    toString(): string;
+    /**
+     * Compare two Uint8 values for equality
+     */
+    equals(other: Value): boolean;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+declare class Uint16Value implements Value {
+    readonly type: Type;
+    readonly value?: bigint;
+    private static readonly MIN_VALUE;
+    private static readonly MAX_VALUE;
+    constructor(value?: bigint | number | string);
+    static parse(str: string): Uint16Value;
+    valueOf(): bigint | undefined;
+    toString(): string;
+    /**
+     * Compare two Uint16 values for equality
+     */
+    equals(other: Value): boolean;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+declare class RowNumberValue implements Value {
+    private static readonly MIN_VALUE;
+    private static readonly MAX_VALUE;
+    readonly type: Type;
+    readonly value?: bigint;
+    constructor(value?: bigint | number);
+    static parse(str: string): RowNumberValue;
+    valueOf(): bigint | undefined;
+    toString(): string;
+    /**
+     * Compare two RowNumber values for equality
+     */
+    equals(other: Value): boolean;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+/**
+ * An undefined value wrapper type
+ */
+declare class UndefinedValue implements Value {
+    readonly type: Type;
+    constructor();
+    /**
+     * Create a new UndefinedValue
+     */
+    static new(): UndefinedValue;
+    /**
+     * Get default UndefinedValue
+     */
+    static default(): UndefinedValue;
+    /**
+     * Parse a string as undefined
+     */
+    static parse(str: string): UndefinedValue;
+    /**
+     * Check if this value is undefined (always true)
+     */
+    isUndefined(): boolean;
+    /**
+     * Format as string
+     */
+    toString(): string;
+    valueOf(): undefined;
+    /**
+     * Get the internal representation (always undefined)
+     */
+    get value(): undefined;
+    /**
+     * Compare two undefined values (always equal)
+     */
+    equals(other: Value): boolean;
+    /**
+     * Compare two undefined values for ordering (always equal)
+     */
+    compare(other: UndefinedValue): number;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+declare class Utf8Value implements Value {
+    readonly type: Type;
+    readonly value?: string;
+    constructor(value?: string);
+    static parse(str: string): Utf8Value;
+    valueOf(): string | undefined;
+    toString(): string;
+    /**
+     * Compare two Utf8 values for equality
+     */
+    equals(other: Value): boolean;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+/**
+ * A UUID version 4 (random) value type
+ */
+declare class Uuid4Value implements Value {
+    readonly type: Type;
+    private readonly uuid?;
+    constructor(value?: string);
+    /**
+     * Generate a new random UUID v4
+     */
+    static generate(): Uuid4Value;
+    /**
+     * Create a new Uuid4Value from a string
+     */
+    static new(uuid: string): Uuid4Value;
+    /**
+     * Get the nil UUID (all zeros)
+     */
+    static nil(): Uuid4Value;
+    /**
+     * Get default Uuid4Value (nil UUID)
+     */
+    static default(): Uuid4Value;
+    /**
+     * Parse a UUID string
+     */
+    static parse(str: string): Uuid4Value;
+    /**
+     * Get the UUID string
+     */
+    asString(): string | undefined;
+    /**
+     * Get the UUID as bytes (16-byte array)
+     */
+    asBytes(): Uint8Array | undefined;
+    /**
+     * Check if this is the nil UUID
+     */
+    isNil(): boolean;
+    /**
+     * Get the UUID version
+     */
+    getVersion(): number | undefined;
+    /**
+     * Format as string
+     */
+    toString(): string;
+    valueOf(): string | undefined;
+    /**
+     * Get the internal representation
+     */
+    get value(): string | undefined;
+    /**
+     * Compare two UUID4 values for equality
+     */
+    equals(other: Value): boolean;
+    /**
+     * Compare two UUID4 values (for ordering)
+     */
+    compare(other: Uuid4Value): number;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+/**
+ * A UUID version 7 (timestamp-based) value type
+ */
+declare class Uuid7Value implements Value {
+    readonly type: Type;
+    private readonly uuid?;
+    constructor(value?: string);
+    /**
+     * Generate a new timestamp-based UUID v7
+     */
+    static generate(): Uuid7Value;
+    /**
+     * Create a new Uuid7Value from a string
+     */
+    static new(uuid: string): Uuid7Value;
+    /**
+     * Get the nil UUID (all zeros)
+     */
+    static nil(): Uuid7Value;
+    /**
+     * Get default Uuid7Value (nil UUID)
+     */
+    static default(): Uuid7Value;
+    /**
+     * Parse a UUID string
+     */
+    static parse(str: string): Uuid7Value;
+    /**
+     * Get the UUID string
+     */
+    asString(): string | undefined;
+    /**
+     * Get the UUID as bytes (16-byte array)
+     */
+    asBytes(): Uint8Array | undefined;
+    /**
+     * Extract the timestamp from UUID v7 (milliseconds since Unix epoch)
+     */
+    getTimestamp(): number | undefined;
+    /**
+     * Check if this is the nil UUID
+     */
+    isNil(): boolean;
+    /**
+     * Get the UUID version
+     */
+    getVersion(): number | undefined;
+    /**
+     * Format as string
+     */
+    toString(): string;
+    valueOf(): string | undefined;
+    /**
+     * Get the internal representation
+     */
+    get value(): string | undefined;
+    /**
+     * Compare two UUID7 values for equality
+     */
+    equals(other: Value): boolean;
+    /**
+     * Compare two UUID7 values (for ordering)
+     * UUID v7 has timestamp-based ordering for UUIDs generated close in time
+     */
+    compare(other: Uuid7Value): number;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+/**
+ * An IdentityId value type that wraps a UUID v7
+ */
+declare class IdentityIdValue implements Value {
+    readonly type: Type;
+    readonly value?: string;
+    constructor(value?: string);
+    /**
+     * Generate a new IdentityId with a UUID v7
+     */
+    static generate(): IdentityIdValue;
+    /**
+     * Get the nil IdentityId (all zeros)
+     */
+    static nil(): IdentityIdValue;
+    /**
+     * Parse a string as an IdentityId
+     */
+    static parse(str: string): IdentityIdValue;
+    /**
+     * Get the UUID string value
+     */
+    valueOf(): string | undefined;
+    /**
+     * Format as string
+     */
+    toString(): string;
+    /**
+     * Extract the timestamp from the UUID v7 (milliseconds since Unix epoch)
+     */
+    getTimestamp(): number | undefined;
+    /**
+     * Check if this is the nil UUID
+     */
+    isNil(): boolean;
+    /**
+     * Compare two IdentityId values for equality
+     */
+    equals(other: Value): boolean;
+    encode(): TypeValuePair;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+type Type = "Blob" | "Bool" | "Float4" | "Float8" | "Int1" | "Int2" | "Int4" | "Int8" | "Int16" | "Uint1" | "Uint2" | "Uint4" | "Uint8" | "Uint16" | "Utf8" | "Date" | "DateTime" | "Time" | "Interval" | "Uuid4" | "Uuid7" | "Undefined" | "RowNumber" | "IdentityId";
+interface TypeValuePair {
+    type: Type;
+    value: string;
+}
+declare abstract class Value {
+    abstract readonly type: Type;
+    abstract encode(): TypeValuePair;
+    abstract equals(other: Value): boolean;
+}
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+declare function decode(pair: TypeValuePair): Value;
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+type PrimitiveToTS<T extends Type> = T extends 'Blob' ? Uint8Array : T extends 'Bool' ? boolean : T extends 'Float4' ? number : T extends 'Float8' ? number : T extends 'Int1' ? number : T extends 'Int2' ? number : T extends 'Int4' ? number : T extends 'Int8' ? bigint : T extends 'Int16' ? bigint : T extends 'Uint1' ? number : T extends 'Uint2' ? number : T extends 'Uint4' ? number : T extends 'Uint8' ? bigint : T extends 'Uint16' ? bigint : T extends 'Utf8' ? string : T extends 'Date' ? Date : T extends 'DateTime' ? Date : T extends 'Time' ? string : T extends 'Interval' ? string : T extends 'Uuid4' ? string : T extends 'Uuid7' ? string : T extends 'Undefined' ? undefined : T extends 'RowNumber' ? bigint : T extends 'IdentityId' ? string : never;
+type PrimitiveToValue<T extends Type> = T extends 'Blob' ? BlobValue : T extends 'Bool' ? BoolValue : T extends 'Float4' ? Float4Value : T extends 'Float8' ? Float8Value : T extends 'Int1' ? Int1Value : T extends 'Int2' ? Int2Value : T extends 'Int4' ? Int4Value : T extends 'Int8' ? Int8Value : T extends 'Int16' ? Int16Value : T extends 'Uint1' ? Uint1Value : T extends 'Uint2' ? Uint2Value : T extends 'Uint4' ? Uint4Value : T extends 'Uint8' ? Uint8Value : T extends 'Uint16' ? Uint16Value : T extends 'Utf8' ? Utf8Value : T extends 'Date' ? DateValue : T extends 'DateTime' ? DateTimeValue : T extends 'Time' ? TimeValue : T extends 'Interval' ? IntervalValue : T extends 'Uuid4' ? Uuid4Value : T extends 'Uuid7' ? Uuid7Value : T extends 'Undefined' ? UndefinedValue : T extends 'RowNumber' ? RowNumberValue : T extends 'IdentityId' ? IdentityIdValue : never;
+type InferSchema<S> = S extends PrimitiveSchemaNode<infer T> ? T extends Type ? PrimitiveToTS<T> : never : S extends ValueSchemaNode<infer T> ? T extends Type ? PrimitiveToValue<T> : never : S extends ObjectSchemaNode<infer P> ? {
+    [K in keyof P]: InferSchema<P[K]>;
+} : S extends ArraySchemaNode<infer T> ? InferSchema<T>[] : S extends OptionalSchemaNode<infer T> ? InferSchema<T> | undefined : never;
+type InferSchemas<S extends readonly SchemaNode[]> = {
+    [K in keyof S]: InferSchema<S[K]>[];
+};
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+declare class SchemaBuilder {
+    static blob(): PrimitiveSchemaNode<'Blob'>;
+    static bool(): PrimitiveSchemaNode<'Bool'>;
+    static boolean(): PrimitiveSchemaNode<'Bool'>;
+    static float4(): PrimitiveSchemaNode<'Float4'>;
+    static float8(): PrimitiveSchemaNode<'Float8'>;
+    static float(): PrimitiveSchemaNode<'Float8'>;
+    static double(): PrimitiveSchemaNode<'Float8'>;
+    static int1(): PrimitiveSchemaNode<'Int1'>;
+    static int2(): PrimitiveSchemaNode<'Int2'>;
+    static int4(): PrimitiveSchemaNode<'Int4'>;
+    static int8(): PrimitiveSchemaNode<'Int8'>;
+    static int16(): PrimitiveSchemaNode<'Int16'>;
+    static int(): PrimitiveSchemaNode<'Int4'>;
+    static bigint(): PrimitiveSchemaNode<'Int8'>;
+    static uint1(): PrimitiveSchemaNode<'Uint1'>;
+    static uint2(): PrimitiveSchemaNode<'Uint2'>;
+    static uint4(): PrimitiveSchemaNode<'Uint4'>;
+    static uint8(): PrimitiveSchemaNode<'Uint8'>;
+    static uint16(): PrimitiveSchemaNode<'Uint16'>;
+    static utf8(): PrimitiveSchemaNode<'Utf8'>;
+    static string(): PrimitiveSchemaNode<'Utf8'>;
+    static date(): PrimitiveSchemaNode<'Date'>;
+    static datetime(): PrimitiveSchemaNode<'DateTime'>;
+    static time(): PrimitiveSchemaNode<'Time'>;
+    static interval(): PrimitiveSchemaNode<'Interval'>;
+    static uuid4(): PrimitiveSchemaNode<'Uuid4'>;
+    static uuid7(): PrimitiveSchemaNode<'Uuid7'>;
+    static uuid(): PrimitiveSchemaNode<'Uuid7'>;
+    static undefined(): PrimitiveSchemaNode<'Undefined'>;
+    static rownumber(): PrimitiveSchemaNode<'RowNumber'>;
+    static identityid(): PrimitiveSchemaNode<'IdentityId'>;
+    static object<P extends Record<string, SchemaNode>>(properties: P): ObjectSchemaNode<P>;
+    static array<T extends SchemaNode>(items: T): ArraySchemaNode<T>;
+    static optional<T extends SchemaNode>(schema: T): OptionalSchemaNode<T>;
+    static number(): PrimitiveSchemaNode<'Float8'>;
+    static boolValue(): ValueSchemaNode<'Bool'>;
+    static int1Value(): ValueSchemaNode<'Int1'>;
+    static int2Value(): ValueSchemaNode<'Int2'>;
+    static int4Value(): ValueSchemaNode<'Int4'>;
+    static int8Value(): ValueSchemaNode<'Int8'>;
+    static int16Value(): ValueSchemaNode<'Int16'>;
+    static uint1Value(): ValueSchemaNode<'Uint1'>;
+    static uint2Value(): ValueSchemaNode<'Uint2'>;
+    static uint4Value(): ValueSchemaNode<'Uint4'>;
+    static uint8Value(): ValueSchemaNode<'Uint8'>;
+    static uint16Value(): ValueSchemaNode<'Uint16'>;
+    static float4Value(): ValueSchemaNode<'Float4'>;
+    static float8Value(): ValueSchemaNode<'Float8'>;
+    static utf8Value(): ValueSchemaNode<'Utf8'>;
+    static dateValue(): ValueSchemaNode<'Date'>;
+    static dateTimeValue(): ValueSchemaNode<'DateTime'>;
+    static timeValue(): ValueSchemaNode<'Time'>;
+    static intervalValue(): ValueSchemaNode<'Interval'>;
+    static uuid4Value(): ValueSchemaNode<'Uuid4'>;
+    static uuid7Value(): ValueSchemaNode<'Uuid7'>;
+    static undefinedValue(): ValueSchemaNode<'Undefined'>;
+    static blobValue(): ValueSchemaNode<'Blob'>;
+    static rowIdValue(): ValueSchemaNode<'RowNumber'>;
+    static identityIdValue(): ValueSchemaNode<'IdentityId'>;
+}
+declare const Schema: typeof SchemaBuilder;
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+declare function parseValue(schema: SchemaNode, value: any): any;
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+declare function validateSchema(schema: SchemaNode, value: any): boolean;
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+interface PrimitiveSchemaNode<T extends string = string> {
+    kind: 'primitive';
+    type: T;
+}
+interface ObjectSchemaNode<P extends Record<string, SchemaNode> = Record<string, SchemaNode>> {
+    kind: 'object';
+    properties: P;
+}
+interface ArraySchemaNode<T extends SchemaNode = SchemaNode> {
+    kind: 'array';
+    items: T;
+}
+interface OptionalSchemaNode<T extends SchemaNode = SchemaNode> {
+    kind: 'optional';
+    schema: T;
+}
+interface ValueSchemaNode<T extends string = string> {
+    kind: 'value';
+    type: T;
+}
+type SchemaNode = PrimitiveSchemaNode | ObjectSchemaNode | ArraySchemaNode | OptionalSchemaNode | ValueSchemaNode;
+
+/**
+ * MIT License
+ * Copyright (c) 2025 ReifyDB
+ * See license.md file for full license text
+ */
+
+type Params = (TypeValuePair | null)[] | Record<string, TypeValuePair | null>;
+interface Frame {
+    columns: Column[];
+}
+interface DiagnosticColumn {
+    name: string;
+    ty: Type;
+}
+interface Span {
+    offset: number;
+    line: number;
+    fragment: string;
+}
+interface Diagnostic {
+    code: string;
+    statement?: string;
+    message: string;
+    column?: DiagnosticColumn;
+    span?: Span;
+    label?: string;
+    help?: string;
+    notes: Array<string>;
+    cause?: Diagnostic;
+}
+interface Column {
+    name: string;
+    ty: Type;
+    data: string[];
+}
+interface ErrorResponse {
+    id: string;
+    type: "Err";
+    payload: {
+        diagnostic: Diagnostic;
+    };
+}
+declare class ReifyError extends Error {
+    readonly code: string;
+    readonly statement?: string;
+    readonly column?: DiagnosticColumn;
+    readonly span?: Span;
+    readonly label?: string;
+    readonly help?: string;
+    readonly notes: string[];
+    readonly cause?: Diagnostic;
+    constructor(response: ErrorResponse);
+    toString(): string;
+}
+/**
+ * Simplified type for inferring frame results to avoid deep instantiation
+ * This provides a workaround for TypeScript's limitation with deeply nested types
+ */
+type FrameResults<S extends readonly SchemaNode[]> = S extends readonly [infer First, ...infer Rest] ? First extends SchemaNode ? Rest extends readonly SchemaNode[] ? [InferSchema<First>[], ...FrameResults<Rest>] : [InferSchema<First>[]] : never : [];
+/**
+ * Helper type to extract a single frame result
+ */
+type SingleFrameResult<S extends SchemaNode> = InferSchema<S>[];
+/**
+ * Type-safe cast helper for frame results
+ */
+declare function asFrameResults<S extends readonly SchemaNode[]>(results: any): FrameResults<S>;
+
+export { type ArraySchemaNode, BlobValue, BoolValue, type Column, DateTimeValue, DateValue, type Diagnostic, type DiagnosticColumn, type ErrorResponse, Float4Value, Float8Value, type Frame, type FrameResults, IdentityIdValue, type InferSchema, type InferSchemas, Int16Value, Int1Value, Int2Value, Int4Value, Int8Value, IntervalValue, type ObjectSchemaNode, type OptionalSchemaNode, type Params, type PrimitiveSchemaNode, type PrimitiveToTS, type PrimitiveToValue, ReifyError, RowNumberValue, Schema, SchemaBuilder, type SchemaNode, type SingleFrameResult, type Span, TimeValue, type Type, type TypeValuePair, UNDEFINED_VALUE, Uint16Value, Uint1Value, Uint2Value, Uint4Value, Uint8Value, UndefinedValue, Utf8Value, Uuid4Value, Uuid7Value, Value, type ValueSchemaNode, asFrameResults, decode, parseValue, validateSchema };