@lukasmurdock/remix-ui-components 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1490 @@
+import * as remix_component from 'remix/component';
+import { RemixNode, Handle } from 'remix/component';
+
+type ComponentChildren = RemixNode;
+
+type ButtonVariant = "solid" | "outline" | "ghost";
+type ButtonSize = "sm" | "md" | "lg";
+type ButtonProps = {
+    type?: "button" | "submit" | "reset";
+    disabled?: boolean;
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    name?: string;
+    value?: string;
+    children: ComponentChildren;
+};
+declare function Button(_handle: Handle): (props: ButtonProps) => remix_component.RemixElement;
+
+type AvatarSize = "sm" | "md" | "lg";
+type AvatarStatus = "online" | "offline" | "busy";
+type AvatarProps = {
+    name: string;
+    src?: string;
+    alt?: string;
+    size?: AvatarSize;
+    square?: boolean;
+    status?: AvatarStatus;
+};
+declare function resolveAvatarSize(size?: AvatarSize): AvatarSize;
+declare function resolveAvatarSquare(square?: boolean): boolean;
+declare function getAvatarInitials(name: string): string;
+declare function Avatar(_handle: Handle): (props: AvatarProps) => remix_component.RemixElement;
+
+type AppHeaderDensity = "comfortable" | "compact";
+type AppHeaderProps = {
+    brand?: ComponentChildren;
+    title?: ComponentChildren;
+    subtitle?: ComponentChildren;
+    nav?: ComponentChildren;
+    actions?: ComponentChildren;
+    account?: ComponentChildren;
+    sticky?: boolean;
+    density?: AppHeaderDensity;
+};
+declare function resolveAppHeaderDensity(density?: AppHeaderDensity): AppHeaderDensity;
+declare function resolveAppHeaderSticky(sticky?: boolean): boolean;
+declare function AppHeader(_handle: Handle): (props: AppHeaderProps) => remix_component.RemixElement;
+
+type AppProviderDirection = "ltr" | "rtl";
+type AppProviderColorScheme = "light" | "dark" | "auto";
+type AppProviderReducedMotion = "no-preference" | "reduce";
+type AppProviderNavigatePayload = {
+    href: string;
+    external: boolean;
+};
+type AppProviderProps = {
+    children: ComponentChildren;
+    locale?: string;
+    direction?: AppProviderDirection;
+    colorScheme?: AppProviderColorScheme;
+    reducedMotion?: AppProviderReducedMotion;
+    onNavigate?: (payload: AppProviderNavigatePayload) => void;
+};
+declare function resolveAppProviderLocale(locale?: string): string;
+declare function resolveAppProviderDirection(direction?: AppProviderDirection): AppProviderDirection;
+declare function resolveAppProviderColorScheme(colorScheme?: AppProviderColorScheme): AppProviderColorScheme;
+declare function resolveAppProviderReducedMotion(reducedMotion?: AppProviderReducedMotion): AppProviderReducedMotion;
+declare function isExternalAppProviderHref(href: string): boolean;
+declare function shouldHandleAppProviderNavigation(event: MouseEvent, anchor: HTMLAnchorElement): boolean;
+declare function AppProvider(_handle: Handle): (props: AppProviderProps) => remix_component.RemixElement;
+
+type AppShellSidebarPosition = "left" | "right";
+type AppShellProps = {
+    header?: ComponentChildren;
+    sidebar?: ComponentChildren;
+    children: ComponentChildren;
+    sidebarCollapsed?: boolean;
+    sidebarPosition?: AppShellSidebarPosition;
+    sidebarWidth?: string;
+};
+declare function resolveAppShellSidebarState(collapsed?: boolean): "collapsed" | "expanded";
+declare function resolveAppShellSidebarPosition(position?: AppShellSidebarPosition): AppShellSidebarPosition;
+declare function resolveAppShellSidebarWidth(width?: string): string;
+declare function AppShell(_handle: Handle): (props: AppShellProps) => remix_component.RemixElement;
+
+type BadgeTone = "neutral" | "success" | "warning" | "danger" | "info";
+type BadgeProps = {
+    tone?: BadgeTone;
+    children: ComponentChildren;
+};
+declare function resolveBadgeTone(tone?: BadgeTone): BadgeTone;
+declare function Badge(_handle: Handle): (props: BadgeProps) => remix_component.RemixElement;
+
+type BreadcrumbItem = {
+    id: string;
+    label: ComponentChildren;
+    href?: string;
+    current?: boolean;
+    disabled?: boolean;
+};
+type BreadcrumbsProps = {
+    items: BreadcrumbItem[];
+    ariaLabel?: string;
+    separator?: ComponentChildren;
+};
+declare function resolveBreadcrumbCurrentIndex(items: BreadcrumbItem[]): number;
+declare function resolveBreadcrumbSeparator(separator?: ComponentChildren): ComponentChildren;
+declare function Breadcrumbs(_handle: Handle): (props: BreadcrumbsProps) => remix_component.RemixElement;
+
+type BreadcrumbOverflowEntry = {
+    kind: "item";
+    item: BreadcrumbItem;
+    current: boolean;
+} | {
+    kind: "ellipsis";
+    hiddenCount: number;
+};
+type BreadcrumbOverflowProps = {
+    items: BreadcrumbItem[];
+    maxVisible?: number;
+    ariaLabel?: string;
+    separator?: ComponentChildren;
+    ellipsisLabel?: string;
+};
+declare function normalizeBreadcrumbOverflowMaxVisible(maxVisible?: number): number;
+declare function buildBreadcrumbOverflowEntries(items: BreadcrumbItem[], maxVisible?: number): BreadcrumbOverflowEntry[];
+declare function BreadcrumbOverflow(_handle: Handle): (props: BreadcrumbOverflowProps) => remix_component.RemixElement;
+
+type CheckboxProps = {
+    id?: string;
+    name?: string;
+    value?: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    children?: ComponentChildren;
+};
+declare function Checkbox(_handle: Handle): (props: CheckboxProps) => remix_component.RemixElement;
+
+type AlertTone = "info" | "success" | "warning" | "danger";
+type AlertProps = {
+    tone?: AlertTone;
+    title?: ComponentChildren;
+    children: ComponentChildren;
+    dismissible?: boolean;
+    onDismiss?: () => void;
+};
+declare function Alert(_handle: Handle): (props: AlertProps) => remix_component.RemixElement;
+
+type AnchorItem = {
+    id: string;
+    label: ComponentChildren;
+    href: string;
+    disabled?: boolean;
+};
+type AnchorProps = {
+    items: AnchorItem[];
+    ariaLabel?: string;
+    activeHref?: string;
+    defaultActiveHref?: string;
+    onActiveHrefChange?: (href: string) => void;
+};
+declare function resolveAnchorActiveHref(items: AnchorItem[], preferred?: string): string | undefined;
+declare function isAnchorItemActive(itemHref: string, activeHref?: string): boolean;
+declare function resolveAnchorInitialHref(items: AnchorItem[], defaultActiveHref?: string, locationHash?: string): string | undefined;
+declare function resolveAnchorHashTarget(items: AnchorItem[], currentHref: string | undefined, locationHash?: string): string | undefined;
+declare function syncAnchorActiveHrefFromHash(items: AnchorItem[], currentHref: string | undefined, locationHash: string | undefined, onNext: (href: string) => void): string | undefined;
+declare function Anchor(handle: Handle): (props: AnchorProps) => remix_component.RemixElement;
+
+type ComboboxOption = {
+    id: string;
+    label: ComponentChildren;
+    value: string;
+    textValue?: string;
+    disabled?: boolean;
+};
+type ComboboxProps = {
+    id?: string;
+    label: ComponentChildren;
+    options: ComboboxOption[];
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+};
+declare function filterComboboxOptions(options: ComboboxOption[], query: string): ComboboxOption[];
+declare function findNextEnabledIndex(options: ComboboxOption[], current: number, step: 1 | -1): number;
+declare function findFirstEnabledIndex(options: ComboboxOption[]): number;
+declare function Combobox(handle: Handle): (props: ComboboxProps) => remix_component.RemixElement;
+
+type AutocompleteOption = ComboboxOption;
+type AutocompleteCommit = {
+    value: string;
+    option?: AutocompleteOption;
+};
+type AutocompleteProps = {
+    id?: string;
+    name?: string;
+    label: ComponentChildren;
+    options: AutocompleteOption[];
+    value?: string;
+    defaultValue?: string;
+    disabled?: boolean;
+    required?: boolean;
+    onValueChange?: (value: string) => void;
+    onCommit?: (commit: AutocompleteCommit) => void;
+};
+declare function resolveAutocompleteCommit(options: AutocompleteOption[], highlighted: number, fallbackValue: string): AutocompleteCommit;
+declare function Autocomplete(handle: Handle): (props: AutocompleteProps) => remix_component.RemixElement;
+
+type CascaderOption = {
+    value: string;
+    label: ComponentChildren;
+    children?: CascaderOption[];
+    disabled?: boolean;
+};
+type CascaderProps = {
+    options: CascaderOption[];
+    value?: string[];
+    defaultValue?: string[];
+    open?: boolean;
+    defaultOpen?: boolean;
+    placeholder?: ComponentChildren;
+    emptyState?: ComponentChildren;
+    changeOnSelect?: boolean;
+    ariaLabel?: string;
+    onChange?: (value: string[]) => void;
+    onOpenChange?: (open: boolean) => void;
+};
+declare function isCascaderLeaf(option: CascaderOption): boolean;
+declare function resolveCascaderPath(options: CascaderOption[], value?: string[]): string[];
+declare function resolveCascaderColumns(options: CascaderOption[], path: string[]): CascaderOption[][];
+declare function resolveCascaderPathLabels(options: CascaderOption[], path: string[]): string[];
+declare function resolveCascaderTriggerLabel(options: CascaderOption[], path: string[], placeholder: ComponentChildren): ComponentChildren;
+declare function shouldCascaderCommitSelection(option: CascaderOption, changeOnSelect?: boolean): {
+    commit: boolean;
+    close: boolean;
+};
+declare function findCascaderOptionIndex(column: CascaderOption[], value?: string): number;
+declare function findNextEnabledCascaderOption(column: CascaderOption[], start: number, step: 1 | -1): number;
+declare function Cascader(handle: Handle): (props: CascaderProps) => remix_component.RemixElement;
+
+type CardProps = {
+    title?: ComponentChildren;
+    subtitle?: ComponentChildren;
+    children: ComponentChildren;
+    footer?: ComponentChildren;
+};
+declare function Card(_handle: Handle): (props: CardProps) => remix_component.RemixElement;
+
+type CalendarView = "month" | "year";
+type CalendarProps = {
+    id?: string;
+    name?: string;
+    value?: string;
+    defaultValue?: string;
+    min?: string;
+    max?: string;
+    disabled?: boolean;
+    required?: boolean;
+    view?: CalendarView;
+    onValueChange?: (value: string | undefined) => void;
+    "aria-describedby"?: string;
+    "aria-invalid"?: "true";
+};
+declare function resolveCalendarView(view?: CalendarView): CalendarView;
+declare function resolveCalendarDisabled(disabled?: boolean): boolean;
+declare function resolveCalendarType(view?: CalendarView): "date" | "month";
+declare function Calendar(_handle: Handle): (props: CalendarProps) => remix_component.RemixElement;
+
+type CollapseProps = {
+    title: ComponentChildren;
+    children: ComponentChildren;
+    open?: boolean;
+};
+declare function resolveCollapseOpen(open?: boolean): boolean;
+declare function Collapse(_handle: Handle): (props: CollapseProps) => remix_component.RemixElement;
+
+type CommandItem = {
+    id: string;
+    label: ComponentChildren;
+    keywords?: string[];
+    disabled?: boolean;
+};
+type CommandPaletteProps = {
+    open: boolean;
+    title?: ComponentChildren;
+    commands: CommandItem[];
+    onClose: () => void;
+    onSelect?: (id: string) => void;
+};
+declare function filterCommands(commands: CommandItem[], query: string): CommandItem[];
+declare function findNextEnabledCommandIndex(commands: CommandItem[], current: number, step: 1 | -1): number;
+declare function buildCommandOptionId(handleId: string, commandId: string): string;
+declare function CommandPalette(handle: Handle): (props: CommandPaletteProps) => remix_component.RemixElement | null;
+
+type DialogCloseReason = "escape" | "backdrop" | "close-button" | "programmatic";
+type DialogProps = {
+    open: boolean;
+    children: ComponentChildren;
+    onClose: (reason: DialogCloseReason) => void;
+    title?: ComponentChildren;
+    closeLabel?: string;
+    showCloseButton?: boolean;
+    dismissOnBackdrop?: boolean;
+    dismissOnEscape?: boolean;
+    restoreFocus?: boolean;
+    container?: HTMLElement;
+    ariaLabel?: string;
+    ariaLabelledBy?: string;
+};
+declare function Dialog(handle: Handle): (props: DialogProps) => remix_component.RemixElement | null;
+
+type ConfirmDialogCloseReason = DialogCloseReason | "cancel" | "confirm";
+type ConfirmDialogProps = {
+    open: boolean;
+    title: ComponentChildren;
+    description?: ComponentChildren;
+    children?: ComponentChildren;
+    onClose: (reason: ConfirmDialogCloseReason) => void;
+    onConfirm?: () => void;
+    onCancel?: () => void;
+    confirmLabel?: ComponentChildren;
+    cancelLabel?: ComponentChildren;
+    confirmDisabled?: boolean;
+    dismissOnBackdrop?: boolean;
+    dismissOnEscape?: boolean;
+    restoreFocus?: boolean;
+    container?: HTMLElement;
+    ariaLabel?: string;
+    ariaLabelledBy?: string;
+};
+type ConfirmDialogDefaults = {
+    dismissOnBackdrop: boolean;
+    confirmLabel: ComponentChildren;
+    cancelLabel: ComponentChildren;
+};
+declare function resolveConfirmDialogDefaults(props: ConfirmDialogProps): ConfirmDialogDefaults;
+declare function ConfirmDialog(_handle: Handle): (props: ConfirmDialogProps) => remix_component.RemixElement;
+
+type LinkNavigatePayload = {
+    href: string;
+    external: boolean;
+};
+type LinkNavigateMode = "internal" | "all";
+type LinkProps = {
+    href: string;
+    children: ComponentChildren;
+    target?: string;
+    rel?: string;
+    download?: boolean;
+    "aria-current"?: "page" | "step" | "location" | "date" | "time" | "true" | "false";
+    onNavigate?: (payload: LinkNavigatePayload) => void;
+    navigateMode?: LinkNavigateMode;
+};
+declare function isExternalLinkHref(href: string): boolean;
+declare function resolveLinkRel(params: {
+    target?: string;
+    rel?: string;
+    href: string;
+}): string | undefined;
+declare function shouldHandleLinkNavigation(event: MouseEvent, anchor: HTMLAnchorElement, navigateMode: LinkNavigateMode): boolean;
+declare function resolveLinkNavigateMode(mode?: LinkNavigateMode): LinkNavigateMode;
+declare function Link(_handle: Handle): (props: LinkProps) => remix_component.RemixElement;
+
+type ConfigProviderDirection = "ltr" | "rtl";
+type ConfigProviderColorScheme = "light" | "dark" | "auto";
+type ConfigProviderReducedMotion = "no-preference" | "reduce";
+type ConfigProviderNavigatePayload = {
+    href: string;
+    external: boolean;
+};
+type ConfigProviderRouter = {
+    navigate: (href: string) => void;
+};
+type ConfigProviderProps = {
+    children: ComponentChildren;
+    locale?: string;
+    direction?: ConfigProviderDirection;
+    colorScheme?: ConfigProviderColorScheme;
+    reducedMotion?: ConfigProviderReducedMotion;
+    navigateMode?: LinkNavigateMode;
+    router?: ConfigProviderRouter;
+    onNavigate?: (payload: ConfigProviderNavigatePayload) => void;
+};
+declare function resolveConfigProviderLocale(locale?: string): string;
+declare function resolveConfigProviderDirection(direction?: ConfigProviderDirection): ConfigProviderDirection;
+declare function resolveConfigProviderColorScheme(colorScheme?: ConfigProviderColorScheme): ConfigProviderColorScheme;
+declare function resolveConfigProviderReducedMotion(reducedMotion?: ConfigProviderReducedMotion): ConfigProviderReducedMotion;
+declare function ConfigProvider(_handle: Handle): (props: ConfigProviderProps) => remix_component.RemixElement;
+
+type DataListItem = {
+    id: string;
+    title: ComponentChildren;
+    description?: ComponentChildren;
+    meta?: ComponentChildren;
+    actions?: ComponentChildren;
+};
+type DataListProps = {
+    items: DataListItem[];
+    emptyState?: ComponentChildren;
+};
+declare function DataList(_handle: Handle): (props: DataListProps) => remix_component.RemixElement;
+
+type DataGridDirection = "asc" | "desc";
+type DataGridSort = {
+    columnKey: string;
+    direction: DataGridDirection;
+};
+type DataGridColumn = {
+    key: string;
+    header: ComponentChildren;
+    align?: "left" | "center" | "right";
+    sortable?: boolean;
+};
+type DataGridRow = {
+    key: string;
+    cells: Record<string, ComponentChildren>;
+    sortValues?: Record<string, string | number>;
+};
+type DataGridLiteProps = {
+    columns: DataGridColumn[];
+    rows: DataGridRow[];
+    caption?: ComponentChildren;
+    loading?: boolean;
+    emptyState?: ComponentChildren;
+    selectable?: boolean;
+    selectedKeys?: string[];
+    defaultSelectedKeys?: string[];
+    onSelectionChange?: (keys: string[]) => void;
+    sort?: DataGridSort;
+    defaultSort?: DataGridSort;
+    onSortChange?: (sort: DataGridSort | undefined) => void;
+};
+declare function nextSort(current: DataGridSort | undefined, columnKey: string): DataGridSort | undefined;
+declare function sortRows(rows: DataGridRow[], sort: DataGridSort | undefined): DataGridRow[];
+declare function DataGridLite(handle: Handle): (props: DataGridLiteProps) => remix_component.RemixElement;
+
+type DataTableColumn = {
+    key: string;
+    header: ComponentChildren;
+    align?: "left" | "center" | "right";
+    sortable?: boolean;
+};
+type DataTableRow = {
+    key: string;
+    cells: Record<string, ComponentChildren>;
+    sortValues?: Record<string, string | number>;
+};
+type DataTableProps = {
+    columns: DataTableColumn[];
+    rows: DataTableRow[];
+    rowFilter?: DataTableRowFilter;
+    caption?: ComponentChildren;
+    loading?: boolean;
+    errorState?: ComponentChildren;
+    emptyState?: ComponentChildren;
+    selectable?: boolean;
+    selectedKeys?: string[];
+    defaultSelectedKeys?: string[];
+    onSelectionChange?: (keys: string[]) => void;
+    sort?: DataGridSort;
+    defaultSort?: DataGridSort;
+    onSortChange?: (sort: DataGridSort | undefined) => void;
+    page?: number;
+    defaultPage?: number;
+    onPageChange?: (page: number) => void;
+    pageSize?: number;
+};
+type DataTableRowFilter = (row: DataTableRow) => boolean;
+declare function resolveDataTablePageSize(pageSize?: number): number;
+declare function resolveDataTableTotalPages(rowCount: number, pageSize: number): number;
+declare function clampDataTablePage(page: number | undefined, totalPages: number): number;
+declare function paginateDataTableRows(rows: DataTableRow[], page: number, pageSize: number): DataTableRow[];
+declare function filterDataTableRows(rows: DataTableRow[], rowFilter?: DataTableRowFilter): DataTableRow[];
+declare function composeDataTableRowFilter(...filters: Array<DataTableRowFilter | undefined>): DataTableRowFilter | undefined;
+declare function resolveDataTableCellText(row: DataTableRow, columnKey: string): string;
+declare function createDataTableContainsFilter(columnKeys: string[], query: string | undefined): DataTableRowFilter | undefined;
+declare function createDataTableEqualsFilter(columnKey: string, value: string | number | undefined, allValue?: string | number): DataTableRowFilter | undefined;
+declare function DataTable(handle: Handle): (props: DataTableProps) => remix_component.RemixElement;
+
+type DatePickerProps = {
+    id?: string;
+    name?: string;
+    value?: string;
+    defaultValue?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    required?: boolean;
+    min?: string;
+    max?: string;
+    onValueChange?: (value: string | undefined) => void;
+    "aria-describedby"?: string;
+    "aria-invalid"?: "true";
+};
+type CalendarCell = {
+    iso: string;
+    day: number;
+    inMonth: boolean;
+    disabled: boolean;
+};
+declare function parseISODate(value?: string): Date | undefined;
+declare function formatISODate(date: Date): string;
+declare function monthStart(date: Date): Date;
+declare function addDays(date: Date, days: number): Date;
+declare function addMonths(date: Date, months: number): Date;
+declare function buildCalendarCells(viewMonth: Date, min?: string, max?: string): CalendarCell[];
+declare function DatePicker(handle: Handle): (props: DatePickerProps) => remix_component.RemixElement;
+
+type DateTimePickerParts = {
+    date: string | undefined;
+    time: string | undefined;
+};
+type DateTimePickerProps = {
+    id?: string;
+    name?: string;
+    dateName?: string;
+    timeName?: string;
+    value?: string;
+    defaultValue?: string;
+    minDate?: string;
+    maxDate?: string;
+    minTime?: string;
+    maxTime?: string;
+    step?: number;
+    disabled?: boolean;
+    required?: boolean;
+    onValueChange?: (value: string | undefined) => void;
+    "aria-describedby"?: string;
+    "aria-invalid"?: "true";
+};
+declare function splitDateTimeLocal(value?: string): DateTimePickerParts;
+declare function joinDateTimeLocal(date?: string, time?: string): string | undefined;
+declare function normalizeDateTimeLocal(value?: string): string | undefined;
+declare function DateTimePicker(handle: Handle): (props: DateTimePickerProps) => remix_component.RemixElement;
+
+type DateRangeValue = {
+    start?: string;
+    end?: string;
+};
+type DateRangePickerProps = {
+    id?: string;
+    startName?: string;
+    endName?: string;
+    value?: DateRangeValue;
+    defaultValue?: DateRangeValue;
+    disabled?: boolean;
+    min?: string;
+    max?: string;
+    onValueChange?: (value: DateRangeValue) => void;
+};
+declare function nextDateRangeSelection(current: DateRangeValue, pickedISO: string): DateRangeValue;
+declare function isDateWithinRange(iso: string, range: DateRangeValue): boolean;
+declare function formatDateRangeValue(range: DateRangeValue): string;
+declare function DateRangePicker(handle: Handle): (props: DateRangePickerProps) => remix_component.RemixElement;
+
+type DescriptionsSize = "comfortable" | "compact";
+type DescriptionsLayout = "horizontal" | "vertical";
+type DescriptionsCollapseBelow = "sm" | "md" | "lg" | "none";
+type DescriptionsItem = {
+    key: string;
+    label: ComponentChildren;
+    content: ComponentChildren;
+    span?: number;
+};
+type DescriptionsProps = {
+    items: DescriptionsItem[];
+    title?: ComponentChildren;
+    extra?: ComponentChildren;
+    columns?: number;
+    size?: DescriptionsSize;
+    layout?: DescriptionsLayout;
+    collapseBelow?: DescriptionsCollapseBelow;
+    bordered?: boolean;
+    emptyState?: ComponentChildren;
+};
+declare function resolveDescriptionsColumns(columns?: number): number;
+declare function resolveDescriptionsSize(size?: DescriptionsSize): DescriptionsSize;
+declare function resolveDescriptionsLayout(layout?: DescriptionsLayout): DescriptionsLayout;
+declare function resolveDescriptionsCollapseBelow(collapseBelow?: DescriptionsCollapseBelow): DescriptionsCollapseBelow;
+declare function resolveDescriptionsItemSpan(span: number | undefined, columns: number): number;
+declare function resolveDescriptionsBordered(bordered?: boolean): boolean;
+declare function Descriptions(_handle: Handle): (props: DescriptionsProps) => remix_component.RemixElement;
+
+type DividerOrientation = "horizontal" | "vertical";
+type DividerProps = {
+    orientation?: DividerOrientation;
+    decorative?: boolean;
+    inset?: boolean;
+    ariaLabel?: string;
+};
+declare function resolveDividerOrientation(orientation?: DividerOrientation): DividerOrientation;
+declare function resolveDividerDecorative(decorative?: boolean): boolean;
+declare function resolveDividerInset(inset?: boolean): boolean;
+declare function Divider(_handle: Handle): (props: DividerProps) => remix_component.RemixElement;
+
+type MenuItem = {
+    id: string;
+    label: ComponentChildren;
+    disabled?: boolean;
+};
+type MenuProps = {
+    triggerLabel: ComponentChildren;
+    items: MenuItem[];
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onSelect?: (id: string) => void;
+};
+declare function resolveMenuOpen(props: MenuProps, uncontrolledOpen: boolean | undefined): boolean;
+declare function Menu(handle: Handle): (props: MenuProps) => remix_component.RemixElement;
+
+type DropdownProps = {
+    label: ComponentChildren;
+    items: MenuItem[];
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onSelect?: (id: string) => void;
+};
+declare function Dropdown(_handle: Handle): (props: DropdownProps) => remix_component.RemixElement;
+
+type DrawerPosition = "left" | "right";
+type DrawerCloseReason = "escape" | "backdrop" | "close-button" | "programmatic";
+type DrawerProps = {
+    open: boolean;
+    onClose: (reason: DrawerCloseReason) => void;
+    title?: ComponentChildren;
+    children: ComponentChildren;
+    position?: DrawerPosition;
+    closeLabel?: string;
+    showCloseButton?: boolean;
+    dismissOnBackdrop?: boolean;
+    dismissOnEscape?: boolean;
+    restoreFocus?: boolean;
+    container?: HTMLElement;
+    ariaLabel?: string;
+    ariaLabelledBy?: string;
+};
+declare function resolveDrawerPosition(position?: DrawerPosition): DrawerPosition;
+declare function resolveDrawerDismissOnBackdrop(value?: boolean): boolean;
+declare function Drawer(handle: Handle): (props: DrawerProps) => remix_component.RemixElement | null;
+
+type EmptySize = "comfortable" | "compact";
+type EmptyProps = {
+    title: ComponentChildren;
+    description?: ComponentChildren;
+    action?: ComponentChildren;
+    icon?: ComponentChildren;
+    size?: EmptySize;
+};
+declare function resolveEmptySize(size?: EmptySize): EmptySize;
+declare function Empty(_handle: Handle): (props: EmptyProps) => remix_component.RemixElement;
+
+type EmptyStateProps = {
+    title: ComponentChildren;
+    description?: ComponentChildren;
+    action?: ComponentChildren;
+};
+declare function EmptyState(_handle: Handle): (props: EmptyStateProps) => remix_component.RemixElement;
+
+type EmptyResultsProps = {
+    title?: ComponentChildren;
+    description?: ComponentChildren;
+    clearAction?: ComponentChildren;
+};
+declare function EmptyResults(_handle: Handle): (props: EmptyResultsProps) => remix_component.RemixElement;
+
+type FileUploadCapture = "user" | "environment";
+type FileUploadProps = {
+    id?: string;
+    name?: string;
+    disabled?: boolean;
+    required?: boolean;
+    multiple?: boolean;
+    accept?: string[] | string;
+    capture?: FileUploadCapture;
+    "aria-describedby"?: string;
+    "aria-invalid"?: "true";
+};
+declare function normalizeFileUploadAccept(accept?: string[] | string): string | undefined;
+declare function FileUpload(_handle: Handle): (props: FileUploadProps) => remix_component.RemixElement;
+
+type FieldProps = {
+    id: string;
+    label: ComponentChildren;
+    description?: ComponentChildren;
+    error?: ComponentChildren;
+    invalid?: boolean;
+    children: (ids: {
+        inputId: string;
+        descriptionId?: string;
+        errorId?: string;
+        aria: {
+            "aria-describedby"?: string;
+            "aria-invalid"?: "true";
+        };
+    }) => ComponentChildren;
+};
+declare function Field(_handle: Handle): (props: FieldProps) => remix_component.RemixElement;
+declare function Label(_handle: Handle): (props: {
+    htmlFor?: string;
+    children: ComponentChildren;
+}) => remix_component.RemixElement;
+declare function Description(_handle: Handle): (props: {
+    id: string;
+    children: ComponentChildren;
+}) => remix_component.RemixElement;
+declare function Error(_handle: Handle): (props: {
+    id: string;
+    children: ComponentChildren;
+}) => remix_component.RemixElement;
+
+type FormFieldsetColumns = 1 | 2;
+type FormFieldsetProps = {
+    legend: ComponentChildren;
+    description?: ComponentChildren;
+    children: ComponentChildren;
+    columns?: FormFieldsetColumns;
+};
+declare function normalizeFormFieldsetColumns(columns?: FormFieldsetColumns): FormFieldsetColumns;
+declare function FormFieldset(handle: Handle): (props: FormFieldsetProps) => remix_component.RemixElement;
+
+type FormLayoutColumns = 1 | 2 | 3;
+type FormLayoutProps = {
+    title?: ComponentChildren;
+    description?: ComponentChildren;
+    children: ComponentChildren;
+    actions?: ComponentChildren;
+    columns?: FormLayoutColumns;
+};
+declare function normalizeFormLayoutColumns(columns?: FormLayoutColumns): FormLayoutColumns;
+declare function FormLayout(handle: Handle): (props: FormLayoutProps) => remix_component.RemixElement;
+
+type FormMessageTone = "help" | "success" | "warning" | "error";
+type FormMessageProps = {
+    id?: string;
+    tone?: FormMessageTone;
+    children: ComponentChildren;
+};
+declare function resolveFormMessageA11y(tone: FormMessageTone): {
+    role?: "status" | "alert";
+    live?: "polite" | "assertive";
+};
+declare function FormMessage(_handle: Handle): (props: FormMessageProps) => remix_component.RemixElement;
+
+type FormMethod = "get" | "post";
+type FormProps = {
+    children: ComponentChildren;
+    action?: string;
+    method?: FormMethod;
+    encType?: "application/x-www-form-urlencoded" | "multipart/form-data" | "text/plain";
+    noValidate?: boolean;
+    busy?: boolean;
+    "aria-describedby"?: string;
+};
+type FormErrorSummaryProps = {
+    id: string;
+    title?: ComponentChildren;
+    errors: string[];
+};
+declare function resolveFormMethod(method?: FormMethod): FormMethod;
+declare function resolveFormBusy(busy?: boolean): boolean;
+declare function resolveFormNoValidate(noValidate?: boolean): boolean;
+declare function Form(_handle: Handle): (props: FormProps) => remix_component.RemixElement;
+declare function FormErrorSummary(_handle: Handle): (props: FormErrorSummaryProps) => remix_component.RemixElement | null;
+
+type FilterBarProps = {
+    title?: ComponentChildren;
+    children: ComponentChildren;
+    actions?: ComponentChildren;
+};
+declare function FilterBar(_handle: Handle): (props: FilterBarProps) => remix_component.RemixElement;
+
+type FilterPanelCloseReason = DrawerCloseReason | "apply" | "clear";
+type FilterPanelDrawerOptions = Omit<DrawerProps, "children" | "title" | "onClose">;
+type FilterPanelProps = FilterPanelDrawerOptions & {
+    open: boolean;
+    onClose: (reason: FilterPanelCloseReason) => void;
+    children: ComponentChildren;
+    title?: ComponentChildren;
+    description?: ComponentChildren;
+    actions?: ComponentChildren;
+    applyLabel?: ComponentChildren;
+    clearLabel?: ComponentChildren;
+    closeOnApply?: boolean;
+    closeOnClear?: boolean;
+    showApplyButton?: boolean;
+    showClearButton?: boolean;
+    onApply?: () => void;
+    onClear?: () => void;
+    fieldsLabel?: string;
+};
+declare function resolveFilterPanelTitle(title?: ComponentChildren): ComponentChildren;
+declare function resolveFilterPanelApplyLabel(label?: ComponentChildren): ComponentChildren;
+declare function resolveFilterPanelClearLabel(label?: ComponentChildren): ComponentChildren;
+declare function resolveFilterPanelCloseOnApply(value?: boolean): boolean;
+declare function resolveFilterPanelCloseOnClear(value?: boolean): boolean;
+declare function resolveFilterPanelShowApplyButton(value?: boolean): boolean;
+declare function resolveFilterPanelShowClearButton(value?: boolean): boolean;
+declare function FilterPanel(handle: Handle): (props: FilterPanelProps) => remix_component.RemixElement | null;
+
+type FlexDirection = "row" | "column";
+type FlexAlign = "start" | "center" | "end" | "stretch" | "baseline";
+type FlexJustify = "start" | "center" | "end" | "between" | "around" | "evenly";
+type FlexWrap = "nowrap" | "wrap";
+type FlexProps = {
+    children: ComponentChildren;
+    direction?: FlexDirection;
+    align?: FlexAlign;
+    justify?: FlexJustify;
+    wrap?: FlexWrap;
+    gap?: string;
+    inline?: boolean;
+};
+declare function resolveFlexDirection(direction?: FlexDirection): FlexDirection;
+declare function resolveFlexAlign(align?: FlexAlign): FlexAlign;
+declare function resolveFlexJustify(justify?: FlexJustify): FlexJustify;
+declare function resolveFlexWrap(wrap?: FlexWrap): FlexWrap;
+declare function resolveFlexGap(gap?: string): string;
+declare function resolveFlexInline(inline?: boolean): boolean;
+declare function Flex(_handle: Handle): (props: FlexProps) => remix_component.RemixElement;
+
+type InputType = "text" | "email" | "password" | "search" | "url" | "tel";
+type InputProps = {
+    id?: string;
+    type?: InputType;
+    name?: string;
+    value?: string;
+    defaultValue?: string;
+    disabled?: boolean;
+    required?: boolean;
+    placeholder?: string;
+    "aria-describedby"?: string;
+    "aria-invalid"?: "true";
+};
+declare function Input(_handle: Handle): (props: InputProps) => remix_component.RemixElement;
+
+type InlineAlertTone = "info" | "success" | "warning" | "danger";
+type InlineAlertProps = {
+    tone?: InlineAlertTone;
+    children: ComponentChildren;
+    action?: ComponentChildren;
+};
+declare function resolveInlineAlertTone(tone?: InlineAlertTone): InlineAlertTone;
+declare function resolveInlineAlertRole(tone: InlineAlertTone): "status" | "alert";
+declare function InlineAlert(_handle: Handle): (props: InlineAlertProps) => remix_component.RemixElement;
+
+type GridColumns = 1 | 2 | 3 | 4 | 6 | 12;
+type GridAlign = "start" | "center" | "end" | "stretch";
+type GridProps = {
+    children: ComponentChildren;
+    columns?: GridColumns;
+    gap?: string;
+    align?: GridAlign;
+};
+type GridItemProps = {
+    children: ComponentChildren;
+    span?: GridColumns;
+};
+declare function resolveGridColumns(columns?: GridColumns): GridColumns;
+declare function resolveGridGap(gap?: string): string;
+declare function resolveGridAlign(align?: GridAlign): GridAlign;
+declare function resolveGridItemSpan(span?: GridColumns): GridColumns;
+declare function Grid(_handle: Handle): (props: GridProps) => remix_component.RemixElement;
+declare function GridItem(_handle: Handle): (props: GridItemProps) => remix_component.RemixElement;
+
+type ImageFit = "cover" | "contain" | "fill";
+type ImageProps = {
+    src: string;
+    alt: string;
+    width?: number;
+    height?: number;
+    fit?: ImageFit;
+    loading?: "lazy" | "eager";
+    fallbackText?: string;
+};
+declare function resolveImageFit(fit?: ImageFit): ImageFit;
+declare function resolveImageLoading(loading?: "lazy" | "eager"): "lazy" | "eager";
+declare function resolveImageFallbackText(text?: string): string;
+declare function Image(_handle: Handle): (props: ImageProps) => remix_component.RemixElement;
+
+type LayoutDirection = "row" | "column";
+type LayoutProps = {
+    children: ComponentChildren;
+    direction?: LayoutDirection;
+    hasSider?: boolean;
+};
+type LayoutSectionProps = {
+    children: ComponentChildren;
+};
+type LayoutSiderProps = {
+    children: ComponentChildren;
+    width?: string;
+    collapsed?: boolean;
+};
+declare function resolveLayoutDirection(direction?: LayoutDirection): LayoutDirection;
+declare function resolveLayoutHasSider(hasSider?: boolean): boolean;
+declare function resolveLayoutSiderWidth(width?: string): string;
+declare function resolveLayoutSiderCollapsed(collapsed?: boolean): boolean;
+declare function Layout(_handle: Handle): (props: LayoutProps) => remix_component.RemixElement;
+declare function LayoutHeader(_handle: Handle): (props: LayoutSectionProps) => remix_component.RemixElement;
+declare function LayoutContent(_handle: Handle): (props: LayoutSectionProps) => remix_component.RemixElement;
+declare function LayoutFooter(_handle: Handle): (props: LayoutSectionProps) => remix_component.RemixElement;
+declare function LayoutSider(_handle: Handle): (props: LayoutSiderProps) => remix_component.RemixElement;
+
+type NumberInputProps = {
+    id?: string;
+    name?: string;
+    value?: number;
+    defaultValue?: number;
+    disabled?: boolean;
+    required?: boolean;
+    placeholder?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    "aria-describedby"?: string;
+    "aria-invalid"?: "true";
+};
+declare function normalizeNumberInputStep(step?: number): number | undefined;
+declare function NumberInput(_handle: Handle): (props: NumberInputProps) => remix_component.RemixElement;
+
+type PageHeaderProps = {
+    title: ComponentChildren;
+    subtitle?: ComponentChildren;
+    actions?: ComponentChildren;
+};
+declare function PageHeader(_handle: Handle): (props: PageHeaderProps) => remix_component.RemixElement;
+
+type PaginationItem = number | "ellipsis";
+type PaginationProps = {
+    page: number;
+    totalPages: number;
+    siblingCount?: number;
+    onPageChange?: (page: number) => void;
+};
+declare function clampPage(page: number, totalPages: number): number;
+declare function buildPaginationItems(totalPages: number, currentPage: number, siblingCount?: number): PaginationItem[];
+declare function Pagination(handle: Handle): (props: PaginationProps) => remix_component.RemixElement;
+
+type PopoverProps = {
+    trigger: ComponentChildren;
+    content: ComponentChildren;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+};
+declare function resolvePopoverOpen(props: PopoverProps, uncontrolledOpen: boolean | undefined): boolean;
+declare function Popover(handle: Handle): (props: PopoverProps) => remix_component.RemixElement;
+
+type RadioProps = {
+    id?: string;
+    name: string;
+    value: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    children?: ComponentChildren;
+    onValueChange?: (value: string) => void;
+};
+declare function Radio(_handle: Handle): (props: RadioProps) => remix_component.RemixElement;
+type RadioGroupOption = {
+    value: string;
+    label: ComponentChildren;
+    disabled?: boolean;
+};
+type RadioGroupProps = {
+    legend: ComponentChildren;
+    name: string;
+    options: RadioGroupOption[];
+    checkedValue?: string;
+    defaultCheckedValue?: string;
+    error?: ComponentChildren;
+    required?: boolean;
+    disabled?: boolean;
+    orientation?: "vertical" | "horizontal";
+    onValueChange?: (value: string) => void;
+};
+declare function resolveRadioGroupOrientation(orientation?: "vertical" | "horizontal"): "vertical" | "horizontal";
+declare function RadioGroup(_handle: Handle): (props: RadioGroupProps) => remix_component.RemixElement;
+
+type RangeSliderValue = [number, number];
+type RangeSliderProps = {
+    id?: string;
+    value?: RangeSliderValue;
+    defaultValue?: RangeSliderValue;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    required?: boolean;
+    nameStart?: string;
+    nameEnd?: string;
+    startLabel?: string;
+    endLabel?: string;
+    onValueChange?: (value: RangeSliderValue) => void;
+    "aria-describedby"?: string;
+    "aria-invalid"?: "true";
+};
+declare function normalizeRangeSliderBounds(min?: number, max?: number): {
+    min: number;
+    max: number;
+};
+declare function normalizeRangeSliderValue(value: RangeSliderValue | undefined, min: number, max: number): RangeSliderValue;
+declare function RangeSlider(handle: Handle): (props: RangeSliderProps) => remix_component.RemixElement;
+
+type ResultTone = "info" | "success" | "warning" | "danger";
+type ResultProps = {
+    tone?: ResultTone;
+    title: ComponentChildren;
+    description?: ComponentChildren;
+    actions?: ComponentChildren;
+};
+type ResultTitleProps = {
+    children: ComponentChildren;
+};
+type ResultDescriptionProps = {
+    children: ComponentChildren;
+};
+type ResultActionsProps = {
+    children: ComponentChildren;
+};
+declare function resolveResultTone(tone?: ResultTone): ResultTone;
+declare function resolveResultRole(tone: ResultTone): "status" | "alert";
+declare function Result(_handle: Handle): (props: ResultProps) => remix_component.RemixElement;
+declare function ResultTitle(_handle: Handle): (props: ResultTitleProps) => remix_component.RemixElement;
+declare function ResultDescription(_handle: Handle): (props: ResultDescriptionProps) => remix_component.RemixElement;
+declare function ResultActions(_handle: Handle): (props: ResultActionsProps) => remix_component.RemixElement;
+
+type SegmentedSize = "comfortable" | "compact";
+type SegmentedOption = {
+    value: string;
+    label: ComponentChildren;
+    disabled?: boolean;
+};
+type SegmentedProps = {
+    options: SegmentedOption[];
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    size?: SegmentedSize;
+    fullWidth?: boolean;
+    ariaLabel?: string;
+};
+declare function resolveSegmentedSize(size?: SegmentedSize): SegmentedSize;
+declare function resolveSegmentedFullWidth(fullWidth?: boolean): boolean;
+declare function resolveSegmentedValue(options: SegmentedOption[], value?: string): string | undefined;
+declare function Segmented(handle: Handle): (props: SegmentedProps) => remix_component.RemixElement;
+
+type SelectOption = {
+    value: string;
+    label: ComponentChildren;
+    disabled?: boolean;
+};
+type SelectProps = {
+    id?: string;
+    name?: string;
+    value?: string;
+    defaultValue?: string;
+    disabled?: boolean;
+    required?: boolean;
+    options: SelectOption[];
+};
+declare function Select(_handle: Handle): (props: SelectProps) => remix_component.RemixElement;
+
+type SpaceDirection = "horizontal" | "vertical";
+type SpaceSize = "xs" | "sm" | "md" | "lg";
+type SpaceAlign = "start" | "center" | "end" | "baseline" | "stretch";
+type SpaceProps = {
+    children: ComponentChildren;
+    direction?: SpaceDirection;
+    size?: SpaceSize;
+    align?: SpaceAlign;
+    wrap?: boolean;
+};
+declare function resolveSpaceDirection(direction?: SpaceDirection): SpaceDirection;
+declare function resolveSpaceSize(size?: SpaceSize): SpaceSize;
+declare function resolveSpaceAlign(align?: SpaceAlign): SpaceAlign;
+declare function resolveSpaceWrap(wrap?: boolean): boolean;
+declare function Space(_handle: Handle): (props: SpaceProps) => remix_component.RemixElement;
+
+type SliderProps = {
+    id?: string;
+    name?: string;
+    value?: number;
+    defaultValue?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    required?: boolean;
+    onValueChange?: (value: number) => void;
+    "aria-describedby"?: string;
+    "aria-invalid"?: "true";
+};
+declare function normalizeSliderStep(step?: number): number | undefined;
+declare function Slider(_handle: Handle): (props: SliderProps) => remix_component.RemixElement;
+
+type SkeletonProps = {
+    lines?: number;
+    animated?: boolean;
+};
+declare function normalizeSkeletonLines(lines?: number): number;
+declare function Skeleton(_handle: Handle): (props: SkeletonProps) => remix_component.RemixElement;
+
+type SpinnerSize = "sm" | "md" | "lg";
+type SpinnerProps = {
+    label?: string;
+    size?: SpinnerSize;
+};
+declare function resolveSpinnerSize(size?: SpinnerSize): SpinnerSize;
+declare function Spinner(_handle: Handle): (props: SpinnerProps) => remix_component.RemixElement;
+
+type StatisticTrend = "up" | "down" | "neutral";
+type StatisticProps = {
+    label: ComponentChildren;
+    value: ComponentChildren;
+    prefix?: ComponentChildren;
+    suffix?: ComponentChildren;
+    caption?: ComponentChildren;
+    trend?: StatisticTrend;
+};
+declare function resolveStatisticTrend(trend?: StatisticTrend): StatisticTrend;
+declare function Statistic(_handle: Handle): (props: StatisticProps) => remix_component.RemixElement;
+
+type ProgressTone = "neutral" | "success" | "warning" | "danger";
+type ProgressProps = {
+    value?: number;
+    max?: number;
+    tone?: ProgressTone;
+    label?: ComponentChildren;
+    showValue?: boolean;
+};
+declare function normalizeProgressMax(max?: number): number;
+declare function clampProgressValue(value: number | undefined, max: number): number;
+declare function resolveProgressTone(tone?: ProgressTone): ProgressTone;
+declare function Progress(_handle: Handle): (props: ProgressProps) => remix_component.RemixElement;
+
+type SplitterOrientation = "horizontal" | "vertical";
+type SplitterProps = {
+    first: ComponentChildren;
+    second: ComponentChildren;
+    orientation?: SplitterOrientation;
+    size?: number;
+    defaultSize?: number;
+    minSize?: number;
+    maxSize?: number;
+    step?: number;
+    onSizeChange?: (size: number) => void;
+    ariaLabel?: string;
+};
+declare function resolveSplitterOrientation(orientation?: SplitterOrientation): SplitterOrientation;
+declare function clampSplitterSize(size: number, minSize?: number, maxSize?: number): number;
+declare function resolveSplitterStep(step?: number): number;
+declare function stepSplitterSize(current: number, key: string, orientation: SplitterOrientation, minSize: number, maxSize: number, step: number): number | undefined;
+declare function Splitter(handle: Handle): (props: SplitterProps) => remix_component.RemixElement;
+
+type SideNavItem = {
+    id: string;
+    label: ComponentChildren;
+    href?: string;
+    disabled?: boolean;
+    children?: SideNavItem[];
+};
+type SideNavSection = {
+    id?: string;
+    label?: ComponentChildren;
+    items: SideNavItem[];
+};
+type SideNavProps = {
+    sections: SideNavSection[];
+    activeId?: string;
+    compact?: boolean;
+    ariaLabel?: string;
+};
+declare function normalizeSideNavCompact(compact?: boolean): boolean;
+declare function resolveSideNavActiveId(sections: SideNavSection[], activeId?: string): string | undefined;
+declare function SideNav(_handle: Handle): (props: SideNavProps) => remix_component.RemixElement;
+
+type StepItem = {
+    id: string;
+    label: ComponentChildren;
+    description?: ComponentChildren;
+};
+type StepStatus = "complete" | "current" | "upcoming";
+type StepsProps = {
+    items: StepItem[];
+    currentId?: string;
+    ariaLabel?: string;
+};
+declare function resolveStepsCurrentIndex(items: StepItem[], currentId?: string): number;
+declare function resolveStepStatus(index: number, currentIndex: number): StepStatus;
+declare function Steps(_handle: Handle): (props: StepsProps) => remix_component.RemixElement;
+
+type SwitchProps = {
+    id?: string;
+    name?: string;
+    value?: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    children?: ComponentChildren;
+};
+declare function getSwitchSubmissionValue(value?: string): string;
+declare function Switch(_handle: Handle): (props: SwitchProps) => remix_component.RemixElement;
+
+type TableColumn = {
+    key: string;
+    header: ComponentChildren;
+    align?: "left" | "center" | "right";
+};
+type TableRow = {
+    key: string;
+    cells: Record<string, ComponentChildren>;
+};
+type TableProps = {
+    caption?: ComponentChildren;
+    columns: TableColumn[];
+    rows: TableRow[];
+    emptyState?: ComponentChildren;
+};
+declare function Table(_handle: Handle): (props: TableProps) => remix_component.RemixElement;
+
+type TagTone = "neutral" | "brand";
+type TagProps = {
+    tone?: TagTone;
+    children: ComponentChildren;
+};
+type ChipProps = TagProps;
+declare function resolveTagTone(tone?: TagTone): TagTone;
+declare function Tag(_handle: Handle): (props: TagProps) => remix_component.RemixElement;
+declare function Chip(handle: Handle): (props: ChipProps) => remix_component.RemixElement;
+
+type TabItem = {
+    id: string;
+    label: ComponentChildren;
+    panel: ComponentChildren;
+};
+type TabsProps = {
+    items: TabItem[];
+    value?: string;
+    defaultValue?: string;
+    activation?: "manual" | "automatic";
+    overflow?: "wrap" | "menu";
+    maxVisibleTabs?: number;
+    overflowLabel?: ComponentChildren;
+};
+type TabsActivation = "manual" | "automatic";
+type TabsOverflowPartition = {
+    visible: TabItem[];
+    overflow: TabItem[];
+};
+declare function resolveTabsOverflow(overflow?: "wrap" | "menu"): "wrap" | "menu";
+declare function resolveTabsActivation(activation?: TabsActivation): TabsActivation;
+declare function resolveTabsMaxVisible(maxVisibleTabs?: number): number;
+declare function partitionTabsForOverflow(items: TabItem[], selectedId: string | undefined, maxVisibleTabs: number): TabsOverflowPartition;
+declare function resolveTabsKeyboardTargetIndex(currentIndex: number, itemCount: number, key: "ArrowRight" | "ArrowLeft" | "Home" | "End"): number;
+declare function Tabs(handle: Handle): (props: TabsProps) => remix_component.RemixElement;
+
+type TextareaProps = {
+    id?: string;
+    name?: string;
+    value?: string;
+    defaultValue?: string;
+    disabled?: boolean;
+    required?: boolean;
+    placeholder?: string;
+    rows?: number;
+    maxLength?: number;
+    minLength?: number;
+    onValueChange?: (value: string | undefined) => void;
+    "aria-describedby"?: string;
+    "aria-invalid"?: "true";
+};
+declare function resolveTextareaRows(rows?: number): number;
+declare function Textarea(_handle: Handle): (props: TextareaProps) => remix_component.RemixElement;
+
+type TimePickerProps = {
+    id?: string;
+    name?: string;
+    value?: string;
+    defaultValue?: string;
+    min?: string;
+    max?: string;
+    step?: number;
+    disabled?: boolean;
+    required?: boolean;
+    onValueChange?: (value: string | undefined) => void;
+    onValueCommit?: (value: string | undefined) => void;
+    "aria-describedby"?: string;
+    "aria-invalid"?: "true";
+};
+declare function parseTimeValue(value?: string): {
+    hours: number;
+    minutes: number;
+    seconds: number;
+} | undefined;
+declare function normalizeTimeStep(step?: number): number | undefined;
+declare function TimePicker(_handle: Handle): (props: TimePickerProps) => remix_component.RemixElement;
+
+type TimelineTone = "neutral" | "success" | "warning" | "danger";
+type TimelineItem = {
+    key: string;
+    title: ComponentChildren;
+    description?: ComponentChildren;
+    time?: ComponentChildren;
+    tone?: TimelineTone;
+};
+type TimelineProps = {
+    items: TimelineItem[];
+    pending?: ComponentChildren;
+    emptyState?: ComponentChildren;
+};
+declare function resolveTimelineTone(tone?: TimelineTone): TimelineTone;
+declare function resolveTimelinePending(pending?: ComponentChildren): ComponentChildren;
+declare function Timeline(_handle: Handle): (props: TimelineProps) => remix_component.RemixElement;
+
+type ToastTone = "neutral" | "success" | "danger";
+type ToastItem = {
+    id: string;
+    tone?: ToastTone;
+    content: ComponentChildren;
+    durationMs?: number;
+    dismissible?: boolean;
+};
+type ToastViewportProps = {
+    items: ToastItem[];
+    onPause?: (id: string) => void;
+    onResume?: (id: string) => void;
+    onDismiss?: (id: string, reason: "escape" | "close-button") => void;
+};
+declare function ToastViewport(_handle: Handle): (props: ToastViewportProps) => remix_component.RemixElement;
+type ToastStore = {
+    items(): ToastItem[];
+    show(item: ToastItem): void;
+    dismiss(id: string, reason?: "timeout" | "programmatic" | "escape" | "close-button"): void;
+    pause(id: string): void;
+    resume(id: string): void;
+};
+declare function createToastStore(initial?: ToastItem[], options?: {
+    defaultDurationMs?: number;
+}): ToastStore;
+
+type TooltipProps = {
+    label: ComponentChildren;
+    children: ComponentChildren;
+};
+declare function Tooltip(handle: Handle): (props: TooltipProps) => remix_component.RemixElement;
+
+type TransferDirection = "left" | "right";
+type TransferItem = {
+    key: string;
+    label: ComponentChildren;
+    description?: ComponentChildren;
+    disabled?: boolean;
+};
+type TransferProps = {
+    items: TransferItem[];
+    targetKeys?: string[];
+    defaultTargetKeys?: string[];
+    selectedKeys?: string[];
+    defaultSelectedKeys?: string[];
+    onChange?: (targetKeys: string[]) => void;
+    onSelectChange?: (selectedKeys: string[]) => void;
+    leftTitle?: ComponentChildren;
+    rightTitle?: ComponentChildren;
+    emptyState?: ComponentChildren;
+};
+declare function resolveTransferTargetKeys(items: TransferItem[], targetKeys?: string[]): string[];
+declare function resolveTransferSelectedKeys(items: TransferItem[], selectedKeys?: string[]): string[];
+declare function partitionTransferItems(items: TransferItem[], targetKeys: string[]): {
+    sourceItems: TransferItem[];
+    targetItems: TransferItem[];
+};
+declare function resolveTransferMoveKeys(items: TransferItem[], selectedKeys: string[], targetKeys: string[], direction: TransferDirection): string[];
+declare function moveTransferKeys(currentTargetKeys: string[], moveKeys: string[], direction: TransferDirection): string[];
+declare function Transfer(handle: Handle): (props: TransferProps) => remix_component.RemixElement;
+
+type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+type TextElement = "p" | "span" | "strong" | "em" | "small";
+type HeadingProps = {
+    level?: HeadingLevel;
+    id?: string;
+    children: ComponentChildren;
+};
+type TextProps = {
+    as?: TextElement;
+    truncate?: boolean;
+    children: ComponentChildren;
+};
+type CodeProps = {
+    block?: boolean;
+    children: ComponentChildren;
+};
+declare function resolveHeadingLevel(level?: HeadingLevel): HeadingLevel;
+declare function resolveTextElement(element?: TextElement): TextElement;
+declare function resolveTextTruncate(truncate?: boolean): boolean;
+declare function resolveCodeBlock(block?: boolean): boolean;
+declare function Heading(_handle: Handle): (props: HeadingProps) => remix_component.RemixElement;
+declare function Text(_handle: Handle): (props: TextProps) => remix_component.RemixElement;
+declare function Code(_handle: Handle): (props: CodeProps) => remix_component.RemixElement;
+declare function Typography(handle: Handle): (props: TextProps) => remix_component.RemixElement;
+
+type TopNavItem = {
+    id: string;
+    label: ComponentChildren;
+    href?: string;
+    disabled?: boolean;
+};
+type TopNavProps = {
+    items: TopNavItem[];
+    activeId?: string;
+    compact?: boolean;
+    ariaLabel?: string;
+};
+declare function normalizeTopNavCompact(compact?: boolean): boolean;
+declare function resolveTopNavActiveId(items: TopNavItem[], activeId?: string): string | undefined;
+declare function TopNav(_handle: Handle): (props: TopNavProps) => remix_component.RemixElement;
+
+type TreeNode = {
+    id: string;
+    label: ComponentChildren;
+    children?: TreeNode[];
+    disabled?: boolean;
+};
+type TreeProps = {
+    nodes: TreeNode[];
+    selectedId?: string;
+    defaultSelectedId?: string;
+    expandedIds?: string[];
+    defaultExpandedIds?: string[];
+    onSelect?: (id: string) => void;
+    onExpandedChange?: (ids: string[]) => void;
+    ariaLabel?: string;
+};
+declare function flattenTreeNodeIds(nodes: TreeNode[]): string[];
+declare function resolveTreeSelectedId(nodes: TreeNode[], selectedId?: string): string | undefined;
+declare function toggleTreeExpanded(expandedIds: string[], id: string): string[];
+declare function Tree(handle: Handle): (props: TreeProps) => remix_component.RemixElement;
+
+type TreeSelectNode = {
+    id: string;
+    label: ComponentChildren;
+    children?: TreeSelectNode[];
+    disabled?: boolean;
+};
+type TreeSelectProps = {
+    options: TreeSelectNode[];
+    value?: string;
+    defaultValue?: string;
+    open?: boolean;
+    defaultOpen?: boolean;
+    expandedIds?: string[];
+    defaultExpandedIds?: string[];
+    placeholder?: ComponentChildren;
+    emptyState?: ComponentChildren;
+    onChange?: (id: string) => void;
+    onOpenChange?: (open: boolean) => void;
+    onExpandedChange?: (ids: string[]) => void;
+    ariaLabel?: string;
+};
+declare function flattenTreeSelectIds(nodes: TreeSelectNode[]): string[];
+declare function resolveTreeSelectValue(nodes: TreeSelectNode[], value?: string): string | undefined;
+declare function toggleTreeSelectExpanded(expandedIds: string[], id: string): string[];
+declare function resolveTreeSelectLabel(nodes: TreeSelectNode[], selectedId: string | undefined, placeholder: ComponentChildren): ComponentChildren;
+declare function TreeSelect(handle: Handle): (props: TreeSelectProps) => remix_component.RemixElement;
+
+type Maturity = "experimental" | "stable";
+type ComponentMetadata = {
+    name: string;
+    maturity: Maturity;
+};
+declare const componentMetadata: ComponentMetadata[];
+
+declare const componentKeymaps: {
+    readonly Button: readonly ["Enter", "Space"];
+    readonly Input: readonly ["Printable", "Tab"];
+    readonly Checkbox: readonly ["Space"];
+    readonly Radio: readonly ["Tab", "ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown"];
+    readonly Select: readonly ["ArrowUp", "ArrowDown", "Enter"];
+    readonly Dialog: readonly ["Escape", "Tab", "Shift+Tab"];
+    readonly Tabs: readonly ["ArrowLeft", "ArrowRight", "Home", "End", "Enter", "Space"];
+    readonly Menu: readonly ["ArrowUp", "ArrowDown", "Escape", "Enter", "Space"];
+    readonly Toast: readonly ["Escape", "Tab"];
+};
+
+export { Alert, type AlertProps, type AlertTone, Anchor, type AnchorItem, type AnchorProps, AppHeader, type AppHeaderDensity, type AppHeaderProps, AppProvider, type AppProviderColorScheme, type AppProviderDirection, type AppProviderNavigatePayload, type AppProviderProps, type AppProviderReducedMotion, AppShell, type AppShellProps, type AppShellSidebarPosition, Autocomplete, type AutocompleteCommit, type AutocompleteOption, type AutocompleteProps, Avatar, type AvatarProps, type AvatarSize, type AvatarStatus, Badge, type BadgeProps, type BadgeTone, type BreadcrumbItem, BreadcrumbOverflow, type BreadcrumbOverflowEntry, type BreadcrumbOverflowProps, Breadcrumbs, type BreadcrumbsProps, Button, type ButtonProps, type ButtonSize, type ButtonVariant, Calendar, type CalendarProps, type CalendarView, Card, type CardProps, Cascader, type CascaderOption, type CascaderProps, Checkbox, type CheckboxProps, Chip, type ChipProps, Code, type CodeProps, Collapse, type CollapseProps, Combobox, type ComboboxOption, type ComboboxProps, type CommandItem, CommandPalette, type CommandPaletteProps, type ComponentMetadata, ConfigProvider, type ConfigProviderColorScheme, type ConfigProviderDirection, type ConfigProviderNavigatePayload, type ConfigProviderProps, type ConfigProviderReducedMotion, type ConfigProviderRouter, ConfirmDialog, type ConfirmDialogCloseReason, type ConfirmDialogDefaults, type ConfirmDialogProps, type DataGridColumn, type DataGridDirection, DataGridLite, type DataGridLiteProps, type DataGridRow, type DataGridSort, DataList, type DataListItem, type DataListProps, DataTable, type DataTableColumn, type DataTableProps, type DataTableRow, type DataTableRowFilter, DatePicker, type DatePickerProps, DateRangePicker, type DateRangePickerProps, type DateRangeValue, DateTimePicker, type DateTimePickerParts, type DateTimePickerProps, Description, Descriptions, type DescriptionsCollapseBelow, type DescriptionsItem, type DescriptionsLayout, type DescriptionsProps, type DescriptionsSize, Dialog, type DialogCloseReason, type DialogProps, Divider, type DividerOrientation, type DividerProps, Drawer, type DrawerCloseReason, type DrawerPosition, type DrawerProps, Dropdown, type DropdownProps, Empty, type EmptyProps, EmptyResults, type EmptyResultsProps, type EmptySize, EmptyState, type EmptyStateProps, Error, Field, type FieldProps, FileUpload, type FileUploadCapture, type FileUploadProps, FilterBar, type FilterBarProps, FilterPanel, type FilterPanelCloseReason, type FilterPanelProps, Flex, type FlexAlign, type FlexDirection, type FlexJustify, type FlexProps, type FlexWrap, Form, FormErrorSummary, type FormErrorSummaryProps, FormFieldset, type FormFieldsetColumns, type FormFieldsetProps, FormLayout, type FormLayoutColumns, type FormLayoutProps, FormMessage, type FormMessageProps, type FormMessageTone, type FormMethod, type FormProps, Grid, type GridAlign, type GridColumns, GridItem, type GridItemProps, type GridProps, Heading, type HeadingLevel, type HeadingProps, Image, type ImageFit, type ImageProps, InlineAlert, type InlineAlertProps, type InlineAlertTone, Input, type InputProps, type InputType, Label, Layout, LayoutContent, type LayoutDirection, LayoutFooter, LayoutHeader, type LayoutProps, type LayoutSectionProps, LayoutSider, type LayoutSiderProps, Link, type LinkNavigateMode, type LinkNavigatePayload, type LinkProps, type Maturity, Menu, type MenuItem, type MenuProps, NumberInput, type NumberInputProps, PageHeader, type PageHeaderProps, Pagination, type PaginationItem, type PaginationProps, Popover, type PopoverProps, Progress, type ProgressProps, type ProgressTone, Radio, RadioGroup, type RadioGroupOption, type RadioGroupProps, type RadioProps, RangeSlider, type RangeSliderProps, type RangeSliderValue, Result, ResultActions, type ResultActionsProps, ResultDescription, type ResultDescriptionProps, type ResultProps, ResultTitle, type ResultTitleProps, type ResultTone, Segmented, type SegmentedOption, type SegmentedProps, type SegmentedSize, Select, type SelectOption, type SelectProps, SideNav, type SideNavItem, type SideNavProps, type SideNavSection, Skeleton, type SkeletonProps, Slider, type SliderProps, Space, type SpaceAlign, type SpaceDirection, type SpaceProps, type SpaceSize, Spinner, type SpinnerProps, type SpinnerSize, Splitter, type SplitterOrientation, type SplitterProps, Statistic, type StatisticProps, type StatisticTrend, type StepItem, type StepStatus, Steps, type StepsProps, Switch, type SwitchProps, type TabItem, Table, type TableColumn, type TableProps, type TableRow, Tabs, type TabsActivation, type TabsOverflowPartition, type TabsProps, Tag, type TagProps, type TagTone, Text, type TextElement, type TextProps, Textarea, type TextareaProps, TimePicker, type TimePickerProps, Timeline, type TimelineItem, type TimelineProps, type TimelineTone, type ToastItem, type ToastStore, type ToastTone, ToastViewport, type ToastViewportProps, Tooltip, type TooltipProps, TopNav, type TopNavItem, type TopNavProps, Transfer, type TransferDirection, type TransferItem, type TransferProps, Tree, type TreeNode, type TreeProps, TreeSelect, type TreeSelectNode, type TreeSelectProps, Typography, addDays, addMonths, buildBreadcrumbOverflowEntries, buildCalendarCells, buildCommandOptionId, buildPaginationItems, clampDataTablePage, clampPage, clampProgressValue, clampSplitterSize, componentKeymaps, componentMetadata, composeDataTableRowFilter, createDataTableContainsFilter, createDataTableEqualsFilter, createToastStore, filterComboboxOptions, filterCommands, filterDataTableRows, findCascaderOptionIndex, findFirstEnabledIndex, findNextEnabledCascaderOption, findNextEnabledCommandIndex, findNextEnabledIndex, flattenTreeNodeIds, flattenTreeSelectIds, formatDateRangeValue, formatISODate, getAvatarInitials, getSwitchSubmissionValue, isAnchorItemActive, isCascaderLeaf, isDateWithinRange, isExternalAppProviderHref, isExternalLinkHref, joinDateTimeLocal, monthStart, moveTransferKeys, nextDateRangeSelection, nextSort, normalizeBreadcrumbOverflowMaxVisible, normalizeDateTimeLocal, normalizeFileUploadAccept, normalizeFormFieldsetColumns, normalizeFormLayoutColumns, normalizeNumberInputStep, normalizeProgressMax, normalizeRangeSliderBounds, normalizeRangeSliderValue, normalizeSideNavCompact, normalizeSkeletonLines, normalizeSliderStep, normalizeTimeStep, normalizeTopNavCompact, paginateDataTableRows, parseISODate, parseTimeValue, partitionTabsForOverflow, partitionTransferItems, resolveAnchorActiveHref, resolveAnchorHashTarget, resolveAnchorInitialHref, resolveAppHeaderDensity, resolveAppHeaderSticky, resolveAppProviderColorScheme, resolveAppProviderDirection, resolveAppProviderLocale, resolveAppProviderReducedMotion, resolveAppShellSidebarPosition, resolveAppShellSidebarState, resolveAppShellSidebarWidth, resolveAutocompleteCommit, resolveAvatarSize, resolveAvatarSquare, resolveBadgeTone, resolveBreadcrumbCurrentIndex, resolveBreadcrumbSeparator, resolveCalendarDisabled, resolveCalendarType, resolveCalendarView, resolveCascaderColumns, resolveCascaderPath, resolveCascaderPathLabels, resolveCascaderTriggerLabel, resolveCodeBlock, resolveCollapseOpen, resolveConfigProviderColorScheme, resolveConfigProviderDirection, resolveConfigProviderLocale, resolveConfigProviderReducedMotion, resolveConfirmDialogDefaults, resolveDataTableCellText, resolveDataTablePageSize, resolveDataTableTotalPages, resolveDescriptionsBordered, resolveDescriptionsCollapseBelow, resolveDescriptionsColumns, resolveDescriptionsItemSpan, resolveDescriptionsLayout, resolveDescriptionsSize, resolveDividerDecorative, resolveDividerInset, resolveDividerOrientation, resolveDrawerDismissOnBackdrop, resolveDrawerPosition, resolveEmptySize, resolveFilterPanelApplyLabel, resolveFilterPanelClearLabel, resolveFilterPanelCloseOnApply, resolveFilterPanelCloseOnClear, resolveFilterPanelShowApplyButton, resolveFilterPanelShowClearButton, resolveFilterPanelTitle, resolveFlexAlign, resolveFlexDirection, resolveFlexGap, resolveFlexInline, resolveFlexJustify, resolveFlexWrap, resolveFormBusy, resolveFormMessageA11y, resolveFormMethod, resolveFormNoValidate, resolveGridAlign, resolveGridColumns, resolveGridGap, resolveGridItemSpan, resolveHeadingLevel, resolveImageFallbackText, resolveImageFit, resolveImageLoading, resolveInlineAlertRole, resolveInlineAlertTone, resolveLayoutDirection, resolveLayoutHasSider, resolveLayoutSiderCollapsed, resolveLayoutSiderWidth, resolveLinkNavigateMode, resolveLinkRel, resolveMenuOpen, resolvePopoverOpen, resolveProgressTone, resolveRadioGroupOrientation, resolveResultRole, resolveResultTone, resolveSegmentedFullWidth, resolveSegmentedSize, resolveSegmentedValue, resolveSideNavActiveId, resolveSpaceAlign, resolveSpaceDirection, resolveSpaceSize, resolveSpaceWrap, resolveSpinnerSize, resolveSplitterOrientation, resolveSplitterStep, resolveStatisticTrend, resolveStepStatus, resolveStepsCurrentIndex, resolveTabsActivation, resolveTabsKeyboardTargetIndex, resolveTabsMaxVisible, resolveTabsOverflow, resolveTagTone, resolveTextElement, resolveTextTruncate, resolveTextareaRows, resolveTimelinePending, resolveTimelineTone, resolveTopNavActiveId, resolveTransferMoveKeys, resolveTransferSelectedKeys, resolveTransferTargetKeys, resolveTreeSelectLabel, resolveTreeSelectValue, resolveTreeSelectedId, shouldCascaderCommitSelection, shouldHandleAppProviderNavigation, shouldHandleLinkNavigation, sortRows, splitDateTimeLocal, stepSplitterSize, syncAnchorActiveHrefFromHash, toggleTreeExpanded, toggleTreeSelectExpanded };