sheer-ui 0.4.2 → 0.5.0

package/dist/components/combobox/select/types.d.ts

@@ -0,0 +1,226 @@
+import type { Expand } from '../../../internal/tools/index.js';
+import type { PortalProps } from '../../../internal/portal/index.js';
+import type { PopperLayerProps, PopperLayerStaticProps } from '../../../internal/popper-layer/types.js';
+import type { BitsPrimitiveButtonAttributes, BitsPrimitiveDivAttributes, BitsPrimitiveSpanAttributes } from '../../../internal/attribute-types.js';
+import type { OnChangeFn, WithChild, WithChildNoChildrenSnippetProps, Without } from '../../../internal/types.js';
+import type { Snippet } from 'svelte';
+import type { OpenCell } from '../../../internal/open-cell.svelte.js';
+import type { FloatingContentSnippetProps, StaticContentSnippetProps } from '../../../internal/types.js';
+import type { HTMLInputAttributes } from 'svelte/elements';
+export type SelectSharedRootPropsWithoutHTML = {
+    /**
+     * Whether the combobox is disabled.
+     *
+     * @defaultValue `false`
+     */
+    disabled?: boolean;
+    /**
+     * Whether the combobox is required (for form submission).
+     *
+     * @defaultValue `false`
+     */
+    required?: boolean;
+    /**
+     * The name to apply to the hidden input element for form submission.
+     * If not provided, a hidden input will not be rendered and the combobox will not be part of a form.
+     */
+    name?: string;
+    /**
+     * A callback function called when the open state changes and the animation is complete.
+     */
+    onOpenChangeComplete?: OnChangeFn<boolean>;
+    /**
+     * Whether or not the combobox menu should loop through the items when navigating with the keyboard.
+     *
+     * @defaultValue `false`
+     */
+    loop?: boolean;
+    /**
+     * How to scroll the combobox items into view when navigating with the keyboard.
+     *
+     * @defaultValue `"nearest"`
+     */
+    scrollAlignment?: 'nearest' | 'center';
+    /**
+     * Optionally provide an array of `value` and `label` pairs that will be used to match
+     * and trigger selection when the trigger is focused and a key is pressed while the content
+     * is closed. It's also used to handle form autofill.
+     *
+     * By providing this value, you enable selecting a value when the trigger is focused and a key
+     * is pressed without the content being open, similar to how a native `<select>` works.
+     * For this to work, you must
+     *
+     * The label is what the user will potentially search for via typeahead, and the value is what
+     * is set as the selected value when a typeahead match is found.
+     *
+     * We can't rely on the individual `Item` components to do this because they may not ever be
+     * mounted to do the DOM if using a conditional block with a Svelte transition or certain
+     * animation libraries.
+     *
+     * IMPORTANT: This functionality is only available for single-select listboxes.
+     */
+    items?: {
+        value: string;
+        label: string;
+        disabled?: boolean;
+    }[];
+    /**
+     * Whether to allow the user to deselect an item by clicking on an already selected item.
+     * This is only applicable to `type="single"` selects/comboboxes.
+     */
+    allowDeselect?: boolean;
+    /**
+     * The autocomplete attribute to forward to the hidden input element.
+     */
+    autocomplete?: HTMLInputAttributes['autocomplete'];
+};
+export type SelectBaseRootPropsWithoutHTML = SelectSharedRootPropsWithoutHTML & {
+    /**
+     * The derivation source for the select's open state: the internal cell
+     * re-derives whenever this prop changes, and interactions (trigger, Escape,
+     * a snippet-cell write) override it until the next change. Reconcile
+     * dismissals via onOpenChangeComplete. Plain value — not bindable.
+     */
+    open?: boolean;
+    /**
+     * A caller-constructed cell (own source and, optionally, a delegate writer)
+     * used instead of building one from `open`. When given, `open` is ignored.
+     */
+    state?: OpenCell;
+    /** Children receive the state cell, typed and guaranteed within the tree. */
+    children?: Snippet<[OpenCell]>;
+};
+export type SelectSingleRootPropsWithoutHTML = {
+    /**
+     * The value of the selected combobox item.
+     *
+     * @bindable
+     */
+    value?: string;
+    /**
+     * A callback function called when the value changes.
+     */
+    onValueChange?: OnChangeFn<string>;
+    /**
+     * The type of combobox.
+     *
+     * @required
+     */
+    type: 'single';
+};
+export type SelectMultipleRootPropsWithoutHTML = {
+    /**
+     * The value of the selected combobox item.
+     *
+     * @bindable
+     */
+    value?: string[];
+    /**
+     * A callback function called when the value changes.
+     */
+    onValueChange?: OnChangeFn<string[]>;
+    /**
+     * The type of combobox.
+     *
+     * @required
+     */
+    type: 'multiple';
+};
+export type SelectSingleRootProps = SelectBaseRootPropsWithoutHTML & SelectSingleRootPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, SelectSingleRootPropsWithoutHTML | SelectBaseRootPropsWithoutHTML>;
+export type SelectMultipleRootProps = SelectBaseRootPropsWithoutHTML & SelectMultipleRootPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, SelectMultipleRootPropsWithoutHTML | SelectBaseRootPropsWithoutHTML>;
+export type SelectRootPropsWithoutHTML = SelectBaseRootPropsWithoutHTML & (SelectSingleRootPropsWithoutHTML | SelectMultipleRootPropsWithoutHTML);
+export type SelectRootProps = SelectRootPropsWithoutHTML;
+export type SelectValueSnippetProps = {
+    selection: {
+        type: 'single';
+        selected?: {
+            value: string;
+            label: string;
+        };
+        setValue: (value: string) => void;
+    } | {
+        type: 'multiple';
+        selected: {
+            value: string;
+            label: string;
+        }[];
+        setValue: (value: string[]) => void;
+    };
+    placeholder: string | null;
+    disabled: boolean;
+};
+export type SelectValuePropsWithoutHTML = WithChild<{}, SelectValueSnippetProps>;
+export type SelectValueProps = SelectValuePropsWithoutHTML & Without<BitsPrimitiveSpanAttributes, SelectValuePropsWithoutHTML>;
+export type _SharedSelectContentProps = {
+    /**
+     * Whether or not to loop through the items when navigating with the keyboard.
+     *
+     * @defaultValue `false`
+     */
+    loop?: boolean;
+};
+export type SelectContentPropsWithoutHTML = Expand<WithChildNoChildrenSnippetProps<Omit<PopperLayerProps, 'content' | 'onOpenAutoFocus' | 'trapFocus' | 'onCloseAutoFocus'> & _SharedSelectContentProps, FloatingContentSnippetProps>>;
+export type SelectContentProps = SelectContentPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, SelectContentPropsWithoutHTML>;
+export type SelectContentStaticPropsWithoutHTML = Expand<WithChildNoChildrenSnippetProps<Omit<PopperLayerStaticProps, 'content' | 'onOpenAutoFocus' | 'onCloseAutoFocus' | 'trapFocus'> & _SharedSelectContentProps, StaticContentSnippetProps>>;
+export type SelectContentStaticProps = SelectContentStaticPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, SelectContentStaticPropsWithoutHTML>;
+export type SelectTriggerPropsWithoutHTML = WithChild;
+export type SelectTriggerProps = SelectTriggerPropsWithoutHTML & Without<BitsPrimitiveButtonAttributes, SelectTriggerPropsWithoutHTML>;
+export type SelectItemSnippetProps = {
+    selected: boolean;
+    highlighted: boolean;
+};
+export type SelectItemPropsWithoutHTML = WithChild<{
+    /**
+     * The value of the item.
+     *
+     * @required
+     */
+    value: string;
+    /**
+     * The label of the item. If provided, this is the item that users will search for.
+     * If not provided, the value will be used as the label.
+     */
+    label?: string;
+    /**
+     * Whether the item is disabled.
+     *
+     * @defaultValue `false`
+     */
+    disabled?: boolean;
+    /**
+     * A callback function called when the item is highlighted. This can be used as a
+     * replacement for `onfocus` since we don't actually focus the item and instead
+     * rely on the `aria-activedescendant` attribute to indicate the highlighted item.
+     */
+    onHighlight?: () => void;
+    /**
+     * A callback function called when the item is unhighlighted. This can be used as a
+     * replacement for `onblur` since we don't actually focus the item and instead
+     * rely on the `aria-activedescendant` attribute to indicate the highlighted item.
+     */
+    onUnhighlight?: () => void;
+}, SelectItemSnippetProps>;
+export type SelectItemProps = SelectItemPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, SelectItemPropsWithoutHTML>;
+export type SelectGroupPropsWithoutHTML = WithChild;
+export type SelectGroupProps = SelectGroupPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, SelectGroupPropsWithoutHTML>;
+export type SelectGroupHeadingPropsWithoutHTML = WithChild;
+export type SelectGroupHeadingProps = SelectGroupHeadingPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, SelectGroupHeadingPropsWithoutHTML>;
+export type SelectSeparatorPropsWithoutHTML = WithChild;
+export type SelectSeparatorProps = SelectSeparatorPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, SelectSeparatorPropsWithoutHTML>;
+export type SelectPortalPropsWithoutHTML = PortalProps;
+export type SelectPortalProps = SelectPortalPropsWithoutHTML;
+export type SelectViewportPropsWithoutHTML = WithChild;
+export type SelectViewportProps = SelectViewportPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, SelectViewportPropsWithoutHTML>;
+export type SelectScrollButtonPropsWithoutHTML = WithChild<{
+    /**
+     * Controls the initial delay (tick 0) and delay between auto-scrolls in milliseconds.
+     * The default function always returns 50ms.
+     *
+     * @param tick current tick number
+     */
+    delay?: (tick: number) => number;
+}>;
+export type SelectScrollUpButtonPropsWithoutHTML = SelectScrollButtonPropsWithoutHTML;
+export type SelectScrollUpButtonProps = SelectScrollUpButtonPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, SelectScrollUpButtonPropsWithoutHTML>;
+export type SelectScrollDownButtonPropsWithoutHTML = SelectScrollButtonPropsWithoutHTML;
+export type SelectScrollDownButtonProps = SelectScrollDownButtonPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, SelectScrollDownButtonPropsWithoutHTML>;

package/dist/components/combobox/select/types.js

@@ -0,0 +1 @@
+export {};

package/dist/components/combobox/types.d.ts

@@ -0,0 +1,37 @@
+import type { BitsPrimitiveInputAttributes } from '../../internal/attribute-types.js';
+import type { LucideProps } from '@lucide/svelte';
+import type { SelectBaseRootPropsWithoutHTML, SelectMultipleRootPropsWithoutHTML, SelectSingleRootPropsWithoutHTML } from './select/types.js';
+import type { WithChild, Without } from '../../internal/types.js';
+export type ComboboxBaseRootPropsWithoutHTML = Omit<SelectBaseRootPropsWithoutHTML, 'autocomplete'> & {
+    /**
+     * A read-only value that can be used to programmatically
+     * update the input value.
+     *
+     * This is useful for updating the displayed label/input
+     * when the value changes outside of Bits UI.
+     */
+    inputValue?: string;
+};
+export type ComboboxSingleRootPropsWithoutHTML = ComboboxBaseRootPropsWithoutHTML & SelectSingleRootPropsWithoutHTML;
+export type ComboboxSingleRootProps = ComboboxSingleRootPropsWithoutHTML;
+export type ComboboxMultipleRootPropsWithoutHTML = ComboboxBaseRootPropsWithoutHTML & SelectMultipleRootPropsWithoutHTML;
+export type ComboboxMultipleRootProps = ComboboxMultipleRootPropsWithoutHTML;
+export type ComboboxRootPropsWithoutHTML = ComboboxBaseRootPropsWithoutHTML & (ComboboxSingleRootPropsWithoutHTML | ComboboxMultipleRootPropsWithoutHTML);
+export type ComboboxRootProps = ComboboxRootPropsWithoutHTML;
+export type { SelectContentProps as ComboboxContentProps, SelectContentPropsWithoutHTML as ComboboxContentPropsWithoutHTML, SelectContentStaticProps as ComboboxContentStaticProps, SelectContentStaticPropsWithoutHTML as ComboboxContentStaticPropsWithoutHTML, SelectItemProps as ComboboxItemProps, SelectItemPropsWithoutHTML as ComboboxItemPropsWithoutHTML, SelectItemSnippetProps as ComboboxItemSnippetProps, SelectTriggerProps as ComboboxTriggerProps, SelectTriggerPropsWithoutHTML as ComboboxTriggerPropsWithoutHTML, SelectGroupPropsWithoutHTML as ComboboxGroupPropsWithoutHTML, SelectGroupProps as ComboboxGroupProps, SelectGroupHeadingPropsWithoutHTML as ComboboxGroupHeadingPropsWithoutHTML, SelectGroupHeadingProps as ComboboxGroupHeadingProps, SelectViewportPropsWithoutHTML as ComboboxViewportPropsWithoutHTML, SelectViewportProps as ComboboxViewportProps, SelectScrollDownButtonProps as ComboboxScrollDownButtonProps, SelectScrollDownButtonPropsWithoutHTML as ComboboxScrollDownButtonPropsWithoutHTML, SelectScrollUpButtonProps as ComboboxScrollUpButtonProps, SelectScrollUpButtonPropsWithoutHTML as ComboboxScrollUpButtonPropsWithoutHTML, SelectPortalProps as ComboboxPortalProps, SelectPortalPropsWithoutHTML as ComboboxPortalPropsWithoutHTML, } from './select/types.js';
+export type ComboboxArrowPropsWithoutHTML = LucideProps;
+export type ComboboxArrowProps = ComboboxArrowPropsWithoutHTML;
+export type ComboboxInputPropsWithoutHTML = WithChild<{
+    /**
+     * The default value of the input. This is not a reactive prop and is only used to populate
+     * the input when the combobox is first mounted if there is already a value set.
+     */
+    defaultValue?: string;
+    /**
+     * Whether to clear the input when the last item is deselected.
+     *
+     * @default false
+     */
+    clearOnDeselect?: boolean;
+}>;
+export type ComboboxInputProps = ComboboxInputPropsWithoutHTML & Without<Omit<BitsPrimitiveInputAttributes, 'value'>, ComboboxInputPropsWithoutHTML>;

package/dist/components/combobox/types.js

@@ -0,0 +1 @@
+export {};

package/dist/components/command/command-dialog.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { DialogRootProps, DialogPortalProps } from "../dialog/types.js";
+import type { CommandRootProps } from "./types.js";
+import type { Snippet } from "svelte";
+import type { WithoutChildrenOrChild } from "../../internal/utils.js";
+type $$ComponentProps = WithoutChildrenOrChild<DialogRootProps> & WithoutChildrenOrChild<CommandRootProps> & {
+    portalProps?: DialogPortalProps;
+    children: Snippet;
+    title?: string;
+    description?: string;
+};
+declare const CommandDialog: import("svelte").Component<$$ComponentProps, {}, "ref" | "value">;
+type CommandDialog = ReturnType<typeof CommandDialog>;
+export default CommandDialog;

package/dist/components/command/command.svelte.d.ts

@@ -0,0 +1,360 @@
+import { type WritableBoxedValues, type ReadableBoxedValues } from '../../internal/tools/index.js';
+import type { CommandState } from './types.js';
+import type { BitsKeyboardEvent, BitsMouseEvent, BitsPointerEvent, RefAttachment, WithRefOpts } from '../../internal/types.js';
+interface GridItem {
+    index: number;
+    firstRowOfGroup: boolean;
+    ref: HTMLElement;
+}
+type ItemsGrid = GridItem[][];
+interface CommandRootStateOpts extends WithRefOpts, ReadableBoxedValues<{
+    filter: (value: string, search: string, keywords?: string[]) => number;
+    shouldFilter: boolean;
+    loop: boolean;
+    vimBindings: boolean;
+    columns: number | null;
+    disablePointerSelection: boolean;
+    disableInitialScroll: boolean;
+    onStateChange?: (state: Readonly<CommandState>) => void;
+}>, WritableBoxedValues<{
+    value: string;
+}> {
+}
+export declare class CommandRootState {
+    #private;
+    static create(opts: CommandRootStateOpts): CommandRootState;
+    readonly opts: CommandRootStateOpts;
+    readonly attachment: RefAttachment;
+    sortAfterTick: boolean;
+    sortAndFilterAfterTick: boolean;
+    allItems: Set<string>;
+    allGroups: Map<string, Set<string>>;
+    allIds: Map<string, {
+        value: string;
+        keywords?: string[];
+    }>;
+    key: number;
+    viewportNode: HTMLElement | null;
+    inputNode: HTMLElement | null;
+    labelNode: HTMLElement | null;
+    commandState: CommandState;
+    _commandState: CommandState;
+    setState<K extends keyof CommandState>(key: K, value: CommandState[K], preventScroll?: boolean): void;
+    constructor(opts: CommandRootStateOpts);
+    /**
+     * Sets current value and triggers re-render if cleared.
+     *
+     * @param value - New value to set
+     */
+    setValue(value: string, opts?: boolean): void;
+    /**
+     * Gets all non-disabled, visible command items.
+     *
+     * @returns Array of valid item elements
+     * @remarks Exposed for direct item access and bound checking
+     */
+    getValidItems(): HTMLElement[];
+    /**
+     * Gets all visible command items.
+     *
+     * @returns Array of valid item elements
+     * @remarks Exposed for direct item access and bound checking
+     */
+    getVisibleItems(): HTMLElement[];
+    /** Returns all visible items in a matrix structure
+     *
+     * @remarks Returns empty if the command isn't configured as a grid
+     *
+     * @returns
+     */
+    get itemsGrid(): ItemsGrid;
+    /**
+     * Sets selection to item at specified index in valid items array.
+     * If index is out of bounds, does nothing.
+     *
+     * @param index - Zero-based index of item to select
+     * @remarks
+     * Uses `getValidItems()` to get selectable items, filtering out disabled/hidden ones.
+     * Access valid items directly via `getValidItems()` to check bounds before calling.
+     *
+     * @example
+     * // get valid items length for bounds check
+     * const items = getValidItems()
+     * if (index < items.length) {
+     *   updateSelectedToIndex(index)
+     * }
+     */
+    updateSelectedToIndex(index: number): void;
+    /**
+     * Updates selected item by moving up/down relative to current selection.
+     * Handles wrapping when loop option is enabled.
+     *
+     * @param change - Direction to move: 1 for next item, -1 for previous item
+     * @remarks
+     * The loop behavior wraps:
+     * - From last item to first when moving next
+     * - From first item to last when moving previous
+     *
+     * Uses `getValidItems()` to get all selectable items, which filters out disabled/hidden items.
+     * You can call `getValidItems()` directly to get the current valid items array.
+     *
+     * @example
+     * // select next item
+     * updateSelectedByItem(1)
+     *
+     * // get all valid items
+     * const items = getValidItems()
+     */
+    updateSelectedByItem(change: number): void;
+    /**
+     * Moves selection to the first valid item in the next/previous group.
+     * If no group is found, falls back to selecting the next/previous item globally.
+     *
+     * @param change - Direction to move: 1 for next group, -1 for previous group
+     * @example
+     * // move to first item in next group
+     * updateSelectedByGroup(1)
+     *
+     * // move to first item in previous group
+     * updateSelectedByGroup(-1)
+     */
+    updateSelectedByGroup(change: 1 | -1): void;
+    /**
+     * Maps item id to display value and search keywords.
+     * Returns cleanup function to remove mapping.
+     *
+     * @param id - Unique item identifier
+     * @param value - Display text
+     * @param keywords - Optional search boost terms
+     * @returns Cleanup function
+     */
+    registerValue(value: string, keywords?: string[]): () => void;
+    /**
+     * Registers item in command list and its group.
+     * Handles filtering, sorting and selection updates.
+     *
+     * @param id - Item identifier
+     * @param groupId - Optional group to add item to
+     * @returns Cleanup function that handles selection
+     */
+    registerItem(id: string, groupId: string | undefined): () => void;
+    /**
+     * Creates empty group if not exists.
+     *
+     * @param id - Group identifier
+     * @returns Cleanup function
+     */
+    registerGroup(id: string): () => void;
+    get isGrid(): boolean;
+    onkeydown(e: BitsKeyboardEvent): void;
+    props: {
+        readonly id: string;
+        readonly role: "application";
+        readonly tabindex: -1;
+        readonly onkeydown: (e: BitsKeyboardEvent) => void;
+    };
+}
+interface CommandEmptyStateOpts extends WithRefOpts, ReadableBoxedValues<{
+    forceMount: boolean;
+}> {
+}
+export declare class CommandEmptyState {
+    #private;
+    static create(opts: CommandEmptyStateOpts): CommandEmptyState;
+    readonly opts: CommandEmptyStateOpts;
+    readonly root: CommandRootState;
+    readonly attachment: RefAttachment;
+    readonly shouldRender: boolean;
+    constructor(opts: CommandEmptyStateOpts, root: CommandRootState);
+    readonly props: {
+        readonly id: string;
+        readonly role: "presentation";
+    };
+}
+interface CommandGroupContainerStateOpts extends WithRefOpts, ReadableBoxedValues<{
+    value: string;
+    forceMount: boolean;
+}> {
+}
+export declare class CommandGroupContainerState {
+    static create(opts: CommandGroupContainerStateOpts): CommandGroupContainerState;
+    readonly opts: CommandGroupContainerStateOpts;
+    readonly root: CommandRootState;
+    readonly attachment: RefAttachment;
+    readonly shouldRender: boolean;
+    headingNode: HTMLElement | null;
+    trueValue: string;
+    constructor(opts: CommandGroupContainerStateOpts, root: CommandRootState);
+    readonly props: {
+        readonly id: string;
+        readonly role: "presentation";
+        readonly hidden: true | undefined;
+        readonly 'data-value': string;
+    };
+}
+interface CommandGroupHeadingStateOpts extends WithRefOpts {
+}
+export declare class CommandGroupHeadingState {
+    static create(opts: CommandGroupHeadingStateOpts): CommandGroupHeadingState;
+    readonly opts: CommandGroupHeadingStateOpts;
+    readonly group: CommandGroupContainerState;
+    readonly attachment: RefAttachment;
+    constructor(opts: CommandGroupHeadingStateOpts, group: CommandGroupContainerState);
+    readonly props: {
+        readonly id: string;
+    };
+}
+interface CommandGroupItemsStateOpts extends WithRefOpts {
+}
+export declare class CommandGroupItemsState {
+    static create(opts: CommandGroupItemsStateOpts): CommandGroupItemsState;
+    readonly opts: CommandGroupItemsStateOpts;
+    readonly group: CommandGroupContainerState;
+    readonly attachment: RefAttachment;
+    constructor(opts: CommandGroupItemsStateOpts, group: CommandGroupContainerState);
+    readonly props: {
+        readonly id: string;
+        readonly role: "group";
+        readonly 'aria-labelledby': string | undefined;
+    };
+}
+interface CommandInputStateOpts extends WithRefOpts, WritableBoxedValues<{
+    value: string;
+}>, ReadableBoxedValues<{
+    autofocus: boolean;
+}> {
+}
+export declare class CommandInputState {
+    #private;
+    static create(opts: CommandInputStateOpts): CommandInputState;
+    readonly opts: CommandInputStateOpts;
+    readonly root: CommandRootState;
+    readonly attachment: RefAttachment;
+    constructor(opts: CommandInputStateOpts, root: CommandRootState);
+    readonly props: {
+        readonly id: string;
+        readonly type: "text";
+        readonly autocomplete: "off";
+        readonly autocorrect: "off";
+        readonly spellcheck: false;
+        readonly 'aria-autocomplete': "list";
+        readonly role: "combobox";
+        readonly 'aria-expanded': "true" | "false";
+        readonly 'aria-controls': string | undefined;
+        readonly 'aria-labelledby': string | undefined;
+        readonly 'aria-activedescendant': string | undefined;
+    };
+}
+interface CommandItemStateOpts extends WithRefOpts, ReadableBoxedValues<{
+    value: string;
+    disabled: boolean;
+    onSelect: () => void;
+    forceMount: boolean;
+    keywords: string[];
+}> {
+    group: CommandGroupContainerState | null;
+}
+export declare class CommandItemState {
+    #private;
+    static create(opts: Omit<CommandItemStateOpts, 'group'>): CommandItemState;
+    readonly opts: CommandItemStateOpts;
+    readonly root: CommandRootState;
+    readonly attachment: RefAttachment;
+    readonly shouldRender: boolean;
+    readonly isSelected: boolean;
+    trueValue: string;
+    constructor(opts: CommandItemStateOpts, root: CommandRootState);
+    onpointermove(_: BitsPointerEvent): void;
+    onclick(_: BitsMouseEvent): void;
+    readonly props: {
+        readonly id: string;
+        readonly 'aria-disabled': "true" | "false";
+        readonly 'aria-selected': "true" | "false";
+        readonly 'data-disabled': "" | undefined;
+        readonly 'data-selected': "" | undefined;
+        readonly 'data-value': string;
+        readonly 'data-group': string | undefined;
+        readonly role: "option";
+        readonly onpointermove: (_: BitsPointerEvent) => void;
+        readonly onclick: (_: BitsMouseEvent) => void;
+    };
+}
+interface CommandLoadingStateOpts extends WithRefOpts, ReadableBoxedValues<{
+    progress: number;
+}> {
+}
+export declare class CommandLoadingState {
+    static create(opts: CommandLoadingStateOpts): CommandLoadingState;
+    readonly opts: CommandLoadingStateOpts;
+    readonly attachment: RefAttachment;
+    constructor(opts: CommandLoadingStateOpts);
+    readonly props: {
+        readonly id: string;
+        readonly role: "progressbar";
+        readonly 'aria-valuenow': number;
+        readonly 'aria-valuemin': 0;
+        readonly 'aria-valuemax': 100;
+        readonly 'aria-label': "Loading...";
+    };
+}
+interface CommandSeparatorStateOpts extends WithRefOpts, ReadableBoxedValues<{
+    forceMount: boolean;
+}> {
+}
+export declare class CommandSeparatorState {
+    static create(opts: CommandSeparatorStateOpts): CommandSeparatorState;
+    readonly opts: CommandSeparatorStateOpts;
+    readonly root: CommandRootState;
+    readonly attachment: RefAttachment;
+    readonly shouldRender: boolean;
+    constructor(opts: CommandSeparatorStateOpts, root: CommandRootState);
+    readonly props: {
+        readonly id: string;
+        readonly 'aria-hidden': "true";
+    };
+}
+interface CommandListStateOpts extends WithRefOpts, ReadableBoxedValues<{
+    ariaLabel: string;
+}> {
+}
+export declare class CommandListState {
+    static create(opts: CommandListStateOpts): CommandListState;
+    readonly opts: CommandListStateOpts;
+    readonly root: CommandRootState;
+    readonly attachment: RefAttachment;
+    constructor(opts: CommandListStateOpts, root: CommandRootState);
+    readonly props: {
+        readonly id: string;
+        readonly role: "listbox";
+        readonly 'aria-label': string;
+    };
+}
+interface CommandLabelStateOpts extends WithRefOpts, ReadableBoxedValues<{
+    for?: string;
+}> {
+}
+export declare class CommandLabelState {
+    static create(opts: CommandLabelStateOpts): CommandLabelState;
+    readonly opts: CommandLabelStateOpts;
+    readonly root: CommandRootState;
+    readonly attachment: RefAttachment;
+    constructor(opts: CommandLabelStateOpts, root: CommandRootState);
+    readonly props: {
+        readonly id: string;
+        readonly for: string | undefined;
+        readonly style: import("../../internal/index.js").StyleProperties;
+    };
+}
+interface CommandViewportStateOpts extends WithRefOpts {
+}
+export declare class CommandViewportState {
+    static create(opts: CommandViewportStateOpts): CommandViewportState;
+    readonly opts: CommandViewportStateOpts;
+    readonly list: CommandListState;
+    readonly attachment: RefAttachment;
+    constructor(opts: CommandViewportStateOpts, list: CommandListState);
+    readonly props: {
+        readonly id: string;
+    };
+}
+export {};