@reifydb/core 0.0.1

package/dist/index.js

@@ -0,0 +1,3107 @@
+// src/constant.ts
+var UNDEFINED_VALUE = "\u27EAundefined\u27EB";
+
+// src/value/blob.ts
+var BlobValue = class _BlobValue {
+  constructor(value) {
+    this.type = "Blob";
+    if (value !== void 0) {
+      if (value instanceof Uint8Array) {
+        this.bytes = new Uint8Array(value);
+      } else if (value instanceof ArrayBuffer) {
+        this.bytes = new Uint8Array(value);
+      } else if (typeof value === "string") {
+        const parsed = _BlobValue.parseString(value);
+        if (parsed === null) {
+          throw new Error(`Invalid blob string: ${value}`);
+        }
+        this.bytes = parsed;
+      } else if (Array.isArray(value)) {
+        for (const byte of value) {
+          if (!Number.isInteger(byte) || byte < 0 || byte > 255) {
+            throw new Error(`Invalid byte value: ${byte}`);
+          }
+        }
+        this.bytes = new Uint8Array(value);
+      } else {
+        throw new Error(`Blob value must be a Uint8Array, ArrayBuffer, string, or number[], got ${typeof value}`);
+      }
+    } else {
+      this.bytes = void 0;
+    }
+  }
+  /**
+   * Create a new BLOB from raw bytes
+   */
+  static new(bytes) {
+    return new _BlobValue(bytes);
+  }
+  /**
+   * Create an empty BLOB
+   */
+  static empty() {
+    return new _BlobValue(new Uint8Array(0));
+  }
+  /**
+   * Create a BLOB from a byte array
+   */
+  static fromBytes(bytes) {
+    return new _BlobValue(bytes);
+  }
+  /**
+   * Create a BLOB from a hex string
+   */
+  static fromHex(hex) {
+    const cleanHex = hex.startsWith("0x") || hex.startsWith("0X") ? hex.substring(2) : hex;
+    if (cleanHex.length % 2 !== 0) {
+      throw new Error(`Invalid hex string: odd length`);
+    }
+    const bytes = new Uint8Array(cleanHex.length / 2);
+    for (let i = 0; i < cleanHex.length; i += 2) {
+      const byte = parseInt(cleanHex.substring(i, i + 2), 16);
+      if (isNaN(byte)) {
+        throw new Error(`Invalid hex string: ${hex}`);
+      }
+      bytes[i / 2] = byte;
+    }
+    return new _BlobValue(bytes);
+  }
+  /**
+   * Create a BLOB from a base64 string
+   */
+  static fromBase64(base64) {
+    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(base64)) {
+      throw new Error(`Invalid base64 string: ${base64}`);
+    }
+    try {
+      if (typeof Buffer !== "undefined") {
+        const buffer = Buffer.from(base64, "base64");
+        return new _BlobValue(new Uint8Array(buffer));
+      } else {
+        const binaryString = atob(base64);
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+          bytes[i] = binaryString.charCodeAt(i);
+        }
+        return new _BlobValue(bytes);
+      }
+    } catch (e) {
+      throw new Error(`Invalid base64 string: ${base64}`);
+    }
+  }
+  /**
+   * Create a BLOB from a UTF-8 string
+   */
+  static fromUtf8(str) {
+    const encoder = new TextEncoder();
+    return new _BlobValue(encoder.encode(str));
+  }
+  /**
+   * Parse a blob string (hex or undefined)
+   */
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _BlobValue(void 0);
+    }
+    const parsed = _BlobValue.parseString(trimmed);
+    if (parsed === null) {
+      throw new Error(`Cannot parse "${str}" as Blob`);
+    }
+    return new _BlobValue(parsed);
+  }
+  /**
+   * Get the raw bytes
+   */
+  asBytes() {
+    return this.bytes ? new Uint8Array(this.bytes) : void 0;
+  }
+  /**
+   * Get the length in bytes
+   */
+  length() {
+    return this.bytes?.length ?? 0;
+  }
+  /**
+   * Check if the BLOB is empty
+   */
+  isEmpty() {
+    return this.bytes?.length === 0;
+  }
+  /**
+   * Convert to hex string with 0x prefix
+   */
+  toHex() {
+    if (this.bytes === void 0) return void 0;
+    const hex = Array.from(this.bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+    return "0x" + hex;
+  }
+  /**
+   * Convert to base64 string
+   */
+  toBase64() {
+    if (this.bytes === void 0) return void 0;
+    if (typeof Buffer !== "undefined") {
+      return Buffer.from(this.bytes).toString("base64");
+    } else {
+      const binaryString = Array.from(this.bytes).map((byte) => String.fromCharCode(byte)).join("");
+      return btoa(binaryString);
+    }
+  }
+  /**
+   * Convert to UTF-8 string
+   */
+  toUtf8() {
+    if (this.bytes === void 0) return void 0;
+    const decoder = new TextDecoder();
+    return decoder.decode(this.bytes);
+  }
+  /**
+   * Format as hex string with 0x prefix
+   */
+  toString() {
+    if (this.bytes === void 0) {
+      return "undefined";
+    }
+    return this.toHex();
+  }
+  valueOf() {
+    return this.bytes ? new Uint8Array(this.bytes) : void 0;
+  }
+  /**
+   * Get the internal representation
+   */
+  get value() {
+    return this.valueOf();
+  }
+  /**
+   * Compare two blobs for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherBlob = other;
+    if (this.bytes === void 0 || otherBlob.bytes === void 0) {
+      return this.bytes === otherBlob.bytes;
+    }
+    if (this.bytes.length !== otherBlob.bytes.length) {
+      return false;
+    }
+    for (let i = 0; i < this.bytes.length; i++) {
+      if (this.bytes[i] !== otherBlob.bytes[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Helper to parse a string as hex
+   */
+  static parseString(str) {
+    if (str.startsWith("0x") || str.startsWith("0X")) {
+      try {
+        return _BlobValue.fromHex(str).bytes;
+      } catch {
+        return null;
+      }
+    }
+    if (/^[0-9a-fA-F]+$/.test(str) && str.length % 2 === 0) {
+      try {
+        return _BlobValue.fromHex(str).bytes;
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+
+// src/value/bool.ts
+var BoolValue = class _BoolValue {
+  constructor(value) {
+    this.type = "Bool";
+    if (value !== void 0) {
+      if (typeof value !== "boolean") {
+        throw new Error(`Bool value must be a boolean, got ${typeof value}`);
+      }
+      this.value = value;
+    } else {
+      this.value = void 0;
+    }
+  }
+  static parse(str) {
+    const trimmed = str.trim().toLowerCase();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _BoolValue(void 0);
+    }
+    if (trimmed === "true") {
+      return new _BoolValue(true);
+    }
+    if (trimmed === "false") {
+      return new _BoolValue(false);
+    }
+    throw new Error(`Cannot parse "${str}" as Bool`);
+  }
+  valueOf() {
+    return this.value;
+  }
+  toString() {
+    return this.value === void 0 ? "undefined" : this.value.toString();
+  }
+  /**
+   * Compare two boolean values for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherBool = other;
+    return this.value === otherBool.value;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+
+// src/value/date.ts
+var DateValue = class _DateValue {
+  // day of month (1-31)
+  constructor(value) {
+    this.type = "Date";
+    if (value !== void 0) {
+      if (value instanceof Date) {
+        const year = value.getUTCFullYear();
+        const month = value.getUTCMonth() + 1;
+        const day = value.getUTCDate();
+        this.months = year * 12 + (month - 1);
+        this.days = day;
+      } else if (typeof value === "string") {
+        const parsed = _DateValue.parseDate(value);
+        if (!parsed) {
+          throw new Error(`Invalid date string: ${value}`);
+        }
+        this.months = parsed.months;
+        this.days = parsed.days;
+      } else if (typeof value === "number") {
+        const date = _DateValue.fromDaysSinceEpochToComponents(value);
+        if (!date) {
+          throw new Error(`Invalid days since epoch: ${value}`);
+        }
+        this.months = date.months;
+        this.days = date.days;
+      } else {
+        throw new Error(`Date value must be a Date, string, or number, got ${typeof value}`);
+      }
+    } else {
+      this.months = void 0;
+      this.days = void 0;
+    }
+  }
+  /**
+   * Create a DateValue from year, month (1-12), and day (1-31)
+   */
+  static fromYMD(year, month, day) {
+    if (!_DateValue.isValidDate(year, month, day)) {
+      throw new Error(`Invalid date: ${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`);
+    }
+    const result = new _DateValue(void 0);
+    result.months = year * 12 + (month - 1);
+    result.days = day;
+    return result;
+  }
+  /**
+   * Get today's date (in UTC)
+   */
+  static today() {
+    const now = /* @__PURE__ */ new Date();
+    return _DateValue.fromYMD(
+      now.getUTCFullYear(),
+      now.getUTCMonth() + 1,
+      now.getUTCDate()
+    );
+  }
+  /**
+   * Parse a date string in YYYY-MM-DD format
+   */
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _DateValue(void 0);
+    }
+    const parsed = _DateValue.parseDate(trimmed);
+    if (!parsed) {
+      throw new Error(`Cannot parse "${str}" as Date`);
+    }
+    const result = new _DateValue(void 0);
+    result.months = parsed.months;
+    result.days = parsed.days;
+    return result;
+  }
+  /**
+   * Convert to days since Unix epoch (1970-01-01) for storage
+   */
+  toDaysSinceEpoch() {
+    if (this.months === void 0 || this.days === void 0) {
+      return void 0;
+    }
+    const year = Math.floor(this.months / 12);
+    let m = this.months % 12;
+    if (m < 0) m += 12;
+    const month = m + 1;
+    let date;
+    if (year >= 0 && year < 100) {
+      date = new Date(Date.UTC(2e3, month - 1, this.days));
+      date.setUTCFullYear(year);
+    } else {
+      date = new Date(Date.UTC(year, month - 1, this.days));
+    }
+    const epoch = new Date(Date.UTC(1970, 0, 1));
+    const diffMs = date.getTime() - epoch.getTime();
+    return Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+  }
+  /**
+   * Create from days since Unix epoch
+   */
+  static fromDaysSinceEpochToComponents(days) {
+    const epoch = new Date(Date.UTC(1970, 0, 1));
+    const ms = days * 24 * 60 * 60 * 1e3;
+    const date = new Date(epoch.getTime() + ms);
+    if (!isFinite(date.getTime())) {
+      return null;
+    }
+    const year = date.getUTCFullYear();
+    const month = date.getUTCMonth() + 1;
+    const day = date.getUTCDate();
+    return {
+      months: year * 12 + (month - 1),
+      days: day
+    };
+  }
+  /**
+   * Get the year component
+   */
+  year() {
+    if (this.months === void 0) return void 0;
+    return Math.floor(this.months / 12);
+  }
+  /**
+   * Get the month component (1-12)
+   */
+  month() {
+    if (this.months === void 0) return void 0;
+    let m = this.months % 12;
+    if (m < 0) m += 12;
+    return m + 1;
+  }
+  /**
+   * Get the day component (1-31)
+   */
+  day() {
+    return this.days;
+  }
+  /**
+   * Format as YYYY-MM-DD string
+   */
+  toString() {
+    if (this.months === void 0 || this.days === void 0) {
+      return "undefined";
+    }
+    const year = Math.floor(this.months / 12);
+    let m = this.months % 12;
+    if (m < 0) m += 12;
+    const month = String(m + 1).padStart(2, "0");
+    const day = String(this.days).padStart(2, "0");
+    if (year < 0) {
+      const absYear = Math.abs(year);
+      return `-${String(absYear).padStart(4, "0")}-${month}-${day}`;
+    } else {
+      return `${String(year).padStart(4, "0")}-${month}-${day}`;
+    }
+  }
+  valueOf() {
+    if (this.months === void 0 || this.days === void 0) {
+      return void 0;
+    }
+    const year = Math.floor(this.months / 12);
+    let m = this.months % 12;
+    if (m < 0) m += 12;
+    const month = m + 1;
+    let date;
+    if (year >= 0 && year < 100) {
+      date = new Date(Date.UTC(2e3, month - 1, this.days));
+      date.setUTCFullYear(year);
+    } else {
+      date = new Date(Date.UTC(year, month - 1, this.days));
+    }
+    return date;
+  }
+  /**
+   * Get the internal representation
+   */
+  get value() {
+    return this.valueOf();
+  }
+  /**
+   * Helper to parse YYYY-MM-DD format
+   */
+  static parseDate(str) {
+    const match = str.match(/^(-?\d{1,4})-(\d{2})-(\d{2})$/);
+    if (!match) {
+      return null;
+    }
+    const year = parseInt(match[1], 10);
+    const month = parseInt(match[2], 10);
+    const day = parseInt(match[3], 10);
+    if (month < 1 || month > 12) {
+      return null;
+    }
+    if (day < 1 || day > 31) {
+      return null;
+    }
+    if (!_DateValue.isValidDate(year, month, day)) {
+      return null;
+    }
+    return {
+      months: year * 12 + (month - 1),
+      days: day
+    };
+  }
+  /**
+   * Helper to validate a date
+   */
+  static isValidDate(year, month, day) {
+    let date;
+    if (year >= 0 && year < 100) {
+      date = new Date(Date.UTC(2e3, month - 1, day));
+      date.setUTCFullYear(year);
+    } else {
+      date = new Date(Date.UTC(year, month - 1, day));
+    }
+    return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+  }
+  /**
+   * Compare two dates for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherDate = other;
+    if (this.months === void 0 || otherDate.months === void 0) {
+      return this.months === otherDate.months && this.days === otherDate.days;
+    }
+    return this.months === otherDate.months && this.days === otherDate.days;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+
+// src/value/time.ts
+var _TimeValue = class _TimeValue {
+  constructor(value) {
+    this.type = "Time";
+    if (value !== void 0) {
+      if (typeof value === "bigint") {
+        if (value < 0n || value >= _TimeValue.NANOS_PER_DAY) {
+          throw new Error(`Time value must be between 0 and ${_TimeValue.NANOS_PER_DAY - 1n} nanoseconds`);
+        }
+        this.value = value;
+      } else if (typeof value === "string") {
+        const parsed = _TimeValue.parseTime(value);
+        if (parsed === null) {
+          throw new Error(`Invalid time string: ${value}`);
+        }
+        this.value = parsed;
+      } else if (typeof value === "number") {
+        const bigintValue = BigInt(Math.floor(value));
+        if (bigintValue < 0n || bigintValue >= _TimeValue.NANOS_PER_DAY) {
+          throw new Error(`Time value must be between 0 and ${_TimeValue.NANOS_PER_DAY - 1n} nanoseconds`);
+        }
+        this.value = bigintValue;
+      } else {
+        throw new Error(`Time value must be a bigint, string, or number, got ${typeof value}`);
+      }
+    } else {
+      this.value = void 0;
+    }
+  }
+  /**
+   * Create a TimeValue from hour, minute, second, and nanosecond
+   */
+  static fromHMSN(hour, minute, second, nano = 0) {
+    if (hour < 0 || hour > 23) {
+      throw new Error(`Invalid hour: ${hour}`);
+    }
+    if (minute < 0 || minute > 59) {
+      throw new Error(`Invalid minute: ${minute}`);
+    }
+    if (second < 0 || second > 59) {
+      throw new Error(`Invalid second: ${second}`);
+    }
+    if (nano < 0 || nano > 999999999) {
+      throw new Error(`Invalid nanosecond: ${nano}`);
+    }
+    const nanos = BigInt(hour) * _TimeValue.NANOS_PER_HOUR + BigInt(minute) * _TimeValue.NANOS_PER_MINUTE + BigInt(second) * _TimeValue.NANOS_PER_SECOND + BigInt(nano);
+    return new _TimeValue(nanos);
+  }
+  /**
+   * Create a TimeValue from hour, minute, and second (no fractional seconds)
+   */
+  static fromHMS(hour, minute, second) {
+    return _TimeValue.fromHMSN(hour, minute, second, 0);
+  }
+  /**
+   * Create midnight (00:00:00.000000000)
+   */
+  static midnight() {
+    return new _TimeValue(0n);
+  }
+  /**
+   * Create noon (12:00:00.000000000)
+   */
+  static noon() {
+    return new _TimeValue(12n * _TimeValue.NANOS_PER_HOUR);
+  }
+  /**
+   * Parse a time string in HH:MM:SS[.nnnnnnnnn] format
+   */
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _TimeValue(void 0);
+    }
+    const parsed = _TimeValue.parseTime(trimmed);
+    if (parsed === null) {
+      throw new Error(`Cannot parse "${str}" as Time`);
+    }
+    return new _TimeValue(parsed);
+  }
+  /**
+   * Get the hour component (0-23)
+   */
+  hour() {
+    if (this.value === void 0) return void 0;
+    return Number(this.value / _TimeValue.NANOS_PER_HOUR);
+  }
+  /**
+   * Get the minute component (0-59)
+   */
+  minute() {
+    if (this.value === void 0) return void 0;
+    const remainingAfterHours = this.value % _TimeValue.NANOS_PER_HOUR;
+    return Number(remainingAfterHours / _TimeValue.NANOS_PER_MINUTE);
+  }
+  /**
+   * Get the second component (0-59)
+   */
+  second() {
+    if (this.value === void 0) return void 0;
+    const remainingAfterHours = this.value % _TimeValue.NANOS_PER_HOUR;
+    const remainingAfterMinutes = remainingAfterHours % _TimeValue.NANOS_PER_MINUTE;
+    return Number(remainingAfterMinutes / _TimeValue.NANOS_PER_SECOND);
+  }
+  /**
+   * Get the nanosecond component (0-999999999)
+   */
+  nanosecond() {
+    if (this.value === void 0) return void 0;
+    return Number(this.value % _TimeValue.NANOS_PER_SECOND);
+  }
+  /**
+   * Convert to nanoseconds since midnight for storage
+   */
+  toNanosSinceMidnight() {
+    return this.value;
+  }
+  /**
+   * Create from nanoseconds since midnight
+   */
+  static fromNanosSinceMidnight(nanos) {
+    return new _TimeValue(typeof nanos === "number" ? BigInt(nanos) : nanos);
+  }
+  /**
+   * Format as HH:MM:SS.nnnnnnnnn string
+   */
+  toString() {
+    if (this.value === void 0) {
+      return "undefined";
+    }
+    const hour = this.hour();
+    const minute = this.minute();
+    const second = this.second();
+    const nano = this.nanosecond();
+    const hourStr = String(hour).padStart(2, "0");
+    const minuteStr = String(minute).padStart(2, "0");
+    const secondStr = String(second).padStart(2, "0");
+    const nanoStr = String(nano).padStart(9, "0");
+    return `${hourStr}:${minuteStr}:${secondStr}.${nanoStr}`;
+  }
+  valueOf() {
+    return this.value;
+  }
+  /**
+   * Helper to parse HH:MM:SS[.nnnnnnnnn] format
+   */
+  static parseTime(str) {
+    const match = str.match(/^(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))?$/);
+    if (!match) {
+      return null;
+    }
+    const hour = parseInt(match[1], 10);
+    const minute = parseInt(match[2], 10);
+    const second = parseInt(match[3], 10);
+    let nano = 0;
+    if (match[4]) {
+      const fracStr = match[4].padEnd(9, "0").substring(0, 9);
+      nano = parseInt(fracStr, 10);
+    }
+    if (hour < 0 || hour > 23) {
+      return null;
+    }
+    if (minute < 0 || minute > 59) {
+      return null;
+    }
+    if (second < 0 || second > 59) {
+      return null;
+    }
+    const nanos = BigInt(hour) * _TimeValue.NANOS_PER_HOUR + BigInt(minute) * _TimeValue.NANOS_PER_MINUTE + BigInt(second) * _TimeValue.NANOS_PER_SECOND + BigInt(nano);
+    return nanos;
+  }
+  /**
+   * Compare two Time values for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherTime = other;
+    return this.value === otherTime.value;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+// nanoseconds since midnight
+_TimeValue.NANOS_PER_SECOND = 1000000000n;
+_TimeValue.NANOS_PER_MINUTE = 60000000000n;
+_TimeValue.NANOS_PER_HOUR = 3600000000000n;
+_TimeValue.NANOS_PER_DAY = 86400000000000n;
+var TimeValue = _TimeValue;
+
+// src/value/datetime.ts
+var DateTimeValue = class _DateTimeValue {
+  // nanoseconds since midnight
+  constructor(value) {
+    this.type = "DateTime";
+    if (value !== void 0) {
+      if (value instanceof Date) {
+        const year = value.getUTCFullYear();
+        const month = value.getUTCMonth() + 1;
+        const day = value.getUTCDate();
+        const hour = value.getUTCHours();
+        const minute = value.getUTCMinutes();
+        const second = value.getUTCSeconds();
+        const millis = value.getUTCMilliseconds();
+        this.months = year * 12 + (month - 1);
+        this.days = day;
+        this.nanos = BigInt(hour) * 3600000000000n + BigInt(minute) * 60000000000n + BigInt(second) * 1000000000n + BigInt(millis) * 1000000n;
+      } else if (typeof value === "string") {
+        const parsed = _DateTimeValue.parseDateTime(value);
+        if (!parsed) {
+          throw new Error(`Invalid datetime string: ${value}`);
+        }
+        this.months = parsed.months;
+        this.days = parsed.days;
+        this.nanos = parsed.nanos;
+      } else if (typeof value === "number") {
+        const date = new Date(value);
+        const year = date.getUTCFullYear();
+        const month = date.getUTCMonth() + 1;
+        const day = date.getUTCDate();
+        const hour = date.getUTCHours();
+        const minute = date.getUTCMinutes();
+        const second = date.getUTCSeconds();
+        const millis = date.getUTCMilliseconds();
+        this.months = year * 12 + (month - 1);
+        this.days = day;
+        this.nanos = BigInt(hour) * 3600000000000n + BigInt(minute) * 60000000000n + BigInt(second) * 1000000000n + BigInt(millis) * 1000000n;
+      } else if (typeof value === "bigint") {
+        const millis = Number(value / 1000000n);
+        const extraNanos = value % 1000000n;
+        const date = new Date(millis);
+        const year = date.getUTCFullYear();
+        const month = date.getUTCMonth() + 1;
+        const day = date.getUTCDate();
+        const hour = date.getUTCHours();
+        const minute = date.getUTCMinutes();
+        const second = date.getUTCSeconds();
+        const dateMillis = date.getUTCMilliseconds();
+        this.months = year * 12 + (month - 1);
+        this.days = day;
+        this.nanos = BigInt(hour) * 3600000000000n + BigInt(minute) * 60000000000n + BigInt(second) * 1000000000n + BigInt(dateMillis) * 1000000n + extraNanos;
+      } else {
+        throw new Error(`DateTime value must be a Date, string, number, or bigint, got ${typeof value}`);
+      }
+    } else {
+      this.months = void 0;
+      this.days = void 0;
+      this.nanos = void 0;
+    }
+  }
+  /**
+   * Create a DateTimeValue from year, month, day, hour, minute, second, nanosecond
+   */
+  static fromYMDHMSN(year, month, day, hour, minute, second, nano = 0) {
+    if (hour < 0 || hour > 23) {
+      throw new Error(`Invalid hour: ${hour}`);
+    }
+    if (minute < 0 || minute > 59) {
+      throw new Error(`Invalid minute: ${minute}`);
+    }
+    if (second < 0 || second > 59) {
+      throw new Error(`Invalid second: ${second}`);
+    }
+    if (nano < 0 || nano > 999999999) {
+      throw new Error(`Invalid nanosecond: ${nano}`);
+    }
+    if (!_DateTimeValue.isValidDate(year, month, day)) {
+      throw new Error(`Invalid datetime: ${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")} ${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}:${String(second).padStart(2, "0")}`);
+    }
+    const result = new _DateTimeValue(void 0);
+    result.months = year * 12 + (month - 1);
+    result.days = day;
+    result.nanos = BigInt(hour) * 3600000000000n + BigInt(minute) * 60000000000n + BigInt(second) * 1000000000n + BigInt(nano);
+    return result;
+  }
+  /**
+   * Create a DateTimeValue from year, month, day, hour, minute, second (no fractional)
+   */
+  static fromYMDHMS(year, month, day, hour, minute, second) {
+    return _DateTimeValue.fromYMDHMSN(year, month, day, hour, minute, second, 0);
+  }
+  /**
+   * Create from Unix timestamp in seconds
+   */
+  static fromTimestamp(seconds) {
+    return new _DateTimeValue(seconds * 1e3);
+  }
+  /**
+   * Create from Unix timestamp in milliseconds
+   */
+  static fromTimestampMillis(millis) {
+    return new _DateTimeValue(millis);
+  }
+  /**
+   * Create from nanoseconds since Unix epoch
+   */
+  static fromNanosSinceEpoch(nanos) {
+    return new _DateTimeValue(nanos);
+  }
+  /**
+   * Create from separate seconds and nanoseconds
+   */
+  static fromParts(seconds, nanos) {
+    if (nanos < 0 || nanos > 999999999) {
+      throw new Error(`Invalid nanoseconds: ${nanos}`);
+    }
+    const millis = seconds * 1e3 + Math.floor(nanos / 1e6);
+    const extraNanos = nanos % 1e6;
+    const result = new _DateTimeValue(millis);
+    if (result.nanos !== void 0) {
+      result.nanos = result.nanos + BigInt(extraNanos);
+    }
+    return result;
+  }
+  /**
+   * Get current datetime
+   */
+  static now() {
+    return new _DateTimeValue(/* @__PURE__ */ new Date());
+  }
+  /**
+   * Get default datetime (Unix epoch)
+   */
+  static default() {
+    return _DateTimeValue.fromYMDHMS(1970, 1, 1, 0, 0, 0);
+  }
+  /**
+   * Parse a datetime string in ISO 8601 format
+   */
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _DateTimeValue(void 0);
+    }
+    const parsed = _DateTimeValue.parseDateTime(trimmed);
+    if (!parsed) {
+      throw new Error(`Cannot parse "${str}" as DateTime`);
+    }
+    const result = new _DateTimeValue(void 0);
+    result.months = parsed.months;
+    result.days = parsed.days;
+    result.nanos = parsed.nanos;
+    return result;
+  }
+  /**
+   * Get Unix timestamp in seconds
+   */
+  timestamp() {
+    const date = this.valueOf();
+    if (date === void 0) return void 0;
+    return Math.floor(date.getTime() / 1e3);
+  }
+  /**
+   * Get Unix timestamp in nanoseconds
+   */
+  timestampNanos() {
+    const date = this.valueOf();
+    if (date === void 0 || this.nanos === void 0) return void 0;
+    const epochNanos = BigInt(date.getTime()) * 1000000n;
+    const subMillisNanos = this.nanos % 1000000n;
+    return epochNanos + subMillisNanos;
+  }
+  /**
+   * Convert to nanoseconds since Unix epoch for storage
+   */
+  toNanosSinceEpoch() {
+    return this.timestampNanos();
+  }
+  /**
+   * Get separate seconds and nanoseconds for storage
+   */
+  toParts() {
+    const date = this.valueOf();
+    if (date === void 0 || this.nanos === void 0) return void 0;
+    const seconds = Math.floor(date.getTime() / 1e3);
+    const millis = date.getTime() % 1e3;
+    const subMillisNanos = Number(this.nanos % 1000000n);
+    const nanos = millis * 1e6 + subMillisNanos;
+    return [seconds, nanos];
+  }
+  /**
+   * Get the date component
+   */
+  date() {
+    if (this.months === void 0 || this.days === void 0) return void 0;
+    const year = Math.floor(this.months / 12);
+    let m = this.months % 12;
+    if (m < 0) m += 12;
+    const month = m + 1;
+    return DateValue.fromYMD(year, month, this.days);
+  }
+  /**
+   * Get the time component
+   */
+  time() {
+    if (this.nanos === void 0) return void 0;
+    return new TimeValue(this.nanos);
+  }
+  /**
+   * Format as ISO 8601 string with nanosecond precision and Z suffix
+   */
+  toString() {
+    if (this.months === void 0 || this.days === void 0 || this.nanos === void 0) {
+      return "undefined";
+    }
+    const year = Math.floor(this.months / 12);
+    let m = this.months % 12;
+    if (m < 0) m += 12;
+    const month = String(m + 1).padStart(2, "0");
+    const day = String(this.days).padStart(2, "0");
+    const totalNanos = this.nanos;
+    const hours = totalNanos / 3600000000000n;
+    const remainingAfterHours = totalNanos % 3600000000000n;
+    const minutes = remainingAfterHours / 60000000000n;
+    const remainingAfterMinutes = remainingAfterHours % 60000000000n;
+    const seconds = remainingAfterMinutes / 1000000000n;
+    const nanosFraction = remainingAfterMinutes % 1000000000n;
+    const hour = String(Number(hours)).padStart(2, "0");
+    const minute = String(Number(minutes)).padStart(2, "0");
+    const second = String(Number(seconds)).padStart(2, "0");
+    const nanoStr = String(Number(nanosFraction)).padStart(9, "0");
+    let yearStr;
+    if (year < 0) {
+      const absYear = Math.abs(year);
+      yearStr = `-${String(absYear).padStart(4, "0")}`;
+    } else {
+      yearStr = String(year).padStart(4, "0");
+    }
+    return `${yearStr}-${month}-${day}T${hour}:${minute}:${second}.${nanoStr}Z`;
+  }
+  valueOf() {
+    if (this.months === void 0 || this.days === void 0 || this.nanos === void 0) {
+      return void 0;
+    }
+    const year = Math.floor(this.months / 12);
+    let m = this.months % 12;
+    if (m < 0) m += 12;
+    const month = m + 1;
+    const totalNanos = this.nanos;
+    const hours = Number(totalNanos / 3600000000000n);
+    const remainingAfterHours = totalNanos % 3600000000000n;
+    const minutes = Number(remainingAfterHours / 60000000000n);
+    const remainingAfterMinutes = remainingAfterHours % 60000000000n;
+    const seconds = Number(remainingAfterMinutes / 1000000000n);
+    const nanosFraction = remainingAfterMinutes % 1000000000n;
+    const millis = Number(nanosFraction / 1000000n);
+    let date;
+    if (year >= 0 && year < 100) {
+      date = new Date(Date.UTC(2e3, month - 1, this.days, hours, minutes, seconds, millis));
+      date.setUTCFullYear(year);
+    } else {
+      date = new Date(Date.UTC(year, month - 1, this.days, hours, minutes, seconds, millis));
+    }
+    return date;
+  }
+  /**
+   * Get the internal representation as a Date
+   */
+  get value() {
+    return this.valueOf();
+  }
+  /**
+   * Helper to parse ISO 8601 datetime format
+   */
+  static parseDateTime(str) {
+    const match = str.match(/^(-?\d{1,4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))?Z$/);
+    if (!match) {
+      return null;
+    }
+    const year = parseInt(match[1], 10);
+    const month = parseInt(match[2], 10);
+    const day = parseInt(match[3], 10);
+    const hour = parseInt(match[4], 10);
+    const minute = parseInt(match[5], 10);
+    const second = parseInt(match[6], 10);
+    let nanosFraction = 0n;
+    if (match[7]) {
+      const fracStr = match[7].padEnd(9, "0").substring(0, 9);
+      nanosFraction = BigInt(fracStr);
+    }
+    if (month < 1 || month > 12) {
+      return null;
+    }
+    if (day < 1 || day > 31) {
+      return null;
+    }
+    if (hour < 0 || hour > 23) {
+      return null;
+    }
+    if (minute < 0 || minute > 59) {
+      return null;
+    }
+    if (second < 0 || second > 59) {
+      return null;
+    }
+    if (!_DateTimeValue.isValidDate(year, month, day)) {
+      return null;
+    }
+    const months = year * 12 + (month - 1);
+    const nanos = BigInt(hour) * 3600000000000n + BigInt(minute) * 60000000000n + BigInt(second) * 1000000000n + nanosFraction;
+    return { months, days: day, nanos };
+  }
+  /**
+   * Helper to validate a date
+   */
+  static isValidDate(year, month, day) {
+    let date;
+    if (year >= 0 && year < 100) {
+      date = new Date(Date.UTC(2e3, month - 1, day));
+      date.setUTCFullYear(year);
+    } else {
+      date = new Date(Date.UTC(year, month - 1, day));
+    }
+    return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+  }
+  /**
+   * Compare two datetimes for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherDateTime = other;
+    if (this.months === void 0 || otherDateTime.months === void 0) {
+      return this.months === otherDateTime.months && this.days === otherDateTime.days && this.nanos === otherDateTime.nanos;
+    }
+    return this.months === otherDateTime.months && this.days === otherDateTime.days && this.nanos === otherDateTime.nanos;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+
+// src/value/float4.ts
+var _Float4Value = class _Float4Value {
+  constructor(value) {
+    this.type = "Float4";
+    if (value !== void 0) {
+      if (typeof value !== "number") {
+        throw new Error(`Float4 value must be a number, got ${typeof value}`);
+      }
+      if (Number.isNaN(value) || !Number.isFinite(value)) {
+        this.value = void 0;
+      } else {
+        if (value !== 0 && Math.abs(value) < _Float4Value.MIN_POSITIVE) {
+          this.value = 0;
+        } else if (value > _Float4Value.MAX_VALUE) {
+          throw new Error(`Float4 overflow: value ${value} exceeds maximum ${_Float4Value.MAX_VALUE}`);
+        } else if (value < _Float4Value.MIN_VALUE) {
+          throw new Error(`Float4 underflow: value ${value} exceeds minimum ${_Float4Value.MIN_VALUE}`);
+        } else {
+          const float32Array = new Float32Array(1);
+          float32Array[0] = value;
+          this.value = float32Array[0];
+        }
+      }
+    } else {
+      this.value = void 0;
+    }
+  }
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _Float4Value(void 0);
+    }
+    const num = Number(trimmed);
+    if (Number.isNaN(num) && trimmed.toLowerCase() !== "nan") {
+      throw new Error(`Cannot parse "${str}" as Float4`);
+    }
+    return new _Float4Value(num);
+  }
+  valueOf() {
+    return this.value;
+  }
+  toString() {
+    return this.value === void 0 ? "undefined" : this.value.toString();
+  }
+  /**
+   * Compare two Float4 values for equality with limited precision
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherFloat = other;
+    if (this.value === void 0 || otherFloat.value === void 0) {
+      return this.value === otherFloat.value;
+    }
+    const epsilon = 1e-6;
+    return Math.abs(this.value - otherFloat.value) <= epsilon;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+_Float4Value.MAX_VALUE = 34028235e31;
+_Float4Value.MIN_VALUE = -34028235e31;
+_Float4Value.MIN_POSITIVE = 1175494e-44;
+var Float4Value = _Float4Value;
+
+// src/value/float8.ts
+var Float8Value = class _Float8Value {
+  constructor(value) {
+    this.type = "Float8";
+    if (value !== void 0) {
+      if (typeof value !== "number") {
+        throw new Error(`Float8 value must be a number, got ${typeof value}`);
+      }
+      this.value = value;
+    } else {
+      this.value = void 0;
+    }
+  }
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _Float8Value(void 0);
+    }
+    const num = Number(trimmed);
+    if (Number.isNaN(num) && trimmed.toLowerCase() !== "nan") {
+      throw new Error(`Cannot parse "${str}" as Float8`);
+    }
+    return new _Float8Value(num);
+  }
+  valueOf() {
+    return this.value;
+  }
+  toString() {
+    return this.value === void 0 ? "undefined" : this.value.toString();
+  }
+  /**
+   * Compare two Float8 values for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherFloat = other;
+    return this.value === otherFloat.value;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+
+// src/value/int1.ts
+var _Int1Value = class _Int1Value {
+  constructor(value) {
+    this.type = "Int1";
+    if (value !== void 0) {
+      if (!Number.isInteger(value)) {
+        throw new Error(`Int1 value must be an integer, got ${value}`);
+      }
+      if (value < _Int1Value.MIN_VALUE || value > _Int1Value.MAX_VALUE) {
+        throw new Error(`Int1 value must be between ${_Int1Value.MIN_VALUE} and ${_Int1Value.MAX_VALUE}, got ${value}`);
+      }
+    }
+    this.value = value;
+  }
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _Int1Value(void 0);
+    }
+    const num = Number(trimmed);
+    if (isNaN(num)) {
+      throw new Error(`Cannot parse "${str}" as Int1`);
+    }
+    return new _Int1Value(num);
+  }
+  valueOf() {
+    return this.value;
+  }
+  toString() {
+    return this.value === void 0 ? "undefined" : this.value.toString();
+  }
+  /**
+   * Compare two Int1 values for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherInt = other;
+    return this.value === otherInt.value;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+_Int1Value.MIN_VALUE = -128;
+_Int1Value.MAX_VALUE = 127;
+var Int1Value = _Int1Value;
+
+// src/value/int2.ts
+var _Int2Value = class _Int2Value {
+  constructor(value) {
+    this.type = "Int2";
+    if (value !== void 0) {
+      if (!Number.isInteger(value)) {
+        throw new Error(`Int2 value must be an integer, got ${value}`);
+      }
+      if (value < _Int2Value.MIN_VALUE || value > _Int2Value.MAX_VALUE) {
+        throw new Error(`Int2 value must be between ${_Int2Value.MIN_VALUE} and ${_Int2Value.MAX_VALUE}, got ${value}`);
+      }
+    }
+    this.value = value;
+  }
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _Int2Value(void 0);
+    }
+    const num = Number(trimmed);
+    if (isNaN(num)) {
+      throw new Error(`Cannot parse "${str}" as Int2`);
+    }
+    return new _Int2Value(num);
+  }
+  valueOf() {
+    return this.value;
+  }
+  toString() {
+    return this.value === void 0 ? "undefined" : this.value.toString();
+  }
+  /**
+   * Compare two Int2 values for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherInt = other;
+    return this.value === otherInt.value;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+_Int2Value.MIN_VALUE = -32768;
+_Int2Value.MAX_VALUE = 32767;
+var Int2Value = _Int2Value;
+
+// src/value/int4.ts
+var _Int4Value = class _Int4Value {
+  constructor(value) {
+    this.type = "Int4";
+    if (value !== void 0) {
+      if (!Number.isInteger(value)) {
+        throw new Error(`Int4 value must be an integer, got ${value}`);
+      }
+      if (value < _Int4Value.MIN_VALUE || value > _Int4Value.MAX_VALUE) {
+        throw new Error(`Int4 value must be between ${_Int4Value.MIN_VALUE} and ${_Int4Value.MAX_VALUE}, got ${value}`);
+      }
+    }
+    this.value = value;
+  }
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _Int4Value(void 0);
+    }
+    const num = Number(trimmed);
+    if (isNaN(num)) {
+      throw new Error(`Cannot parse "${str}" as Int4`);
+    }
+    return new _Int4Value(num);
+  }
+  valueOf() {
+    return this.value;
+  }
+  toString() {
+    return this.value === void 0 ? "undefined" : this.value.toString();
+  }
+  /**
+   * Compare two Int4 values for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherInt = other;
+    return this.value === otherInt.value;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+_Int4Value.MIN_VALUE = -2147483648;
+_Int4Value.MAX_VALUE = 2147483647;
+var Int4Value = _Int4Value;
+
+// src/value/int8.ts
+var _Int8Value = class _Int8Value {
+  constructor(value) {
+    this.type = "Int8";
+    if (value !== void 0) {
+      const bigintValue = typeof value === "number" ? BigInt(Math.trunc(value)) : value;
+      if (bigintValue < _Int8Value.MIN_VALUE || bigintValue > _Int8Value.MAX_VALUE) {
+        throw new Error(`Int8 value must be between ${_Int8Value.MIN_VALUE} and ${_Int8Value.MAX_VALUE}, got ${bigintValue}`);
+      }
+      this.value = bigintValue;
+    } else {
+      this.value = void 0;
+    }
+  }
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _Int8Value(void 0);
+    }
+    let value;
+    try {
+      value = BigInt(trimmed);
+    } catch (e) {
+      throw new Error(`Cannot parse "${str}" as Int8`);
+    }
+    if (value < _Int8Value.MIN_VALUE || value > _Int8Value.MAX_VALUE) {
+      throw new Error(`Int8 value must be between ${_Int8Value.MIN_VALUE} and ${_Int8Value.MAX_VALUE}, got ${value}`);
+    }
+    return new _Int8Value(value);
+  }
+  valueOf() {
+    return this.value;
+  }
+  toString() {
+    return this.value === void 0 ? "undefined" : this.value.toString();
+  }
+  /**
+   * Compare two Int8 values for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherInt = other;
+    return this.value === otherInt.value;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+_Int8Value.MIN_VALUE = BigInt("-9223372036854775808");
+_Int8Value.MAX_VALUE = BigInt("9223372036854775807");
+var Int8Value = _Int8Value;
+
+// src/value/int16.ts
+var _Int16Value = class _Int16Value {
+  constructor(value) {
+    this.type = "Int16";
+    if (value !== void 0) {
+      let bigintValue;
+      if (typeof value === "string") {
+        try {
+          bigintValue = BigInt(value);
+        } catch (e) {
+          throw new Error(`Int16 value must be a valid integer, got ${value}`);
+        }
+      } else if (typeof value === "number") {
+        bigintValue = BigInt(Math.trunc(value));
+      } else {
+        bigintValue = value;
+      }
+      if (bigintValue < _Int16Value.MIN_VALUE || bigintValue > _Int16Value.MAX_VALUE) {
+        throw new Error(`Int16 value must be between ${_Int16Value.MIN_VALUE} and ${_Int16Value.MAX_VALUE}, got ${bigintValue}`);
+      }
+      this.value = bigintValue;
+    } else {
+      this.value = void 0;
+    }
+  }
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _Int16Value(void 0);
+    }
+    let value;
+    try {
+      value = BigInt(trimmed);
+    } catch (e) {
+      throw new Error(`Cannot parse "${str}" as Int16`);
+    }
+    if (value < _Int16Value.MIN_VALUE || value > _Int16Value.MAX_VALUE) {
+      throw new Error(`Int16 value must be between ${_Int16Value.MIN_VALUE} and ${_Int16Value.MAX_VALUE}, got ${value}`);
+    }
+    return new _Int16Value(value);
+  }
+  valueOf() {
+    return this.value;
+  }
+  toString() {
+    return this.value === void 0 ? "undefined" : this.value.toString();
+  }
+  /**
+   * Compare two Int16 values for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherInt = other;
+    return this.value === otherInt.value;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+_Int16Value.MIN_VALUE = BigInt("-170141183460469231731687303715884105728");
+_Int16Value.MAX_VALUE = BigInt("170141183460469231731687303715884105727");
+var Int16Value = _Int16Value;
+
+// src/value/interval.ts
+var IntervalValue = class _IntervalValue {
+  // all time components as nanoseconds
+  constructor(value) {
+    this.type = "Interval";
+    if (value !== void 0) {
+      if (typeof value === "string") {
+        const parsed = _IntervalValue.parseDuration(value);
+        if (!parsed) {
+          throw new Error(`Invalid interval string: ${value}`);
+        }
+        this.months = parsed.months;
+        this.days = parsed.days;
+        this.nanos = parsed.nanos;
+      } else if (typeof value === "object" && value !== null) {
+        this.months = value.months;
+        this.days = value.days;
+        this.nanos = value.nanos;
+      } else {
+        throw new Error(`Interval value must be an object or string, got ${typeof value}`);
+      }
+    } else {
+      this.months = void 0;
+      this.days = void 0;
+      this.nanos = void 0;
+    }
+  }
+  /**
+   * Create a new interval from months, days, and nanoseconds
+   */
+  static new(months, days, nanos) {
+    return new _IntervalValue({ months, days, nanos });
+  }
+  /**
+   * Create an interval from seconds
+   */
+  static fromSeconds(seconds) {
+    return new _IntervalValue({ months: 0, days: 0, nanos: BigInt(seconds) * 1000000000n });
+  }
+  /**
+   * Create an interval from milliseconds
+   */
+  static fromMilliseconds(milliseconds) {
+    return new _IntervalValue({ months: 0, days: 0, nanos: BigInt(milliseconds) * 1000000n });
+  }
+  /**
+   * Create an interval from microseconds
+   */
+  static fromMicroseconds(microseconds) {
+    return new _IntervalValue({ months: 0, days: 0, nanos: BigInt(microseconds) * 1000n });
+  }
+  /**
+   * Create an interval from nanoseconds
+   */
+  static fromNanoseconds(nanoseconds) {
+    return new _IntervalValue({ months: 0, days: 0, nanos: nanoseconds });
+  }
+  /**
+   * Create an interval from minutes
+   */
+  static fromMinutes(minutes) {
+    return new _IntervalValue({ months: 0, days: 0, nanos: BigInt(minutes) * 60n * 1000000000n });
+  }
+  /**
+   * Create an interval from hours
+   */
+  static fromHours(hours) {
+    return new _IntervalValue({ months: 0, days: 0, nanos: BigInt(hours) * 60n * 60n * 1000000000n });
+  }
+  /**
+   * Create an interval from days
+   */
+  static fromDays(days) {
+    return new _IntervalValue({ months: 0, days, nanos: 0n });
+  }
+  /**
+   * Create an interval from weeks
+   */
+  static fromWeeks(weeks) {
+    return new _IntervalValue({ months: 0, days: weeks * 7, nanos: 0n });
+  }
+  /**
+   * Create an interval from months
+   */
+  static fromMonths(months) {
+    return new _IntervalValue({ months, days: 0, nanos: 0n });
+  }
+  /**
+   * Create an interval from years
+   */
+  static fromYears(years) {
+    return new _IntervalValue({ months: years * 12, days: 0, nanos: 0n });
+  }
+  /**
+   * Create a zero interval
+   */
+  static zero() {
+    return new _IntervalValue({ months: 0, days: 0, nanos: 0n });
+  }
+  /**
+   * Get default interval (zero)
+   */
+  static default() {
+    return _IntervalValue.zero();
+  }
+  /**
+   * Parse an interval string in ISO 8601 duration format
+   */
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _IntervalValue(void 0);
+    }
+    const parsed = _IntervalValue.parseDuration(trimmed);
+    if (!parsed) {
+      throw new Error(`Cannot parse "${str}" as Interval`);
+    }
+    return new _IntervalValue({ months: parsed.months, days: parsed.days, nanos: parsed.nanos });
+  }
+  /**
+   * Get total seconds (truncated)
+   */
+  seconds() {
+    if (this.nanos === void 0) return void 0;
+    return this.nanos / 1000000000n;
+  }
+  /**
+   * Get total milliseconds (truncated)
+   */
+  milliseconds() {
+    if (this.nanos === void 0) return void 0;
+    return this.nanos / 1000000n;
+  }
+  /**
+   * Get total microseconds (truncated)
+   */
+  microseconds() {
+    if (this.nanos === void 0) return void 0;
+    return this.nanos / 1000n;
+  }
+  /**
+   * Get total nanoseconds
+   */
+  nanoseconds() {
+    return this.nanos;
+  }
+  /**
+   * Get months component
+   */
+  getMonths() {
+    return this.months;
+  }
+  /**
+   * Get days component
+   */
+  getDays() {
+    return this.days;
+  }
+  /**
+   * Get nanoseconds component
+   */
+  getNanos() {
+    return this.nanos;
+  }
+  /**
+   * Check if interval is positive (any component > 0)
+   */
+  isPositive() {
+    if (this.months === void 0 || this.days === void 0 || this.nanos === void 0) {
+      return false;
+    }
+    return this.months > 0 || this.days > 0 || this.nanos > 0n;
+  }
+  /**
+   * Check if interval is negative (any component < 0)
+   */
+  isNegative() {
+    if (this.months === void 0 || this.days === void 0 || this.nanos === void 0) {
+      return false;
+    }
+    return this.months < 0 || this.days < 0 || this.nanos < 0n;
+  }
+  /**
+   * Get absolute value of interval
+   */
+  abs() {
+    if (this.months === void 0 || this.days === void 0 || this.nanos === void 0) {
+      return new _IntervalValue(void 0);
+    }
+    return new _IntervalValue({
+      months: Math.abs(this.months),
+      days: Math.abs(this.days),
+      nanos: this.nanos < 0n ? -this.nanos : this.nanos
+    });
+  }
+  /**
+   * Negate the interval
+   */
+  negate() {
+    if (this.months === void 0 || this.days === void 0 || this.nanos === void 0) {
+      return new _IntervalValue(void 0);
+    }
+    return new _IntervalValue({
+      months: -this.months,
+      days: -this.days,
+      nanos: -this.nanos
+    });
+  }
+  /**
+   * Format as ISO 8601 duration string
+   */
+  toString() {
+    if (this.months === void 0 || this.days === void 0 || this.nanos === void 0) {
+      return "undefined";
+    }
+    if (this.months === 0 && this.days === 0 && this.nanos === 0n) {
+      return "PT0S";
+    }
+    let result = "P";
+    const years = Math.floor(this.months / 12);
+    const months = this.months % 12;
+    if (years !== 0) {
+      result += `${years}Y`;
+    }
+    if (months !== 0) {
+      result += `${months}M`;
+    }
+    const totalSeconds = this.nanos / 1000000000n;
+    const remainingNanos = this.nanos % 1000000000n;
+    const extraDays = totalSeconds / 86400n;
+    const remainingSeconds = totalSeconds % 86400n;
+    const displayDays = this.days + Number(extraDays);
+    const hours = remainingSeconds / 3600n;
+    const minutes = remainingSeconds % 3600n / 60n;
+    const seconds = remainingSeconds % 60n;
+    if (displayDays !== 0) {
+      result += `${displayDays}D`;
+    }
+    if (hours !== 0n || minutes !== 0n || seconds !== 0n || remainingNanos !== 0n) {
+      result += "T";
+      if (hours !== 0n) {
+        result += `${hours}H`;
+      }
+      if (minutes !== 0n) {
+        result += `${minutes}M`;
+      }
+      if (seconds !== 0n || remainingNanos !== 0n) {
+        if (remainingNanos !== 0n) {
+          const fractional = Number(remainingNanos) / 1e9;
+          const totalSecondsFloat = Number(seconds) + fractional;
+          const formatted = totalSecondsFloat.toFixed(9).replace(/0+$/, "").replace(/\.$/, "");
+          result += `${formatted}S`;
+        } else {
+          result += `${seconds}S`;
+        }
+      }
+    }
+    return result;
+  }
+  valueOf() {
+    if (this.months === void 0 || this.days === void 0 || this.nanos === void 0) {
+      return void 0;
+    }
+    return { months: this.months, days: this.days, nanos: this.nanos };
+  }
+  /**
+   * Get the internal representation
+   */
+  get value() {
+    return this.valueOf();
+  }
+  /**
+   * Helper to parse ISO 8601 duration format
+   */
+  static parseDuration(str) {
+    const negative = str.startsWith("-");
+    const cleanStr = negative ? str.substring(1) : str;
+    if (!cleanStr.startsWith("P")) {
+      return null;
+    }
+    const match = cleanStr.match(/^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/);
+    if (!match) {
+      return null;
+    }
+    if (!match[1] && !match[2] && !match[3] && !match[4] && !match[5] && !match[6]) {
+      return null;
+    }
+    const years = parseInt(match[1] || "0", 10);
+    const months = parseInt(match[2] || "0", 10);
+    const days = parseInt(match[3] || "0", 10);
+    const hours = parseInt(match[4] || "0", 10);
+    const minutes = parseInt(match[5] || "0", 10);
+    const secondsStr = match[6] || "0";
+    const secondsParts = secondsStr.split(".");
+    const wholeSeconds = parseInt(secondsParts[0] || "0", 10);
+    let fracNanos = 0n;
+    if (secondsParts.length > 1) {
+      const fracStr = secondsParts[1].padEnd(9, "0").substring(0, 9);
+      fracNanos = BigInt(fracStr);
+    }
+    const totalNanos = BigInt(hours) * 3600n * 1000000000n + BigInt(minutes) * 60n * 1000000000n + BigInt(wholeSeconds) * 1000000000n + fracNanos;
+    const totalMonths = years * 12 + months;
+    if (negative) {
+      return {
+        months: -totalMonths,
+        days: -days,
+        nanos: -totalNanos
+      };
+    } else {
+      return {
+        months: totalMonths,
+        days,
+        nanos: totalNanos
+      };
+    }
+  }
+  /**
+   * Compare two intervals for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherInterval = other;
+    if (this.months === void 0 || otherInterval.months === void 0) {
+      return this.months === otherInterval.months && this.days === otherInterval.days && this.nanos === otherInterval.nanos;
+    }
+    return this.months === otherInterval.months && this.days === otherInterval.days && this.nanos === otherInterval.nanos;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+
+// src/value/uint1.ts
+var _Uint1Value = class _Uint1Value {
+  constructor(value) {
+    this.type = "Uint1";
+    if (value !== void 0) {
+      if (!Number.isInteger(value)) {
+        throw new Error(`Uint1 value must be an integer, got ${value}`);
+      }
+      if (value < _Uint1Value.MIN_VALUE || value > _Uint1Value.MAX_VALUE) {
+        throw new Error(`Uint1 value must be between ${_Uint1Value.MIN_VALUE} and ${_Uint1Value.MAX_VALUE}, got ${value}`);
+      }
+    }
+    this.value = value;
+  }
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _Uint1Value(void 0);
+    }
+    const num = Number(trimmed);
+    if (isNaN(num)) {
+      throw new Error(`Cannot parse "${str}" as Uint1`);
+    }
+    return new _Uint1Value(num);
+  }
+  valueOf() {
+    return this.value;
+  }
+  toString() {
+    return this.value === void 0 ? "undefined" : this.value.toString();
+  }
+  /**
+   * Compare two Uint1 values for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherUint = other;
+    return this.value === otherUint.value;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+_Uint1Value.MIN_VALUE = 0;
+_Uint1Value.MAX_VALUE = 255;
+var Uint1Value = _Uint1Value;
+
+// src/value/uint2.ts
+var _Uint2Value = class _Uint2Value {
+  constructor(value) {
+    this.type = "Uint2";
+    if (value !== void 0) {
+      if (!Number.isInteger(value)) {
+        throw new Error(`Uint2 value must be an integer, got ${value}`);
+      }
+      if (value < _Uint2Value.MIN_VALUE || value > _Uint2Value.MAX_VALUE) {
+        throw new Error(`Uint2 value must be between ${_Uint2Value.MIN_VALUE} and ${_Uint2Value.MAX_VALUE}, got ${value}`);
+      }
+    }
+    this.value = value;
+  }
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _Uint2Value(void 0);
+    }
+    const num = Number(trimmed);
+    if (isNaN(num)) {
+      throw new Error(`Cannot parse "${str}" as Uint2`);
+    }
+    return new _Uint2Value(num);
+  }
+  valueOf() {
+    return this.value;
+  }
+  toString() {
+    return this.value === void 0 ? "undefined" : this.value.toString();
+  }
+  /**
+   * Compare two Uint2 values for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherUint = other;
+    return this.value === otherUint.value;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+_Uint2Value.MIN_VALUE = 0;
+_Uint2Value.MAX_VALUE = 65535;
+var Uint2Value = _Uint2Value;
+
+// src/value/uint4.ts
+var _Uint4Value = class _Uint4Value {
+  constructor(value) {
+    this.type = "Uint4";
+    if (value !== void 0) {
+      if (!Number.isInteger(value)) {
+        throw new Error(`Uint4 value must be an integer, got ${value}`);
+      }
+      if (value < _Uint4Value.MIN_VALUE || value > _Uint4Value.MAX_VALUE) {
+        throw new Error(`Uint4 value must be between ${_Uint4Value.MIN_VALUE} and ${_Uint4Value.MAX_VALUE}, got ${value}`);
+      }
+    }
+    this.value = value;
+  }
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _Uint4Value(void 0);
+    }
+    const num = Number(trimmed);
+    if (isNaN(num)) {
+      throw new Error(`Cannot parse "${str}" as Uint4`);
+    }
+    return new _Uint4Value(num);
+  }
+  valueOf() {
+    return this.value;
+  }
+  toString() {
+    return this.value === void 0 ? "undefined" : this.value.toString();
+  }
+  /**
+   * Compare two Uint4 values for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherUint = other;
+    return this.value === otherUint.value;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+_Uint4Value.MIN_VALUE = 0;
+_Uint4Value.MAX_VALUE = 4294967295;
+var Uint4Value = _Uint4Value;
+
+// src/value/uint8.ts
+var _Uint8Value = class _Uint8Value {
+  constructor(value) {
+    this.type = "Uint8";
+    if (value !== void 0) {
+      const bigintValue = typeof value === "number" ? BigInt(Math.trunc(value)) : value;
+      if (bigintValue < _Uint8Value.MIN_VALUE || bigintValue > _Uint8Value.MAX_VALUE) {
+        throw new Error(`Uint8 value must be between ${_Uint8Value.MIN_VALUE} and ${_Uint8Value.MAX_VALUE}, got ${bigintValue}`);
+      }
+      this.value = bigintValue;
+    } else {
+      this.value = void 0;
+    }
+  }
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _Uint8Value(void 0);
+    }
+    let value;
+    try {
+      value = BigInt(trimmed);
+    } catch (e) {
+      throw new Error(`Cannot parse "${str}" as Uint8`);
+    }
+    if (value < _Uint8Value.MIN_VALUE || value > _Uint8Value.MAX_VALUE) {
+      throw new Error(`Uint8 value must be between ${_Uint8Value.MIN_VALUE} and ${_Uint8Value.MAX_VALUE}, got ${value}`);
+    }
+    return new _Uint8Value(value);
+  }
+  valueOf() {
+    return this.value;
+  }
+  toNumber() {
+    if (this.value === void 0) return void 0;
+    return Number(this.value);
+  }
+  toString() {
+    return this.value === void 0 ? "undefined" : this.value.toString();
+  }
+  /**
+   * Compare two Uint8 values for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherUint = other;
+    return this.value === otherUint.value;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+_Uint8Value.MIN_VALUE = BigInt(0);
+_Uint8Value.MAX_VALUE = BigInt("18446744073709551615");
+var Uint8Value = _Uint8Value;
+
+// src/value/uint16.ts
+var _Uint16Value = class _Uint16Value {
+  constructor(value) {
+    this.type = "Uint16";
+    if (value !== void 0) {
+      let bigintValue;
+      if (typeof value === "string") {
+        try {
+          bigintValue = BigInt(value);
+        } catch (e) {
+          throw new Error(`Uint16 value must be a valid integer, got ${value}`);
+        }
+      } else if (typeof value === "number") {
+        bigintValue = BigInt(Math.trunc(value));
+      } else {
+        bigintValue = value;
+      }
+      if (bigintValue < _Uint16Value.MIN_VALUE || bigintValue > _Uint16Value.MAX_VALUE) {
+        throw new Error(`Uint16 value must be between ${_Uint16Value.MIN_VALUE} and ${_Uint16Value.MAX_VALUE}, got ${bigintValue}`);
+      }
+      this.value = bigintValue;
+    } else {
+      this.value = void 0;
+    }
+  }
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _Uint16Value(void 0);
+    }
+    let value;
+    try {
+      value = BigInt(trimmed);
+    } catch (e) {
+      throw new Error(`Cannot parse "${str}" as Uint16`);
+    }
+    if (value < _Uint16Value.MIN_VALUE || value > _Uint16Value.MAX_VALUE) {
+      throw new Error(`Uint16 value must be between ${_Uint16Value.MIN_VALUE} and ${_Uint16Value.MAX_VALUE}, got ${value}`);
+    }
+    return new _Uint16Value(value);
+  }
+  valueOf() {
+    return this.value;
+  }
+  toString() {
+    return this.value === void 0 ? "undefined" : this.value.toString();
+  }
+  /**
+   * Compare two Uint16 values for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherUint = other;
+    return this.value === otherUint.value;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+_Uint16Value.MIN_VALUE = BigInt(0);
+_Uint16Value.MAX_VALUE = BigInt("340282366920938463463374607431768211455");
+var Uint16Value = _Uint16Value;
+
+// src/value/rownumber.ts
+var _RowNumberValue = class _RowNumberValue {
+  constructor(value) {
+    this.type = "RowNumber";
+    if (value !== void 0) {
+      const bigintValue = typeof value === "number" ? BigInt(Math.trunc(value)) : value;
+      if (bigintValue < _RowNumberValue.MIN_VALUE || bigintValue > _RowNumberValue.MAX_VALUE) {
+        throw new Error(`RowNumber value must be between ${_RowNumberValue.MIN_VALUE} and ${_RowNumberValue.MAX_VALUE}, got ${bigintValue}`);
+      }
+      this.value = bigintValue;
+    } else {
+      this.value = void 0;
+    }
+  }
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _RowNumberValue(void 0);
+    }
+    let value;
+    try {
+      value = BigInt(trimmed);
+    } catch (e) {
+      throw new Error(`Cannot parse "${str}" as RowNumber`);
+    }
+    if (value < _RowNumberValue.MIN_VALUE || value > _RowNumberValue.MAX_VALUE) {
+      throw new Error(`RowNumber value must be between ${_RowNumberValue.MIN_VALUE} and ${_RowNumberValue.MAX_VALUE}, got ${value}`);
+    }
+    return new _RowNumberValue(value);
+  }
+  valueOf() {
+    return this.value;
+  }
+  toString() {
+    return this.value === void 0 ? "undefined" : this.value.toString();
+  }
+  /**
+   * Compare two RowNumber values for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherRowNumber = other;
+    return this.value === otherRowNumber.value;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+_RowNumberValue.MIN_VALUE = BigInt(0);
+_RowNumberValue.MAX_VALUE = BigInt("18446744073709551615");
+var RowNumberValue = _RowNumberValue;
+
+// src/value/undefined.ts
+var UndefinedValue = class _UndefinedValue {
+  constructor() {
+    this.type = "Undefined";
+  }
+  /**
+   * Create a new UndefinedValue
+   */
+  static new() {
+    return new _UndefinedValue();
+  }
+  /**
+   * Get default UndefinedValue
+   */
+  static default() {
+    return new _UndefinedValue();
+  }
+  /**
+   * Parse a string as undefined
+   */
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE || trimmed === "undefined") {
+      return new _UndefinedValue();
+    }
+    throw new Error(`Cannot parse "${str}" as Undefined`);
+  }
+  /**
+   * Check if this value is undefined (always true)
+   */
+  isUndefined() {
+    return true;
+  }
+  /**
+   * Format as string
+   */
+  toString() {
+    return "undefined";
+  }
+  valueOf() {
+    return void 0;
+  }
+  /**
+   * Get the internal representation (always undefined)
+   */
+  get value() {
+    return void 0;
+  }
+  /**
+   * Compare two undefined values (always equal)
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Compare two undefined values for ordering (always equal)
+   */
+  compare(other) {
+    return 0;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+
+// src/value/utf8.ts
+var Utf8Value = class _Utf8Value {
+  constructor(value) {
+    this.type = "Utf8";
+    if (value !== void 0) {
+      if (typeof value !== "string") {
+        throw new Error(`Utf8 value must be a string, got ${typeof value}`);
+      }
+      this.value = value;
+    } else {
+      this.value = void 0;
+    }
+  }
+  static parse(str) {
+    if (str === UNDEFINED_VALUE) {
+      return new _Utf8Value(void 0);
+    }
+    return new _Utf8Value(str);
+  }
+  valueOf() {
+    return this.value;
+  }
+  toString() {
+    return this.value === void 0 ? "undefined" : this.value;
+  }
+  /**
+   * Compare two Utf8 values for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherUtf8 = other;
+    return this.value === otherUtf8.value;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+
+// src/value/uuid4.ts
+import { v4 as uuidv4, NIL as NIL_UUID, validate, version } from "uuid";
+var Uuid4Value = class _Uuid4Value {
+  constructor(value) {
+    this.type = "Uuid4";
+    if (value !== void 0) {
+      if (typeof value !== "string") {
+        throw new Error(`Uuid4 value must be a string, got ${typeof value}`);
+      }
+      if (!validate(value)) {
+        throw new Error(`Invalid UUID format: ${value}`);
+      }
+      const ver = version(value);
+      if (value !== NIL_UUID && ver !== 4) {
+        throw new Error(`Invalid UUID version for Uuid4: expected v4, got v${ver}`);
+      }
+      this.uuid = value.toLowerCase();
+    } else {
+      this.uuid = void 0;
+    }
+  }
+  /**
+   * Generate a new random UUID v4
+   */
+  static generate() {
+    return new _Uuid4Value(uuidv4());
+  }
+  /**
+   * Create a new Uuid4Value from a string
+   */
+  static new(uuid) {
+    return new _Uuid4Value(uuid);
+  }
+  /**
+   * Get the nil UUID (all zeros)
+   */
+  static nil() {
+    return new _Uuid4Value(NIL_UUID);
+  }
+  /**
+   * Get default Uuid4Value (nil UUID)
+   */
+  static default() {
+    return _Uuid4Value.nil();
+  }
+  /**
+   * Parse a UUID string
+   */
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _Uuid4Value(void 0);
+    }
+    if (!validate(trimmed)) {
+      throw new Error(`Cannot parse "${str}" as Uuid4`);
+    }
+    const ver = version(trimmed);
+    if (trimmed !== NIL_UUID && ver !== 4) {
+      throw new Error(`Cannot parse "${str}" as Uuid4: wrong version (v${ver})`);
+    }
+    return new _Uuid4Value(trimmed);
+  }
+  /**
+   * Get the UUID string
+   */
+  asString() {
+    return this.uuid;
+  }
+  /**
+   * Get the UUID as bytes (16-byte array)
+   */
+  asBytes() {
+    if (this.uuid === void 0) return void 0;
+    const hex = this.uuid.replace(/-/g, "");
+    const bytes = new Uint8Array(16);
+    for (let i = 0; i < 16; i++) {
+      bytes[i] = parseInt(hex.substring(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+  }
+  /**
+   * Check if this is the nil UUID
+   */
+  isNil() {
+    return this.uuid === NIL_UUID;
+  }
+  /**
+   * Get the UUID version
+   */
+  getVersion() {
+    if (this.uuid === void 0) return void 0;
+    return version(this.uuid);
+  }
+  /**
+   * Format as string
+   */
+  toString() {
+    if (this.uuid === void 0) {
+      return "undefined";
+    }
+    return this.uuid;
+  }
+  valueOf() {
+    return this.uuid;
+  }
+  /**
+   * Get the internal representation
+   */
+  get value() {
+    return this.valueOf();
+  }
+  /**
+   * Compare two UUID4 values for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherUuid = other;
+    return this.uuid === otherUuid.uuid;
+  }
+  /**
+   * Compare two UUID4 values (for ordering)
+   */
+  compare(other) {
+    if (this.uuid === void 0 || other.uuid === void 0) {
+      if (this.uuid === other.uuid) return 0;
+      if (this.uuid === void 0) return -1;
+      return 1;
+    }
+    const thisBytes = this.asBytes();
+    const otherBytes = other.asBytes();
+    for (let i = 0; i < 16; i++) {
+      if (thisBytes[i] < otherBytes[i]) return -1;
+      if (thisBytes[i] > otherBytes[i]) return 1;
+    }
+    return 0;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+
+// src/value/uuid7.ts
+import { v7 as uuidv7, NIL as NIL_UUID2, validate as validate2, version as version2 } from "uuid";
+var Uuid7Value = class _Uuid7Value {
+  constructor(value) {
+    this.type = "Uuid7";
+    if (value !== void 0) {
+      if (typeof value !== "string") {
+        throw new Error(`Uuid7 value must be a string, got ${typeof value}`);
+      }
+      if (!validate2(value)) {
+        throw new Error(`Invalid UUID format: ${value}`);
+      }
+      const ver = version2(value);
+      if (value !== NIL_UUID2 && ver !== 7) {
+        throw new Error(`Invalid UUID version for Uuid7: expected v7, got v${ver}`);
+      }
+      this.uuid = value.toLowerCase();
+    } else {
+      this.uuid = void 0;
+    }
+  }
+  /**
+   * Generate a new timestamp-based UUID v7
+   */
+  static generate() {
+    return new _Uuid7Value(uuidv7());
+  }
+  /**
+   * Create a new Uuid7Value from a string
+   */
+  static new(uuid) {
+    return new _Uuid7Value(uuid);
+  }
+  /**
+   * Get the nil UUID (all zeros)
+   */
+  static nil() {
+    return new _Uuid7Value(NIL_UUID2);
+  }
+  /**
+   * Get default Uuid7Value (nil UUID)
+   */
+  static default() {
+    return _Uuid7Value.nil();
+  }
+  /**
+   * Parse a UUID string
+   */
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _Uuid7Value(void 0);
+    }
+    if (!validate2(trimmed)) {
+      throw new Error(`Cannot parse "${str}" as Uuid7`);
+    }
+    const ver = version2(trimmed);
+    if (trimmed !== NIL_UUID2 && ver !== 7) {
+      throw new Error(`Cannot parse "${str}" as Uuid7: wrong version (v${ver})`);
+    }
+    return new _Uuid7Value(trimmed);
+  }
+  /**
+   * Get the UUID string
+   */
+  asString() {
+    return this.uuid;
+  }
+  /**
+   * Get the UUID as bytes (16-byte array)
+   */
+  asBytes() {
+    if (this.uuid === void 0) return void 0;
+    const hex = this.uuid.replace(/-/g, "");
+    const bytes = new Uint8Array(16);
+    for (let i = 0; i < 16; i++) {
+      bytes[i] = parseInt(hex.substring(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+  }
+  /**
+   * Extract the timestamp from UUID v7 (milliseconds since Unix epoch)
+   */
+  getTimestamp() {
+    if (this.uuid === void 0 || this.uuid === NIL_UUID2) return void 0;
+    const hex = this.uuid.replace(/-/g, "");
+    const timestampHex = hex.substring(0, 12);
+    const timestamp = parseInt(timestampHex, 16);
+    return timestamp;
+  }
+  /**
+   * Check if this is the nil UUID
+   */
+  isNil() {
+    return this.uuid === NIL_UUID2;
+  }
+  /**
+   * Get the UUID version
+   */
+  getVersion() {
+    if (this.uuid === void 0) return void 0;
+    return version2(this.uuid);
+  }
+  /**
+   * Format as string
+   */
+  toString() {
+    if (this.uuid === void 0) {
+      return "undefined";
+    }
+    return this.uuid;
+  }
+  valueOf() {
+    return this.uuid;
+  }
+  /**
+   * Get the internal representation
+   */
+  get value() {
+    return this.valueOf();
+  }
+  /**
+   * Compare two UUID7 values for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherUuid = other;
+    return this.uuid === otherUuid.uuid;
+  }
+  /**
+   * Compare two UUID7 values (for ordering)
+   * UUID v7 has timestamp-based ordering for UUIDs generated close in time
+   */
+  compare(other) {
+    if (this.uuid === void 0 || other.uuid === void 0) {
+      if (this.uuid === other.uuid) return 0;
+      if (this.uuid === void 0) return -1;
+      return 1;
+    }
+    const thisBytes = this.asBytes();
+    const otherBytes = other.asBytes();
+    for (let i = 0; i < 16; i++) {
+      if (thisBytes[i] < otherBytes[i]) return -1;
+      if (thisBytes[i] > otherBytes[i]) return 1;
+    }
+    return 0;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+
+// src/value/identityid.ts
+import { v7 as uuidv72, NIL as NIL_UUID3, validate as validate3, version as version3 } from "uuid";
+var IdentityIdValue = class _IdentityIdValue {
+  constructor(value) {
+    this.type = "IdentityId";
+    if (value !== void 0) {
+      if (typeof value !== "string") {
+        throw new Error(`IdentityId value must be a string, got ${typeof value}`);
+      }
+      if (!validate3(value)) {
+        throw new Error(`Invalid UUID format for IdentityId: ${value}`);
+      }
+      const ver = version3(value);
+      if (value !== NIL_UUID3 && ver !== 7) {
+        throw new Error(`Invalid UUID version for IdentityId: expected v7, got v${ver}`);
+      }
+      this.value = value.toLowerCase();
+    } else {
+      this.value = void 0;
+    }
+  }
+  /**
+   * Generate a new IdentityId with a UUID v7
+   */
+  static generate() {
+    return new _IdentityIdValue(uuidv72());
+  }
+  /**
+   * Get the nil IdentityId (all zeros)
+   */
+  static nil() {
+    return new _IdentityIdValue(NIL_UUID3);
+  }
+  /**
+   * Parse a string as an IdentityId
+   */
+  static parse(str) {
+    const trimmed = str.trim();
+    if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
+      return new _IdentityIdValue(void 0);
+    }
+    if (!validate3(trimmed)) {
+      throw new Error(`Cannot parse "${str}" as IdentityId`);
+    }
+    const ver = version3(trimmed);
+    if (trimmed !== NIL_UUID3 && ver !== 7) {
+      throw new Error(`Cannot parse "${str}" as IdentityId: wrong UUID version (v${ver})`);
+    }
+    return new _IdentityIdValue(trimmed);
+  }
+  /**
+   * Get the UUID string value
+   */
+  valueOf() {
+    return this.value;
+  }
+  /**
+   * Format as string
+   */
+  toString() {
+    return this.value === void 0 ? "undefined" : this.value;
+  }
+  /**
+   * Extract the timestamp from the UUID v7 (milliseconds since Unix epoch)
+   */
+  getTimestamp() {
+    if (this.value === void 0 || this.value === NIL_UUID3) return void 0;
+    const hex = this.value.replace(/-/g, "");
+    const timestampHex = hex.substring(0, 12);
+    const timestamp = parseInt(timestampHex, 16);
+    return timestamp;
+  }
+  /**
+   * Check if this is the nil UUID
+   */
+  isNil() {
+    return this.value === NIL_UUID3;
+  }
+  /**
+   * Compare two IdentityId values for equality
+   */
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherIdentityId = other;
+    return this.value === otherIdentityId.value;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+
+// src/value/index.ts
+var Value = class {
+};
+
+// src/decoder.ts
+function decode(pair) {
+  switch (pair.type) {
+    case "Blob":
+      return BlobValue.parse(pair.value);
+    case "Bool":
+      return BoolValue.parse(pair.value);
+    case "Date":
+      return DateValue.parse(pair.value);
+    case "DateTime":
+      return DateTimeValue.parse(pair.value);
+    case "Float4":
+      return Float4Value.parse(pair.value);
+    case "Float8":
+      return Float8Value.parse(pair.value);
+    case "Int1":
+      return Int1Value.parse(pair.value);
+    case "Int2":
+      return Int2Value.parse(pair.value);
+    case "Int4":
+      return Int4Value.parse(pair.value);
+    case "Int8":
+      return Int8Value.parse(pair.value);
+    case "Int16":
+      return Int16Value.parse(pair.value);
+    case "Interval":
+      return IntervalValue.parse(pair.value);
+    case "RowNumber":
+      return RowNumberValue.parse(pair.value);
+    case "Time":
+      return TimeValue.parse(pair.value);
+    case "Uint1":
+      return Uint1Value.parse(pair.value);
+    case "Uint2":
+      return Uint2Value.parse(pair.value);
+    case "Uint4":
+      return Uint4Value.parse(pair.value);
+    case "Uint8":
+      return Uint8Value.parse(pair.value);
+    case "Uint16":
+      return Uint16Value.parse(pair.value);
+    case "Undefined":
+      return UndefinedValue.parse(pair.value);
+    case "Utf8":
+      return Utf8Value.parse(pair.value);
+    case "Uuid4":
+      return Uuid4Value.parse(pair.value);
+    case "Uuid7":
+      return Uuid7Value.parse(pair.value);
+    case "IdentityId":
+      return IdentityIdValue.parse(pair.value);
+    default:
+      throw new Error(`Unsupported type: ${pair.type}`);
+  }
+}
+
+// src/schema/builder.ts
+var SchemaBuilder = class {
+  static blob() {
+    return { kind: "primitive", type: "Blob" };
+  }
+  static bool() {
+    return { kind: "primitive", type: "Bool" };
+  }
+  static boolean() {
+    return { kind: "primitive", type: "Bool" };
+  }
+  static float4() {
+    return { kind: "primitive", type: "Float4" };
+  }
+  static float8() {
+    return { kind: "primitive", type: "Float8" };
+  }
+  static float() {
+    return { kind: "primitive", type: "Float8" };
+  }
+  static double() {
+    return { kind: "primitive", type: "Float8" };
+  }
+  static int1() {
+    return { kind: "primitive", type: "Int1" };
+  }
+  static int2() {
+    return { kind: "primitive", type: "Int2" };
+  }
+  static int4() {
+    return { kind: "primitive", type: "Int4" };
+  }
+  static int8() {
+    return { kind: "primitive", type: "Int8" };
+  }
+  static int16() {
+    return { kind: "primitive", type: "Int16" };
+  }
+  static int() {
+    return { kind: "primitive", type: "Int4" };
+  }
+  static bigint() {
+    return { kind: "primitive", type: "Int8" };
+  }
+  static uint1() {
+    return { kind: "primitive", type: "Uint1" };
+  }
+  static uint2() {
+    return { kind: "primitive", type: "Uint2" };
+  }
+  static uint4() {
+    return { kind: "primitive", type: "Uint4" };
+  }
+  static uint8() {
+    return { kind: "primitive", type: "Uint8" };
+  }
+  static uint16() {
+    return { kind: "primitive", type: "Uint16" };
+  }
+  static utf8() {
+    return { kind: "primitive", type: "Utf8" };
+  }
+  static string() {
+    return { kind: "primitive", type: "Utf8" };
+  }
+  static date() {
+    return { kind: "primitive", type: "Date" };
+  }
+  static datetime() {
+    return { kind: "primitive", type: "DateTime" };
+  }
+  static time() {
+    return { kind: "primitive", type: "Time" };
+  }
+  static interval() {
+    return { kind: "primitive", type: "Interval" };
+  }
+  static uuid4() {
+    return { kind: "primitive", type: "Uuid4" };
+  }
+  static uuid7() {
+    return { kind: "primitive", type: "Uuid7" };
+  }
+  static uuid() {
+    return { kind: "primitive", type: "Uuid7" };
+  }
+  static undefined() {
+    return { kind: "primitive", type: "Undefined" };
+  }
+  static rownumber() {
+    return { kind: "primitive", type: "RowNumber" };
+  }
+  static identityid() {
+    return { kind: "primitive", type: "IdentityId" };
+  }
+  static object(properties) {
+    return { kind: "object", properties };
+  }
+  static array(items) {
+    return { kind: "array", items };
+  }
+  static optional(schema) {
+    return { kind: "optional", schema };
+  }
+  static number() {
+    return { kind: "primitive", type: "Float8" };
+  }
+  static boolValue() {
+    return { kind: "value", type: "Bool" };
+  }
+  static int1Value() {
+    return { kind: "value", type: "Int1" };
+  }
+  static int2Value() {
+    return { kind: "value", type: "Int2" };
+  }
+  static int4Value() {
+    return { kind: "value", type: "Int4" };
+  }
+  static int8Value() {
+    return { kind: "value", type: "Int8" };
+  }
+  static int16Value() {
+    return { kind: "value", type: "Int16" };
+  }
+  static uint1Value() {
+    return { kind: "value", type: "Uint1" };
+  }
+  static uint2Value() {
+    return { kind: "value", type: "Uint2" };
+  }
+  static uint4Value() {
+    return { kind: "value", type: "Uint4" };
+  }
+  static uint8Value() {
+    return { kind: "value", type: "Uint8" };
+  }
+  static uint16Value() {
+    return { kind: "value", type: "Uint16" };
+  }
+  static float4Value() {
+    return { kind: "value", type: "Float4" };
+  }
+  static float8Value() {
+    return { kind: "value", type: "Float8" };
+  }
+  static utf8Value() {
+    return { kind: "value", type: "Utf8" };
+  }
+  static dateValue() {
+    return { kind: "value", type: "Date" };
+  }
+  static dateTimeValue() {
+    return { kind: "value", type: "DateTime" };
+  }
+  static timeValue() {
+    return { kind: "value", type: "Time" };
+  }
+  static intervalValue() {
+    return { kind: "value", type: "Interval" };
+  }
+  static uuid4Value() {
+    return { kind: "value", type: "Uuid4" };
+  }
+  static uuid7Value() {
+    return { kind: "value", type: "Uuid7" };
+  }
+  static undefinedValue() {
+    return { kind: "value", type: "Undefined" };
+  }
+  static blobValue() {
+    return { kind: "value", type: "Blob" };
+  }
+  static rowIdValue() {
+    return { kind: "value", type: "RowNumber" };
+  }
+  static identityIdValue() {
+    return { kind: "value", type: "IdentityId" };
+  }
+};
+var Schema = SchemaBuilder;
+
+// src/schema/parser.ts
+function createValueInstance(type, value) {
+  switch (type) {
+    case "Blob":
+      return new BlobValue(value);
+    case "Bool":
+      return new BoolValue(value);
+    case "Float4":
+      return new Float4Value(value);
+    case "Float8":
+      return new Float8Value(value);
+    case "Int1":
+      return new Int1Value(value);
+    case "Int2":
+      return new Int2Value(value);
+    case "Int4":
+      return new Int4Value(value);
+    case "Int8":
+      return new Int8Value(value);
+    case "Int16":
+      return new Int16Value(value);
+    case "Uint1":
+      return new Uint1Value(value);
+    case "Uint2":
+      return new Uint2Value(value);
+    case "Uint4":
+      return new Uint4Value(value);
+    case "Uint8":
+      return new Uint8Value(value);
+    case "Uint16":
+      return new Uint16Value(value);
+    case "Utf8":
+      return new Utf8Value(value);
+    case "Date":
+      return new DateValue(value);
+    case "DateTime":
+      return new DateTimeValue(value);
+    case "Time":
+      return new TimeValue(value);
+    case "Interval":
+      return new IntervalValue(value);
+    case "Uuid4":
+      return new Uuid4Value(value);
+    case "Uuid7":
+      return new Uuid7Value(value);
+    case "Undefined":
+      return new UndefinedValue();
+    case "RowNumber":
+      return new RowNumberValue(value);
+    default:
+      throw new Error(`Unknown type: ${type}`);
+  }
+}
+function parseValue(schema, value) {
+  if (schema.kind === "primitive") {
+    if (value === null || value === void 0) {
+      return void 0;
+    }
+    return createValueInstance(schema.type, value);
+  }
+  if (schema.kind === "object") {
+    if (value === null || value === void 0) {
+      return void 0;
+    }
+    const result = {};
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+      result[key] = parseValue(propSchema, value[key]);
+    }
+    return result;
+  }
+  if (schema.kind === "array") {
+    if (!Array.isArray(value)) {
+      return [];
+    }
+    return value.map((item) => parseValue(schema.items, item));
+  }
+  if (schema.kind === "optional") {
+    if (value === void 0) {
+      return void 0;
+    }
+    return parseValue(schema.schema, value);
+  }
+  throw new Error(`Unknown schema kind: ${schema.kind}`);
+}
+
+// src/schema/validator.ts
+function validateSchema(schema, value) {
+  if (schema.kind === "primitive") {
+    const schemaType = schema.type;
+    if (value === null || value === void 0) {
+      return schemaType === "Undefined";
+    }
+    switch (schemaType) {
+      case "Bool":
+        return typeof value === "boolean";
+      case "Float4":
+      case "Float8":
+      case "Int1":
+      case "Int2":
+      case "Int4":
+        return typeof value === "number";
+      case "Int8":
+      case "Int16":
+      case "Uint8":
+      case "Uint16":
+        return typeof value === "bigint" || typeof value === "number";
+      case "Uint1":
+      case "Uint2":
+      case "Uint4":
+        return typeof value === "number" && value >= 0;
+      case "Utf8":
+      case "Time":
+      case "Interval":
+      case "Uuid4":
+      case "Uuid7":
+      case "RowNumber":
+        return typeof value === "string";
+      case "Date":
+      case "DateTime":
+        return value instanceof Date || typeof value === "string";
+      case "Blob":
+        return value instanceof Uint8Array || value instanceof ArrayBuffer;
+      case "Undefined":
+        return value === void 0;
+      default:
+        return false;
+    }
+  }
+  if (schema.kind === "object") {
+    if (typeof value !== "object" || value === null) {
+      return false;
+    }
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+      if (!validateSchema(propSchema, value[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (schema.kind === "array") {
+    if (!Array.isArray(value)) {
+      return false;
+    }
+    return value.every((item) => validateSchema(schema.items, item));
+  }
+  if (schema.kind === "optional") {
+    if (value === void 0) {
+      return true;
+    }
+    return validateSchema(schema.schema, value);
+  }
+  return false;
+}
+
+// src/types.ts
+var ReifyError = class extends Error {
+  constructor(response) {
+    const diagnostic = response.payload.diagnostic;
+    const message = `[${diagnostic.code}] ${diagnostic.message}` + (diagnostic.label ? ` \u2014 ${diagnostic.label}` : "");
+    super(message);
+    this.name = "ReifyError";
+    this.code = diagnostic.code;
+    this.statement = diagnostic.statement;
+    this.column = diagnostic.column;
+    this.span = diagnostic.span;
+    this.label = diagnostic.label;
+    this.help = diagnostic.help;
+    this.notes = diagnostic.notes ?? [];
+    this.cause = diagnostic.cause;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  toString() {
+    const position = this.span ? `line ${this.span.line}, offset ${this.span.offset}` : "unknown position";
+    const notes = this.notes.length ? `
+Notes:
+- ${this.notes.join("\n- ")}` : "";
+    const help = this.help ? `
+Help: ${this.help}` : "";
+    return `${this.name}: ${this.message}
+At ${position}${help}${notes}`;
+  }
+};
+function asFrameResults(results) {
+  return results;
+}
+export {
+  BlobValue,
+  BoolValue,
+  DateTimeValue,
+  DateValue,
+  Float4Value,
+  Float8Value,
+  IdentityIdValue,
+  Int16Value,
+  Int1Value,
+  Int2Value,
+  Int4Value,
+  Int8Value,
+  IntervalValue,
+  ReifyError,
+  RowNumberValue,
+  Schema,
+  SchemaBuilder,
+  TimeValue,
+  UNDEFINED_VALUE,
+  Uint16Value,
+  Uint1Value,
+  Uint2Value,
+  Uint4Value,
+  Uint8Value,
+  UndefinedValue,
+  Utf8Value,
+  Uuid4Value,
+  Uuid7Value,
+  Value,
+  asFrameResults,
+  decode,
+  parseValue,
+  validateSchema
+};
+//# sourceMappingURL=index.js.map