@proyecto-viviana/solid-stately 0.4.0 → 0.4.1

package/dist/calendar/createDateFieldState.d.ts

@@ -2,20 +2,27 @@
  * DateFieldState for Solid-Stately
  *
  * Provides state management for date field components with segment-based editing.
- * Based on @react-stately/datepicker useDateFieldState
+ * Faithful port of @react-stately/datepicker useDateFieldState.
  *
  * Editing is modeled with an {@link IncompleteDate} display value so that invalid
  * intermediate dates (e.g. February 31st, produced by editing the day before the
  * month) are held as-typed while the field is focused and only constrained on blur
  * via `confirmPlaceholder`, matching upstream behavior. Out-of-range values are
  * never snapped to `minValue`/`maxValue`; they are kept and reported as invalid.
+ *
+ * The upstream "derived state during render" resync (which re-mints the display
+ * value when the committed value / calendar / hour cycle changes) is ported to a
+ * Solid `createComputed` so it runs synchronously before render effects — mirroring
+ * React's render-phase setState rather than a post-render `createEffect`.
  */
 import { type Accessor } from "solid-js";
-import { type CalendarDateTime, type DateValue } from "@internationalized/date";
+import { type Calendar, type CalendarDateTime, type CalendarIdentifier, type DateValue, DateFormatter, Time } from "@internationalized/date";
 import { type MaybeAccessor } from "../utils";
 import type { ValidationState } from "./createCalendarState";
 import { type ValidationBehavior, type ValidationFunction, type ValidationResult } from "../form";
 export type DateSegmentType = "year" | "month" | "day" | "hour" | "minute" | "second" | "dayPeriod" | "era" | "timeZoneName" | "literal";
+type Granularity = "year" | "month" | "day" | "hour" | "minute" | "second";
+type FieldGranularity = "day" | "hour" | "minute" | "second";
 export interface DateSegment {
     /** The type of segment. */
     type: DateSegmentType;
@@ -56,7 +63,9 @@ export interface DateFieldStateProps<T extends DateValue = DateValue> {
     /** The locale to use for formatting. */
     locale?: string;
     /** The granularity of the date/time (day, hour, minute, second). */
-    granularity?: "day" | "hour" | "minute" | "second";
+    granularity?: FieldGranularity;
+    /** The maximum granularity (largest editable unit). Defaults to `year`. */
+    maxGranularity?: "year" | "month" | "day" | "hour" | "minute";
     /** Whether to show the hour in 12 or 24 hour format. */
     hourCycle?: 12 | 24;
     /** Whether to hide the time zone. */
@@ -77,28 +86,42 @@ export interface DateFieldStateProps<T extends DateValue = DateValue> {
     errorMessage?: string;
     /** Whether dates outside the min/max range are allowed. */
     allowsNonContiguousRanges?: boolean;
-    /** Whether to create a date or datetime. */
-    createCalendar?: (name: string) => unknown;
+    /** Resolves a calendar system by its Unicode identifier. */
+    createCalendar?: (name: CalendarIdentifier) => Calendar;
     /** Whether a date is unavailable. */
     isDateUnavailable?: (date: DateValue) => boolean;
 }
 export interface DateFieldState<T extends DateValue = DateValue> {
-    /** The current value. */
-    value: Accessor<T | null>;
-    /** The date value (may be partial during editing). */
-    dateValue: Accessor<DateValue | null>;
+    /** The current value, converted to the display calendar. */
+    value: Accessor<DateValue | null>;
+    /** The current value as a native JavaScript Date (may be partial during editing). */
+    dateValue: Accessor<Date>;
+    /** The display calendar system. */
+    readonly calendar: Calendar;
     /** Sets the date value. */
     setValue: (value: T | null) => void;
     /** The segments that make up the date. */
     segments: Accessor<DateSegment[]>;
-    /** The format string. */
+    /** The formatter used to render the field. */
+    readonly dateFormatter: DateFormatter;
+    /** Formats the current value with the given field options. */
     formatValue: (fieldOptions?: Intl.DateTimeFormatOptions) => string;
+    /** Returns a formatter with the field's resolved options merged with the given ones. */
+    getDateFormatter: (locale: string, formatOptions: FormatterOptions) => DateFormatter;
     /** Sets a segment value. */
     setSegment: (type: DateSegmentType, value: number) => void;
-    /** Increments a segment. */
-    incrementSegment: (type: DateSegmentType) => void;
-    /** Decrements a segment. */
-    decrementSegment: (type: DateSegmentType) => void;
+    /** Increments a segment by one. */
+    increment: (type: DateSegmentType) => void;
+    /** Decrements a segment by one. */
+    decrement: (type: DateSegmentType) => void;
+    /** Increments a segment by a larger page step. */
+    incrementPage: (type: DateSegmentType) => void;
+    /** Decrements a segment by a larger page step. */
+    decrementPage: (type: DateSegmentType) => void;
+    /** Sets a segment to its maximum value. */
+    incrementToMax: (type: DateSegmentType) => void;
+    /** Sets a segment to its minimum value. */
+    decrementToMin: (type: DateSegmentType) => void;
     /** Clears a segment. */
     clearSegment: (type: DateSegmentType) => void;
     /** Confirms the value (after typing). */
@@ -112,7 +135,9 @@ export interface DateFieldState<T extends DateValue = DateValue> {
     /** The validation state. */
     validationState: Accessor<ValidationState | undefined>;
     /** The granularity. */
-    granularity: "day" | "hour" | "minute" | "second";
+    readonly granularity: FieldGranularity;
+    /** The maximum granularity. */
+    readonly maxGranularity: "year" | "month" | "day" | "hour" | "minute";
     /** Whether the value is invalid. */
     isInvalid: Accessor<boolean>;
     /** Realtime validation results, including native and custom constraints. */
@@ -126,14 +151,27 @@ export interface DateFieldState<T extends DateValue = DateValue> {
     /** Commits realtime validation to displayed validation. */
     commitValidation: () => void;
     /** The locale. */
-    locale: string;
+    readonly locale: string;
     /** The time zone. */
-    timeZone: string;
+    readonly timeZone: string;
     /** The default value. */
-    defaultValue: T | null;
+    defaultValue: DateValue | null;
 }
 /**
  * Provides state management for a date field component.
  */
 export declare function createDateFieldState<T extends DateValue = DateValue>(props?: DateFieldStateProps<T>): DateFieldState<T>;
+interface FormatterOptions {
+    timeZone?: string;
+    hideTimeZone?: boolean;
+    granularity?: Granularity;
+    maxGranularity?: "year" | "month" | "day" | "hour" | "minute";
+    hourCycle?: 12 | 24;
+    showEra?: boolean;
+    shouldForceLeadingZeros?: boolean;
+}
+export declare function getFormatOptions(fieldOptions: Intl.DateTimeFormatOptions | undefined, options: FormatterOptions): Intl.DateTimeFormatOptions;
+/** The placeholder time, used by time-only fields. */
+export declare function getPlaceholderTime(placeholderValue?: DateValue): Time | DateValue;
+export declare function getValidationResult(value: DateValue | null, minValue: DateValue | undefined, maxValue: DateValue | undefined, isDateUnavailable: ((date: DateValue) => boolean) | undefined, options: FormatterOptions): ValidationResult;
 export type { CalendarDateTime };

package/dist/calendar/createRangeCalendarState.d.ts

@@ -164,6 +164,16 @@ export interface RangeCalendarState<T extends DateValue = DateValue> {
     isDragging: Accessor<boolean>;
     /** Sets whether the user is dragging to select. */
     setDragging: (dragging: boolean) => void;
+    /**
+     * Formats the selected range as a `{ start, end }` pair of localized strings,
+     * or `null` when the range is incomplete. Mirrors upstream
+     * `DateRangePickerState.formatValue` — the port collapses that state into the
+     * range calendar state, so the range picker reads its SR description from here.
+     */
+    formatValue: (locale: string, fieldOptions: Intl.DateTimeFormatOptions) => {
+        start: string;
+        end: string;
+    } | null;
 }
 /**
  * Provides state management for a range calendar component.

package/dist/calendar/createTimeFieldState.d.ts

@@ -1,34 +1,37 @@
 /**
  * TimeFieldState for Solid-Stately
  *
- * Provides state management for time field components with segment-based editing.
- * Based on @react-stately/datepicker useTimeFieldState
+ * Faithful port of `@react-stately/datepicker` `useTimeFieldState`, which is a
+ * thin wrapper over `useDateFieldState`: a time-only `Time` value is converted
+ * to a `CalendarDateTime` (anchored on today's date, or a zoned date when the
+ * value/default carries a time zone) and fed to the date-field state machine
+ * with `maxGranularity: 'hour'` so the date segments drop away and only
+ * hour/minute[/second]/dayPeriod remain. The returned state IS the
+ * `DateFieldState`, plus a `timeValue` accessor holding the value back in the
+ * `Time` domain. This means TimeField reuses the certified DateField segment
+ * stack (`createDateSegment`, `DateInput`, `DateSegment`) exactly as RAC's
+ * TimeField reuses `DateInput`/`DateSegment` — there is no parallel time
+ * primitive.
+ *
+ * The `timeValue` is layered on with a Proxy rather than an object spread
+ * because `DateFieldState`'s `calendar`/`dateFormatter`/`granularity`/
+ * `maxGranularity`/`locale`/`timeZone` members are getters — spreading would
+ * invoke and freeze them, breaking reactivity.
  */
 import { type Accessor } from "solid-js";
-import { type Time, type CalendarDateTime, type ZonedDateTime, type DateValue } from "@internationalized/date";
+import { Time, type CalendarDateTime, type ZonedDateTime, type DateValue } from "@internationalized/date";
 import { type MaybeAccessor } from "../utils";
 import type { ValidationState } from "./createCalendarState";
-import { type ValidationBehavior, type ValidationFunction, type ValidationResult } from "../form";
+import type { ValidationBehavior, ValidationFunction } from "../form";
+import { type DateFieldState, type DateSegment as DateSegmentInternal, type DateSegmentType as DateSegmentTypeInternal } from "./createDateFieldState";
 export type TimeValue = Time | CalendarDateTime | ZonedDateTime;
-export type TimeSegmentType = "hour" | "minute" | "second" | "dayPeriod" | "literal";
-export interface TimeSegment {
-    /** The type of segment. */
-    type: TimeSegmentType;
-    /** The text content of the segment. */
-    text: string;
-    /** The numeric value of the segment (if applicable). */
-    value?: number;
-    /** The minimum value for the segment. */
-    minValue?: number;
-    /** The maximum value for the segment. */
-    maxValue?: number;
-    /** Whether this segment is editable. */
-    isEditable: boolean;
-    /** Whether this segment is a placeholder. */
-    isPlaceholder: boolean;
-    /** A placeholder string for the segment. */
-    placeholder: string;
-}
+/**
+ * TimeField reuses the DateField segment vocabulary (RAC TimeField reuses
+ * `DateInput`/`DateSegment`); the legacy `TimeSegment`/`TimeSegmentType` names
+ * are kept as aliases of the shared date-segment types.
+ */
+export type TimeSegmentType = DateSegmentTypeInternal;
+export type TimeSegment = DateSegmentInternal;
 export interface TimeFieldStateProps<T extends TimeValue = Time> {
     /** The current value (controlled). */
     value?: MaybeAccessor<T | null>;
@@ -54,6 +57,8 @@ export interface TimeFieldStateProps<T extends TimeValue = Time> {
     granularity?: "hour" | "minute" | "second";
     /** Whether to show 12 or 24 hour format. */
     hourCycle?: 12 | 24;
+    /** Whether to hide the time zone. */
+    hideTimeZone?: boolean;
     /** Whether to force leading zeroes in the hour segment. */
     shouldForceLeadingZeros?: boolean;
     /** Validation state. */
@@ -61,7 +66,7 @@ export interface TimeFieldStateProps<T extends TimeValue = Time> {
     /** Validation behavior mode. */
     validationBehavior?: ValidationBehavior;
     /** Custom validation function. */
-    validate?: ValidationFunction<T>;
+    validate?: ValidationFunction<T | null>;
     /** Description text. */
     description?: string;
     /** Error message. */
@@ -71,49 +76,15 @@ export interface TimeFieldStateProps<T extends TimeValue = Time> {
     /** Whether dates outside the min/max range are unavailable. Added for API consistency. */
     isDateUnavailable?: (date: DateValue) => boolean;
 }
-export interface TimeFieldState<T extends TimeValue = Time> {
-    /** The current value. */
-    value: Accessor<T | null>;
-    /** The default value. */
-    defaultValue: T | null;
-    /** Sets the value. */
-    setValue: (value: T | null) => void;
-    /** The segments that make up the time. */
-    segments: Accessor<TimeSegment[]>;
-    /** Sets a segment value. */
-    setSegment: (type: TimeSegmentType, value: number) => void;
-    /** Increments a segment. */
-    incrementSegment: (type: TimeSegmentType) => void;
-    /** Decrements a segment. */
-    decrementSegment: (type: TimeSegmentType) => void;
-    /** Clears a segment. */
-    clearSegment: (type: TimeSegmentType) => void;
-    /** Whether the field is disabled. */
-    isDisabled: Accessor<boolean>;
-    /** Whether the field is read-only. */
-    isReadOnly: Accessor<boolean>;
-    /** Whether the field is required. */
-    isRequired: Accessor<boolean>;
-    /** The validation state. */
-    validationState: Accessor<ValidationState | undefined>;
-    /** The granularity. */
-    granularity: "hour" | "minute" | "second";
-    /** Whether the value is invalid. */
-    isInvalid: Accessor<boolean>;
-    /** Realtime validation results, including native and custom constraints. */
-    realtimeValidation: Accessor<ValidationResult>;
-    /** Currently displayed validation results. */
-    displayValidation: Accessor<ValidationResult>;
-    /** Updates the current validation result. */
-    updateValidation: (result: ValidationResult) => void;
-    /** Resets displayed validation to valid. */
-    resetValidation: () => void;
-    /** Commits realtime validation to displayed validation. */
-    commitValidation: () => void;
-    /** The locale. */
-    locale: string;
-    /** The hour cycle. */
-    hourCycle: 12 | 24;
+/**
+ * The TimeField state IS the certified DateField state (segments, validation,
+ * increment/decrement, formatter, etc.) with a `timeValue` accessor added. The
+ * `T` generic is retained for API back-compat with existing `TimeFieldState<T>`
+ * consumers.
+ */
+export interface TimeFieldState<T extends TimeValue = Time> extends DateFieldState {
+    /** The current value in the `Time`/`CalendarDateTime`/`ZonedDateTime` domain. */
+    timeValue: Accessor<TimeValue | null>;
 }
 /**
  * Provides state management for a time field component.

package/dist/calendar/intl/index.d.ts

@@ -0,0 +1,10 @@
+export type DateFieldErrorKey = "rangeUnderflow" | "rangeOverflow" | "rangeReversed" | "unavailableDate";
+type DateFieldErrorArgs = {
+    minValue?: string;
+    maxValue?: string;
+};
+/** Mirrors LocalizedStringFormatter.format for the datepicker validation messages. */
+export declare function formatDateFieldError(locale: string, key: DateFieldErrorKey, args?: DateFieldErrorArgs): string;
+/** Mirrors @react-stately/datepicker getPlaceholder. */
+export declare function getPlaceholder(field: string, value: string, locale: string): string;
+export {};

package/dist/collections/ListCollection.d.ts

@@ -21,6 +21,14 @@ export declare class ListCollection<T = unknown> implements Collection<T> {
     getLastKey(): Key | null;
     getChildren(key: Key): Iterable<CollectionNode<T>>;
     getTextValue(key: Key): string;
+    /**
+     * Filter the collection, returning a new `ListCollection` containing only the
+     * item nodes for which `filterFn(node.textValue, node)` returns true. Sections
+     * whose children are all filtered out are dropped; surviving sections are
+     * rebuilt with their filtered children. Node order is preserved. Mirrors the
+     * behaviour of @react-aria/collections `BaseCollection.filter`.
+     */
+    filter(filterFn: (nodeValue: string, node: CollectionNode<T>) => boolean): ListCollection<T>;
     /**
      * Get all items (excluding sections, including items within sections).
      */

package/dist/collections/createListState.d.ts

@@ -56,6 +56,18 @@ export interface ListState<T = unknown> extends SelectionState {
  * Creates state for a list component with selection.
  */
 export declare function createListState<T = unknown>(props: MaybeAccessor<ListStateProps<T>>): ListState<T>;
+/** A collection filter predicate: `(nodeTextValue, node) => keep`. */
+export type ListFilterFn<T = unknown> = (nodeValue: string, node: CollectionNode<T>) => boolean;
+/**
+ * Wraps a {@link ListState} so its collection is filtered by `filterFn`, returning
+ * a new (reactive) ListState. Mirrors @react-stately's `UNSTABLE_useFilteredListState`
+ * (used by Autocomplete): the filter re-runs as the predicate — which typically
+ * closes over the current input value — or the base collection changes; a single
+ * stable, collection-aware manager reads the narrowed collection live and shares
+ * the base selection/focus state; and the focused key is reset to the nearest
+ * surviving item when the current one is filtered out.
+ */
+export declare function createFilteredListState<T = unknown>(state: ListState<T>, filterFn: Accessor<ListFilterFn<T> | null | undefined>): ListState<T>;
 /**
  * Props for single selection list state.
  */

package/dist/collections/getChildNodes.d.ts

@@ -8,4 +8,12 @@ export declare function getChildNodes<T>(node: CollectionNode<T>, collection: Co
 export declare function getFirstItem<T>(iterable: Iterable<T>): T | undefined;
 export declare function getNthItem<T>(iterable: Iterable<T>, index: number): T | undefined;
 export declare function getLastItem<T>(iterable: Iterable<T>): T | undefined;
+/**
+ * Counts the item nodes (recursing into sections, ignoring section headers and
+ * other non-item nodes) in a collection. Faithful port of
+ * @react-stately/collections `getItemCount`; used by createOption to populate
+ * `aria-setsize` when the listbox is virtualized. Cached per (immutable)
+ * collection identity, exactly like upstream.
+ */
+export declare function getItemCount<T>(collection: Collection<T>): number;
 export declare function compareNodeOrder<T>(collection: Collection<T>, a: CollectionNode<T>, b: CollectionNode<T>): number;

package/dist/collections/index.d.ts

@@ -1,6 +1,6 @@
 export type { Key, SelectionMode, SelectionBehavior, Selection, FocusStrategy, DisabledBehavior, CollectionNode, Collection, ItemProps, SectionProps, CollectionBase, SingleSelection, MultipleSelection, } from "./types";
 export { ListCollection, createListCollection } from "./ListCollection";
-export { getChildNodes, getFirstItem, getNthItem, getLastItem, compareNodeOrder, } from "./getChildNodes";
+export { getChildNodes, getFirstItem, getNthItem, getLastItem, getItemCount, compareNodeOrder, } from "./getChildNodes";
 export { createSelectionState, type SelectionStateProps, type SelectionState, type SelectionPressEvent, } from "./createSelectionState";
-export { createListState, createSingleSelectListState, type ListStateProps, type ListState, type SingleSelectListStateProps, type SingleSelectListState, } from "./createListState";
+export { createListState, createFilteredListState, createSingleSelectListState, type ListStateProps, type ListState, type ListFilterFn, type SingleSelectListStateProps, type SingleSelectListState, } from "./createListState";
 export { createMenuState, createMenuTriggerState, type MenuStateProps, type MenuState, type MenuTriggerStateProps, type MenuTriggerState, } from "./createMenuState";

package/dist/collections/types.d.ts

@@ -70,6 +70,15 @@ export interface Collection<T = unknown> extends Iterable<CollectionNode<T>> {
     getChildren(key: Key): Iterable<CollectionNode<T>>;
     /** Get the text value for a key. */
     getTextValue(key: Key): string;
+    /**
+     * Filter the collection, returning a new collection containing only the item
+     * nodes for which `filterFn` returns true. Sections whose children are all
+     * filtered out are dropped. Mirrors @react-aria/collections
+     * `BaseCollection.filter` (and the optional `Collection.filter` in
+     * @react-types/shared). Used by Autocomplete to narrow the collection as the
+     * user types.
+     */
+    filter?(filterFn: (nodeValue: string, node: CollectionNode<T>) => boolean): Collection<T>;
 }
 /**
  * Structural shape expected when inferring collection item properties

package/dist/color/intl/index.d.ts

@@ -0,0 +1,14 @@
+export type ColorStringKey = "hue" | "saturation" | "lightness" | "brightness" | "red" | "green" | "blue" | "alpha" | "colorName" | "transparentColorName" | "very dark" | "dark" | "light" | "very light" | "pale" | "grayish" | "vibrant" | "black" | "white" | "gray" | "pink" | "pink red" | "red orange" | "brown" | "orange" | "orange yellow" | "brown yellow" | "yellow" | "yellow green" | "green cyan" | "cyan" | "cyan blue" | "blue purple" | "purple" | "purple magenta" | "magenta" | "magenta pink";
+export declare const colorStrings: Record<string, Record<ColorStringKey, string>>;
+/**
+ * Mirrors LocalizedStringDictionary.getStringForLocale: exact-locale match,
+ * then language-only match (e.g. "ar" for "ar-AE"), then the en-US fallback.
+ * Ported so solid-stately's Color needs no @internationalized/string dependency.
+ */
+export declare function getColorStringForLocale(key: ColorStringKey, locale: string): string;
+/**
+ * Mirrors LocalizedStringFormatter.format for the plain `{variable}` messages
+ * used by color names (colorName / transparentColorName). Substitutes each
+ * `{name}` token with the matching variable's string value.
+ */
+export declare function formatColorMessage(key: ColorStringKey, locale: string, variables: Record<string, string>): string;

package/dist/dnd/createDroppableCollectionState.d.ts

@@ -5,6 +5,7 @@
  */
 import { type Accessor } from "solid-js";
 import type { DropItem, DropTarget, DropOperation, DragTypes, DroppableCollectionEnterEvent, DroppableCollectionActivateEvent, DroppableCollectionExitEvent, DroppableCollectionDropEvent, DroppableCollectionInsertDropEvent, DroppableCollectionRootDropEvent, DroppableCollectionOnItemDropEvent, DroppableCollectionReorderEvent, ItemDropTarget } from "./types";
+import type { Collection } from "../collections/types";
 export interface DroppableCollectionStateOptions {
     /**
      * The drag types that the droppable collection accepts.
@@ -35,6 +36,14 @@ export interface DroppableCollectionStateOptions {
     onMove?: (e: DroppableCollectionReorderEvent) => void;
     /** A function returning whether a given target is a valid "on" drop target. */
     shouldAcceptItemDrop?: (target: ItemDropTarget, types: DragTypes) => boolean;
+    /**
+     * The host collection. Used by the default drop-operation feature detection to
+     * confirm a reorder stays within the same parent and to prevent dropping an
+     * item onto itself or a descendant. Optional: a flat collection (e.g. a plain
+     * ListBox) is always "within parent" and has no descendants, so omitting it is
+     * faithful for flat hosts.
+     */
+    collection?: Collection<unknown>;
     /** Whether the droppable collection is disabled. */
     isDisabled?: boolean;
 }
@@ -59,8 +68,14 @@ export interface DroppableCollectionState {
     activateTarget(x: number, y: number): void;
     /** Perform a drop on the collection. */
     drop(items: DropItem[], dropOperation: DropOperation, isInternal: boolean, draggingKeys?: Set<string | number>): void;
-    /** Get the drop operation for a target. */
-    getDropOperation(target: DropTarget, types: DragTypes, allowedOperations: DropOperation[]): DropOperation;
+    /**
+     * Get the drop operation for a target. `isInternal` is true when the active
+     * drag originated from this same collection; `draggingKeys` are the keys being
+     * dragged. Both feed the handler-aware feature detection that decides whether a
+     * given drop position (before/after/on/root) is a valid target — e.g. a
+     * reorder-only collection rejects "on" targets, matching React Aria.
+     */
+    getDropOperation(target: DropTarget, types: DragTypes, allowedOperations: DropOperation[], isInternal?: boolean, draggingKeys?: Set<string | number>): DropOperation;
     /** Check if an item drop should be accepted. */
     shouldAcceptItemDrop(target: ItemDropTarget, types: DragTypes): boolean;
 }

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export { createTextFieldState, type TextFieldStateOptions, type TextFieldState }
 export { createCheckboxGroupState, type CheckboxGroupProps, type CheckboxGroupState, } from "./checkbox";
 export { createRadioGroupState, radioGroupSyncVersion, type RadioGroupProps, type RadioGroupState, } from "./radio";
 export { createOverlayTriggerState, type OverlayTriggerProps, type OverlayTriggerState, } from "./overlays";
-export { type Key, type SelectionMode, type SelectionBehavior, type Selection, type FocusStrategy, type DisabledBehavior, type CollectionNode, type Collection, type ItemProps, type SectionProps, type CollectionBase, type SingleSelection, type MultipleSelection, ListCollection, createListCollection, createSelectionState, type SelectionStateProps, type SelectionState, type SelectionPressEvent, createListState, createSingleSelectListState, type ListStateProps, type ListState, type SingleSelectListStateProps, type SingleSelectListState, createMenuState, createMenuTriggerState, type MenuStateProps, type MenuState, type MenuTriggerStateProps, type MenuTriggerState, } from "./collections";
+export { type Key, type SelectionMode, type SelectionBehavior, type Selection, type FocusStrategy, type DisabledBehavior, type CollectionNode, type Collection, type ItemProps, type SectionProps, type CollectionBase, type SingleSelection, type MultipleSelection, ListCollection, createListCollection, getItemCount, createSelectionState, type SelectionStateProps, type SelectionState, type SelectionPressEvent, createListState, createFilteredListState, createSingleSelectListState, type ListStateProps, type ListState, type ListFilterFn, type SingleSelectListStateProps, type SingleSelectListState, createMenuState, createMenuTriggerState, type MenuStateProps, type MenuState, type MenuTriggerStateProps, type MenuTriggerState, } from "./collections";
 export { useMultipleSelectionState, type MultipleSelectionStateProps, type MultipleSelectionState, SelectionManager, type SelectionManagerOptions, type LayoutDelegate, } from "./selection";
 export { useMenuTriggerState } from "./menu";
 export { useDateFieldState, useDatePickerState, useDateRangePickerState, useTimeFieldState, type DateFieldStateOptions, type DatePickerStateOptions, type DateRangePickerStateOptions, type TimeFieldStateOptions, type SegmentType, } from "./datepicker";