@rivetjs/cdk 0.0.0-stage → 0.1.0-alpha.0

package/data-grid/state.d.ts

@@ -0,0 +1,131 @@
+import type { Key, Selection, SelectionMode, SortDescriptor, SortDirection } from "../collections/types.js";
+export type { Key, Selection, SelectionMode, SortDescriptor, SortDirection };
+/** A column width: pixels, a percentage of the grid width or a fraction of the remaining space. */
+export type DataGridColumnSize = number | `${number}%` | `${number}fr`;
+/** The data-only part of a column definition (what the pipeline and the layout read). */
+export interface DataGridColumnBase<T> {
+    /** Unique column id (also the `SortDescriptor.column` value). */
+    id: string;
+    /** Property of the row item shown in the column (and compared when sorting) unless `cell` / `sortFn` are given. */
+    accessorKey?: (keyof T & string) | undefined;
+    /** Whether the column labels its row (`<td role="rowheader">`, as React Aria). Default: the first data column. */
+    isRowHeader?: boolean | undefined;
+    /** Whether the column can be sorted by pressing its header. */
+    allowsSorting?: boolean | undefined;
+    /** Comparator used to sort by this column (ascending order); default compares `item[accessorKey]`. */
+    sortFn?: ((a: T, b: T) => number) | undefined;
+    /** Whether the column can be resized (needs `allowsColumnResize` on the grid). Default `true` when the grid allows resizing. */
+    allowsResizing?: boolean | undefined;
+    /** Width: px number, `"20%"` or `"2fr"`. Columns without a width share the remaining space (`1fr`). */
+    width?: DataGridColumnSize | undefined;
+    /** Minimum width in px (resizing never goes below it). Default 40. */
+    minWidth?: number | undefined;
+    /** Maximum width in px. */
+    maxWidth?: number | undefined;
+    /** Horizontal alignment of the header and the cells. Default `"start"`. */
+    align?: "start" | "center" | "end" | undefined;
+    /** Keep the column visible while scrolling horizontally (sticky); needs a numeric `width`. */
+    pinned?: "start" | "end" | undefined;
+}
+/** One rendered body row: a flattened, possibly nested item. */
+export interface DataGridRow<T> {
+    key: Key;
+    item: T;
+    /** Nesting depth, 0 for top-level rows. */
+    depth: number;
+    /** Key of the parent row (`null` at the top level). */
+    parentKey: Key | null;
+    /** Whether `getChildren` returned at least one child. */
+    hasChildren: boolean;
+    /** 1-based position among its siblings and the sibling count (`aria-posinset` / `aria-setsize`). */
+    posInSet: number;
+    setSize: number;
+    /** 0-based index in the flattened rows (before pagination). */
+    index: number;
+}
+export interface DataGridPipelineInput<T> {
+    data: readonly T[];
+    columns: readonly DataGridColumnBase<T>[];
+    getRowId: (item: T, index: number) => Key;
+    /** Client-side sort (omit or `null`: keep the data order). */
+    sort?: SortDescriptor | null | undefined;
+    /** Row predicate; with a tree, a row stays when it or a descendant matches. */
+    filter?: ((item: T) => boolean) | null | undefined;
+    getChildren?: ((item: T) => readonly T[] | null | undefined) | undefined;
+    /** Expanded row keys (`"all"`: every row with children). */
+    expandedKeys?: Iterable<Key> | "all" | undefined;
+    /** Rows per page (after flattening); omit to show every row. */
+    pageSize?: number | undefined;
+    /** 1-based page. */
+    page?: number | undefined;
+    /** Locale of the default string comparison. */
+    locale?: string | undefined;
+}
+export interface DataGridPipelineResult<T> {
+    /** The rows to render (current page). */
+    rows: DataGridRow<T>[];
+    /** Flattened row count before pagination. */
+    total: number;
+    /** Page count (1 when not paginated). */
+    pageCount: number;
+}
+/** Locale-aware, numeric-aware collator (cached per locale). */
+export declare function collatorFor(locale?: string): Intl.Collator;
+/** Default comparison: `null` / `undefined` last, numbers / bigints / dates / booleans by value, the rest as locale strings. */
+export declare function compareValues(a: unknown, b: unknown, collator: Intl.Collator): number;
+/** The ascending comparator of a column (its `sortFn`, else `accessorKey` values), or `null` when it cannot sort. */
+export declare function columnComparator<T>(column: DataGridColumnBase<T> | undefined, locale?: string): ((a: T, b: T) => number) | null;
+/** Stable sort of `items` by `column` in `direction` (returns a new array). */
+export declare function sortItems<T>(items: readonly T[], compare: (a: T, b: T) => number, direction: SortDirection): T[];
+/** Next sort descriptor when a column header is pressed (react-stately `useTableState.sort`: new column → ascending, same → flip). */
+export declare function nextSortDescriptor(current: SortDescriptor | null | undefined, column: Key, direction?: SortDirection): SortDescriptor;
+/** Run the pipeline: filter → sort → flatten (expanded) → paginate. */
+export declare function dataGridRows<T>(input: DataGridPipelineInput<T>): DataGridPipelineResult<T>;
+/** Keys of every row that has children (for "expand all"). */
+export declare function expandableKeys<T>(data: readonly T[], getRowId: (item: T, index: number) => Key, getChildren: (item: T) => readonly T[] | null | undefined): Set<Key>;
+/** `expanded` with `key` toggled (a new Set). */
+export declare function toggleExpandedKey(expanded: Iterable<Key> | "all", key: Key, allExpandable?: () => Iterable<Key>): Set<Key>;
+/** Whether `key` is selected (`"all"` selects every key except disabled ones). */
+export declare function isKeySelected(selection: Selection, key: Key, disabled?: ReadonlySet<Key>): boolean;
+/** The selection with `key` toggled. `"all"` turns into the selectable `keys` minus `key`. */
+export declare function toggleKeySelection(selection: Selection, key: Key, mode: SelectionMode, keys: () => Iterable<Key>, disabled?: ReadonlySet<Key>): Selection;
+/** Replace the selection with `key` (selectionBehavior "replace" press). */
+export declare function replaceSelection(mode: SelectionMode, key: Key, disabled?: ReadonlySet<Key>): Selection;
+/** Select the range from `anchor` to `key` in `order` (shift-click / shift-arrow), added to `base` when given. */
+export declare function rangeSelection(order: readonly Key[], anchor: Key, key: Key, disabled?: ReadonlySet<Key>, base?: Set<Key>): Set<Key>;
+/** Select-all checkbox state over the selectable `keys`: `"all"`, `"some"` or `"none"`. */
+export declare function selectAllState(selection: Selection, keys: readonly Key[], disabled?: ReadonlySet<Key>): "all" | "some" | "none";
+/** Number of selected keys (`"all"`: `total` minus disabled). */
+export declare function selectionSize(selection: Selection, total: number, disabled?: ReadonlySet<Key>): number;
+/**
+ * CSS widths for `<col>` elements: px for numbers and measured / resized columns, `%` as given, fractions of the
+ * remaining space (`calc((100% - <static px>) * f / Σf)`) for `fr` and width-less columns.
+ */
+export declare function columnCssWidths<T>(columns: readonly DataGridColumnBase<T>[], resized?: ReadonlyMap<string, number> | null, extra?: number): string[];
+/** Total table width in px when every column has a px width (after a resize), else `null` (100%). */
+export declare function tableWidthPx<T>(columns: readonly DataGridColumnBase<T>[], resized?: ReadonlyMap<string, number> | null, extra?: number): number | null;
+export interface PinnedOffset {
+    side: "start" | "end";
+    /** Sticky inset in px (`inset-inline-start` / `-end`). */
+    offset: number;
+    /** The innermost pinned column of its side (draws the separator shadow). */
+    edge: boolean;
+}
+/**
+ * Sticky offsets of pinned columns (`columns` in render order, incl. leading utility columns given as
+ * `{ id, width, pinned }`). A pinned column needs a px width; columns after it pinned to the same side add up.
+ */
+export declare function pinnedOffsets<T>(columns: readonly DataGridColumnBase<T>[], resized?: ReadonlyMap<string, number> | null): Map<string, PinnedOffset>;
+/** Clamp a resized width to the column's min / max (min default 40). */
+export declare function clampColumnWidth<T>(column: DataGridColumnBase<T>, width: number): number;
+export interface VirtualWindow {
+    start: number;
+    end: number;
+}
+/** Rows `[start, end)` intersecting the viewport (+ `overscan` rows each side) for fixed `rowHeight`. */
+export declare function virtualWindow(scrollTop: number, viewportHeight: number, rowHeight: number, count: number, overscan: number): VirtualWindow;
+/** `scrollTop` that brings row `index` fully into a viewport of `viewportHeight` (unchanged when already visible). */
+export declare function scrollTopFor(index: number, rowHeight: number, headerHeight: number, scrollTop: number, viewportHeight: number): number;
+export type DropPosition = "before" | "after";
+/** Move the items with `keys` before / after `target` (order of the moved items kept). Returns a new array. */
+export declare function reorderItems<T>(items: readonly T[], getRowId: (item: T, index: number) => Key, keys: ReadonlySet<Key>, target: Key, position: DropPosition): T[];

package/data-grid/state.js

@@ -0,0 +1,288 @@
+const collators = new Map();
+/** Locale-aware, numeric-aware collator (cached per locale). */
+export function collatorFor(locale = "en-US") {
+    let c = collators.get(locale);
+    if (!c)
+        collators.set(locale, (c = new Intl.Collator(locale, { numeric: true, sensitivity: "base" })));
+    return c;
+}
+/** Default comparison: `null` / `undefined` last, numbers / bigints / dates / booleans by value, the rest as locale strings. */
+export function compareValues(a, b, collator) {
+    if (a === b)
+        return 0;
+    if (a == null)
+        return b == null ? 0 : 1;
+    if (b == null)
+        return -1;
+    if (typeof a === "number" && typeof b === "number")
+        return a - b;
+    if (typeof a === "bigint" && typeof b === "bigint")
+        return a < b ? -1 : a > b ? 1 : 0;
+    if (typeof a === "boolean" && typeof b === "boolean")
+        return a === b ? 0 : a ? 1 : -1;
+    if (a instanceof Date && b instanceof Date)
+        return a.getTime() - b.getTime();
+    return collator.compare(String(a), String(b));
+}
+/** The ascending comparator of a column (its `sortFn`, else `accessorKey` values), or `null` when it cannot sort. */
+export function columnComparator(column, locale) {
+    if (!column)
+        return null;
+    if (column.sortFn)
+        return column.sortFn;
+    const key = column.accessorKey ?? column.id;
+    const collator = collatorFor(locale);
+    return (a, b) => compareValues(a[key], b[key], collator);
+}
+/** Stable sort of `items` by `column` in `direction` (returns a new array). */
+export function sortItems(items, compare, direction) {
+    const sign = direction === "descending" ? -1 : 1;
+    const indexed = items.map((item, index) => ({ item, index }));
+    indexed.sort((x, y) => sign * compare(x.item, y.item) || x.index - y.index);
+    return indexed.map((x) => x.item);
+}
+/** Next sort descriptor when a column header is pressed (react-stately `useTableState.sort`: new column → ascending, same → flip). */
+export function nextSortDescriptor(current, column, direction) {
+    if (direction)
+        return { column, direction };
+    return {
+        column,
+        direction: current && current.column === column && current.direction === "ascending" ? "descending" : "ascending",
+    };
+}
+const expandedSet = (expanded) => expanded === "all" ? "all" : expanded instanceof Set ? expanded : new Set(expanded ?? []);
+/** Run the pipeline: filter → sort → flatten (expanded) → paginate. */
+export function dataGridRows(input) {
+    const { data, columns, getRowId, sort, filter, getChildren, pageSize, page = 1, locale } = input;
+    const expanded = expandedSet(input.expandedKeys);
+    const compare = sort
+        ? columnComparator(columns.find((c) => c.id === sort.column), locale)
+        : null;
+    const direction = sort?.direction ?? "ascending";
+    const out = [];
+    // Tree filter: an item stays when it or one of its descendants matches.
+    const keep = (item) => {
+        if (!filter || filter(item))
+            return true;
+        const children = getChildren?.(item);
+        return !!children && children.some(keep);
+    };
+    const visit = (items, depth, parentKey) => {
+        let level = filter ? items.filter(keep) : items;
+        if (compare)
+            level = sortItems(level, compare, direction);
+        const setSize = level.length;
+        for (let i = 0; i < setSize; i++) {
+            const item = level[i];
+            const key = getRowId(item, i);
+            const children = getChildren?.(item);
+            const hasChildren = !!children && children.length > 0;
+            out.push({ key, item, depth, parentKey, hasChildren, posInSet: i + 1, setSize, index: out.length });
+            if (hasChildren && (expanded === "all" || expanded.has(key)))
+                visit(children, depth + 1, key);
+        }
+    };
+    visit(data, 0, null);
+    const total = out.length;
+    if (!pageSize || pageSize <= 0)
+        return { rows: out, total, pageCount: 1 };
+    const pageCount = Math.max(1, Math.ceil(total / pageSize));
+    const current = Math.min(Math.max(1, page), pageCount);
+    return { rows: out.slice((current - 1) * pageSize, current * pageSize), total, pageCount };
+}
+/** Keys of every row that has children (for "expand all"). */
+export function expandableKeys(data, getRowId, getChildren) {
+    const keys = new Set();
+    const visit = (items) => items.forEach((item, i) => {
+        const children = getChildren(item);
+        if (children && children.length) {
+            keys.add(getRowId(item, i));
+            visit(children);
+        }
+    });
+    visit(data);
+    return keys;
+}
+/** `expanded` with `key` toggled (a new Set). */
+export function toggleExpandedKey(expanded, key, allExpandable) {
+    const next = new Set(expanded === "all" ? (allExpandable?.() ?? []) : expanded);
+    if (next.has(key))
+        next.delete(key);
+    else
+        next.add(key);
+    return next;
+}
+// ---------------------------------------------------------------------------------------------------------------
+// Selection (react-stately Selection semantics)
+// ---------------------------------------------------------------------------------------------------------------
+/** Whether `key` is selected (`"all"` selects every key except disabled ones). */
+export function isKeySelected(selection, key, disabled) {
+    if (disabled?.has(key))
+        return false;
+    return selection === "all" || selection.has(key);
+}
+/** The selection with `key` toggled. `"all"` turns into the selectable `keys` minus `key`. */
+export function toggleKeySelection(selection, key, mode, keys, disabled) {
+    if (mode === "none" || disabled?.has(key))
+        return selection;
+    if (mode === "single")
+        return isKeySelected(selection, key, disabled) ? new Set() : new Set([key]);
+    const next = new Set(selection === "all" ? [...keys()].filter((k) => !disabled?.has(k)) : selection);
+    if (next.has(key))
+        next.delete(key);
+    else
+        next.add(key);
+    return next;
+}
+/** Replace the selection with `key` (selectionBehavior "replace" press). */
+export function replaceSelection(mode, key, disabled) {
+    if (mode === "none" || disabled?.has(key))
+        return new Set();
+    return new Set([key]);
+}
+/** Select the range from `anchor` to `key` in `order` (shift-click / shift-arrow), added to `base` when given. */
+export function rangeSelection(order, anchor, key, disabled, base) {
+    const from = order.indexOf(anchor), to = order.indexOf(key);
+    const next = new Set(base ?? []);
+    if (from < 0 || to < 0) {
+        if (!disabled?.has(key))
+            next.add(key);
+        return next;
+    }
+    const [lo, hi] = from <= to ? [from, to] : [to, from];
+    for (let i = lo; i <= hi; i++)
+        if (!disabled?.has(order[i]))
+            next.add(order[i]);
+    return next;
+}
+/** Select-all checkbox state over the selectable `keys`: `"all"`, `"some"` or `"none"`. */
+export function selectAllState(selection, keys, disabled) {
+    if (selection === "all")
+        return keys.some((k) => !disabled?.has(k)) ? "all" : "none";
+    if (selection.size === 0)
+        return "none";
+    let selectable = 0, selected = 0;
+    for (const k of keys) {
+        if (disabled?.has(k))
+            continue;
+        selectable++;
+        if (selection.has(k))
+            selected++;
+    }
+    if (selectable === 0 || selected === 0)
+        return "none";
+    return selected === selectable ? "all" : "some";
+}
+/** Number of selected keys (`"all"`: `total` minus disabled). */
+export function selectionSize(selection, total, disabled) {
+    return selection === "all" ? total - (disabled?.size ?? 0) : selection.size;
+}
+// ---------------------------------------------------------------------------------------------------------------
+// Column layout
+// ---------------------------------------------------------------------------------------------------------------
+/**
+ * CSS widths for `<col>` elements: px for numbers and measured / resized columns, `%` as given, fractions of the
+ * remaining space (`calc((100% - <static px>) * f / Σf)`) for `fr` and width-less columns.
+ */
+export function columnCssWidths(columns, resized, extra = 0) {
+    let staticPx = extra, staticPct = 0, fr = 0;
+    const parsed = columns.map((c) => {
+        const w = resized?.get(c.id) ?? c.width;
+        if (typeof w === "number")
+            return ((staticPx += w), { px: w });
+        if (typeof w === "string" && w.endsWith("%"))
+            return ((staticPct += parseFloat(w)), { pct: parseFloat(w) });
+        const f = typeof w === "string" && w.endsWith("fr") ? parseFloat(w) || 1 : 1;
+        fr += f;
+        return { fr: f };
+    });
+    return parsed.map((p) => {
+        if ("px" in p)
+            return `${p.px}px`;
+        if ("pct" in p)
+            return `${p.pct}%`;
+        const rest = `(100% - ${staticPx}px${staticPct ? ` - ${staticPct}%` : ""})`;
+        return p.fr === fr ? `calc${rest}` : `calc(${rest} * ${p.fr / fr})`;
+    });
+}
+/** Total table width in px when every column has a px width (after a resize), else `null` (100%). */
+export function tableWidthPx(columns, resized, extra = 0) {
+    let sum = extra;
+    for (const c of columns) {
+        const w = resized?.get(c.id) ?? c.width;
+        if (typeof w !== "number")
+            return null;
+        sum += w;
+    }
+    return sum;
+}
+/**
+ * Sticky offsets of pinned columns (`columns` in render order, incl. leading utility columns given as
+ * `{ id, width, pinned }`). A pinned column needs a px width; columns after it pinned to the same side add up.
+ */
+export function pinnedOffsets(columns, resized) {
+    const out = new Map();
+    const widthOf = (c) => {
+        const w = resized?.get(c.id) ?? c.width;
+        return typeof w === "number" ? w : 0;
+    };
+    let start = 0, lastStart = null;
+    for (const c of columns) {
+        if (c.pinned !== "start")
+            continue;
+        out.set(c.id, { side: "start", offset: start, edge: false });
+        start += widthOf(c);
+        lastStart = c.id;
+    }
+    let end = 0, lastEnd = null;
+    for (let i = columns.length - 1; i >= 0; i--) {
+        const c = columns[i];
+        if (c.pinned !== "end")
+            continue;
+        out.set(c.id, { side: "end", offset: end, edge: false });
+        end += widthOf(c);
+        lastEnd = c.id;
+    }
+    if (lastStart)
+        out.get(lastStart).edge = true;
+    if (lastEnd)
+        out.get(lastEnd).edge = true;
+    return out;
+}
+/** Clamp a resized width to the column's min / max (min default 40). */
+export function clampColumnWidth(column, width) {
+    const min = column.minWidth ?? 40, max = column.maxWidth ?? Infinity;
+    return Math.round(Math.min(max, Math.max(min, width)));
+}
+/** Rows `[start, end)` intersecting the viewport (+ `overscan` rows each side) for fixed `rowHeight`. */
+export function virtualWindow(scrollTop, viewportHeight, rowHeight, count, overscan) {
+    if (count === 0 || rowHeight <= 0)
+        return { start: 0, end: 0 };
+    const first = Math.floor(Math.max(0, scrollTop) / rowHeight);
+    const visible = Math.ceil(Math.max(viewportHeight, rowHeight) / rowHeight) + 1;
+    const start = Math.max(0, first - overscan);
+    const end = Math.min(count, first + visible + overscan);
+    return { start: Math.min(start, end), end };
+}
+/** `scrollTop` that brings row `index` fully into a viewport of `viewportHeight` (unchanged when already visible). */
+export function scrollTopFor(index, rowHeight, headerHeight, scrollTop, viewportHeight) {
+    const top = index * rowHeight, bottom = top + rowHeight;
+    const visibleTop = scrollTop, visibleBottom = scrollTop + viewportHeight - headerHeight;
+    if (top < visibleTop)
+        return top;
+    if (bottom > visibleBottom)
+        return bottom - (viewportHeight - headerHeight);
+    return scrollTop;
+}
+/** Move the items with `keys` before / after `target` (order of the moved items kept). Returns a new array. */
+export function reorderItems(items, getRowId, keys, target, position) {
+    if (keys.has(target))
+        return items.slice();
+    const moving = [], rest = [];
+    items.forEach((item, i) => (keys.has(getRowId(item, i)) ? moving : rest).push(item));
+    const at = rest.findIndex((item, i) => getRowId(item, i) === target);
+    if (at < 0)
+        return items.slice();
+    const index = position === "before" ? at : at + 1;
+    return [...rest.slice(0, index), ...moving, ...rest.slice(index)];
+}

package/date/CalendarDate.d.ts

@@ -0,0 +1,207 @@
+import { type AnyCalendarDate, type AnyTime, type Calendar, type CycleOptions, type CycleTimeOptions, type DateDuration, type DateField, type DateFields, type DateTimeDuration, type Disambiguation, type TimeDuration, type TimeField, type TimeFields } from './types.js';
+export type DateValue = CalendarDate | CalendarDateTime | ZonedDateTime;
+/** A CalendarDate represents a date without any time components in a specific calendar system. */
+export declare class CalendarDate {
+    #private;
+    /** The calendar system associated with this date, e.g. Gregorian. */
+    readonly calendar: Calendar;
+    /** The calendar era for this date, e.g. "BC" or "AD". */
+    readonly era: string;
+    /** The year of this date within the era. */
+    readonly year: number;
+    /**
+     * The month number within the year. Note that some calendar systems such as Hebrew
+     * may have a variable number of months per year. Therefore, month numbers may not
+     * always correspond to the same month names in different years.
+     */
+    readonly month: number;
+    /** The day number within the month. */
+    readonly day: number;
+    constructor(year: number, month: number, day: number);
+    constructor(era: string, year: number, month: number, day: number);
+    constructor(calendar: Calendar, year: number, month: number, day: number);
+    constructor(calendar: Calendar, era: string, year: number, month: number, day: number);
+    /** Returns a copy of this date. */
+    copy(): CalendarDate;
+    /** Returns a new `CalendarDate` with the given duration added to it. */
+    add(duration: DateDuration): CalendarDate;
+    /** Returns a new `CalendarDate` with the given duration subtracted from it. */
+    subtract(duration: DateDuration): CalendarDate;
+    /**
+     * Returns a new `CalendarDate` with the given fields set to the provided values. Other fields
+     * will be constrained accordingly.
+     */
+    set(fields: DateFields): CalendarDate;
+    /**
+     * Returns a new `CalendarDate` with the given field adjusted by a specified amount.
+     * When the resulting value reaches the limits of the field, it wraps around.
+     */
+    cycle(field: DateField, amount: number, options?: CycleOptions): CalendarDate;
+    /**
+     * Converts the date to a native JavaScript Date object, with the time set to midnight in the
+     * given time zone.
+     */
+    toDate(timeZone: string): Date;
+    /** Converts the date to an ISO 8601 formatted string. */
+    toString(): string;
+    /**
+     * Compares this date with another. A negative result indicates that this date is before the given
+     * one, and a positive date indicates that it is after.
+     */
+    compare(b: AnyCalendarDate): number;
+}
+/** A Time represents a clock time without any date components. */
+export declare class Time {
+    #private;
+    /** The hour, numbered from 0 to 23. */
+    readonly hour: number;
+    /** The minute in the hour. */
+    readonly minute: number;
+    /** The second in the minute. */
+    readonly second: number;
+    /** The millisecond in the second. */
+    readonly millisecond: number;
+    constructor(hour?: number, minute?: number, second?: number, millisecond?: number);
+    /** Returns a copy of this time. */
+    copy(): Time;
+    /** Returns a new `Time` with the given duration added to it. */
+    add(duration: TimeDuration): Time;
+    /** Returns a new `Time` with the given duration subtracted from it. */
+    subtract(duration: TimeDuration): Time;
+    /**
+     * Returns a new `Time` with the given fields set to the provided values. Other fields will be
+     * constrained accordingly.
+     */
+    set(fields: TimeFields): Time;
+    /**
+     * Returns a new `Time` with the given field adjusted by a specified amount.
+     * When the resulting value reaches the limits of the field, it wraps around.
+     */
+    cycle(field: TimeField, amount: number, options?: CycleTimeOptions): Time;
+    /** Converts the time to an ISO 8601 formatted string. */
+    toString(): string;
+    /**
+     * Compares this time with another. A negative result indicates that this time is before the given
+     * one, and a positive time indicates that it is after.
+     */
+    compare(b: AnyTime): number;
+}
+/** A CalendarDateTime represents a date and time without a time zone, in a specific calendar system. */
+export declare class CalendarDateTime {
+    #private;
+    /** The calendar system associated with this date, e.g. Gregorian. */
+    readonly calendar: Calendar;
+    /** The calendar era for this date, e.g. "BC" or "AD". */
+    readonly era: string;
+    /** The year of this date within the era. */
+    readonly year: number;
+    /**
+     * The month number within the year. Note that some calendar systems such as Hebrew
+     * may have a variable number of months per year. Therefore, month numbers may not
+     * always correspond to the same month names in different years.
+     */
+    readonly month: number;
+    /** The day number within the month. */
+    readonly day: number;
+    /** The hour in the day, numbered from 0 to 23. */
+    readonly hour: number;
+    /** The minute in the hour. */
+    readonly minute: number;
+    /** The second in the minute. */
+    readonly second: number;
+    /** The millisecond in the second. */
+    readonly millisecond: number;
+    constructor(year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number);
+    constructor(era: string, year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number);
+    constructor(calendar: Calendar, year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number);
+    constructor(calendar: Calendar, era: string, year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number);
+    /** Returns a copy of this date. */
+    copy(): CalendarDateTime;
+    /** Returns a new `CalendarDateTime` with the given duration added to it. */
+    add(duration: DateTimeDuration): CalendarDateTime;
+    /** Returns a new `CalendarDateTime` with the given duration subtracted from it. */
+    subtract(duration: DateTimeDuration): CalendarDateTime;
+    /**
+     * Returns a new `CalendarDateTime` with the given fields set to the provided values. Other fields
+     * will be constrained accordingly.
+     */
+    set(fields: DateFields & TimeFields): CalendarDateTime;
+    /**
+     * Returns a new `CalendarDateTime` with the given field adjusted by a specified amount.
+     * When the resulting value reaches the limits of the field, it wraps around.
+     */
+    cycle(field: DateField | TimeField, amount: number, options?: CycleTimeOptions): CalendarDateTime;
+    /** Converts the date to a native JavaScript Date object in the given time zone. */
+    toDate(timeZone: string, disambiguation?: Disambiguation): Date;
+    /** Converts the date to an ISO 8601 formatted string. */
+    toString(): string;
+    /**
+     * Compares this date with another. A negative result indicates that this date is before the given
+     * one, and a positive date indicates that it is after.
+     */
+    compare(b: CalendarDate | CalendarDateTime | ZonedDateTime): number;
+}
+/** A ZonedDateTime represents a date and time in a specific time zone and calendar system. */
+export declare class ZonedDateTime {
+    #private;
+    /** The calendar system associated with this date, e.g. Gregorian. */
+    readonly calendar: Calendar;
+    /** The calendar era for this date, e.g. "BC" or "AD". */
+    readonly era: string;
+    /** The year of this date within the era. */
+    readonly year: number;
+    /**
+     * The month number within the year. Note that some calendar systems such as Hebrew
+     * may have a variable number of months per year. Therefore, month numbers may not
+     * always correspond to the same month names in different years.
+     */
+    readonly month: number;
+    /** The day number within the month. */
+    readonly day: number;
+    /** The hour in the day, numbered from 0 to 23. */
+    readonly hour: number;
+    /** The minute in the hour. */
+    readonly minute: number;
+    /** The second in the minute. */
+    readonly second: number;
+    /** The millisecond in the second. */
+    readonly millisecond: number;
+    /** The IANA time zone identifier that this date and time is represented in. */
+    readonly timeZone: string;
+    /** The UTC offset for this time, in milliseconds. */
+    readonly offset: number;
+    constructor(year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number);
+    constructor(era: string, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number);
+    constructor(calendar: Calendar, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number);
+    constructor(calendar: Calendar, era: string, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number);
+    /** Returns a copy of this date. */
+    copy(): ZonedDateTime;
+    /** Returns a new `ZonedDateTime` with the given duration added to it. */
+    add(duration: DateTimeDuration): ZonedDateTime;
+    /** Returns a new `ZonedDateTime` with the given duration subtracted from it. */
+    subtract(duration: DateTimeDuration): ZonedDateTime;
+    /**
+     * Returns a new `ZonedDateTime` with the given fields set to the provided values. Other fields
+     * will be constrained accordingly.
+     */
+    set(fields: DateFields & TimeFields, disambiguation?: Disambiguation): ZonedDateTime;
+    /**
+     * Returns a new `ZonedDateTime` with the given field adjusted by a specified amount.
+     * When the resulting value reaches the limits of the field, it wraps around.
+     */
+    cycle(field: DateField | TimeField, amount: number, options?: CycleTimeOptions): ZonedDateTime;
+    /** Converts the date to a native JavaScript Date object. */
+    toDate(): Date;
+    /**
+     * Converts the date to an ISO 8601 formatted string, including the UTC offset and time zone
+     * identifier.
+     */
+    toString(): string;
+    /** Converts the date to an ISO 8601 formatted string in UTC. */
+    toAbsoluteString(): string;
+    /**
+     * Compares this date with another. A negative result indicates that this date is before the given
+     * one, and a positive date indicates that it is after.
+     */
+    compare(b: CalendarDate | CalendarDateTime | ZonedDateTime): number;
+}