@baseline-ui/core 0.59.0 → 0.60.0

package/dist/components/ToggleIconButton/ToggleIconButton.css.d.ts

@@ -0,0 +1,149 @@
+export declare const btnSizeCn: ((options?: {
+    size?: "xs" | "sm" | "lg" | "md" | "xxs" | undefined;
+} | undefined) => string) & {
+    variants: () => "size"[];
+    classNames: import("@baseline-ui/css").RecipeClassNames<{
+        size: {
+            xxs: {
+                minHeight: number;
+            };
+            xs: {
+                minHeight: number;
+            };
+            sm: {
+                minHeight: number;
+            };
+            md: {
+                minHeight: number;
+            };
+            lg: {
+                minHeight: number;
+            };
+        };
+    }>;
+};
+export declare const toolbarIconButtonCn: ((options?: {
+    isHovered?: boolean | undefined;
+    isFocusVisible?: boolean | undefined;
+    isSelected?: boolean | undefined;
+    isDisabled?: boolean | undefined;
+} | undefined) => string) & {
+    variants: () => ("isSelected" | "isHovered" | "isDisabled" | "isFocusVisible")[];
+    classNames: import("@baseline-ui/css").RecipeClassNames<{
+        isHovered: {
+            true: {};
+        };
+        isFocusVisible: {
+            true: {};
+        };
+        isSelected: {
+            true: {};
+        };
+        isDisabled: {
+            true: (string | {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            } | {
+                backgroundColor: `var(--${string})`;
+            })[];
+        };
+    }>;
+};
+export declare const primaryIconButtonCn: ((options?: {
+    isHovered?: boolean | undefined;
+    isFocusVisible?: boolean | undefined;
+    isDisabled?: boolean | undefined;
+    isSelected?: boolean | undefined;
+} | undefined) => string) & {
+    variants: () => ("isSelected" | "isHovered" | "isDisabled" | "isFocusVisible")[];
+    classNames: import("@baseline-ui/css").RecipeClassNames<{
+        isHovered: {
+            true: {};
+        };
+        isFocusVisible: {
+            true: {};
+        };
+        isDisabled: {
+            true: (string | {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            })[];
+        };
+        isSelected: {
+            true: {};
+        };
+    }>;
+};
+export declare const secondaryIconButtonCn: ((options?: {
+    isHovered?: boolean | undefined;
+    isFocusVisible?: boolean | undefined;
+    isSelected?: boolean | undefined;
+    isDisabled?: boolean | undefined;
+} | undefined) => string) & {
+    variants: () => ("isSelected" | "isHovered" | "isDisabled" | "isFocusVisible")[];
+    classNames: import("@baseline-ui/css").RecipeClassNames<{
+        isHovered: {
+            true: {};
+        };
+        isFocusVisible: {
+            true: {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            };
+        };
+        isSelected: {
+            true: {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            };
+        };
+        isDisabled: {
+            true: (string | {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            })[];
+        };
+    }>;
+};
+export declare const tertiaryIconButtonCn: ((options?: {
+    isHovered?: boolean | undefined;
+    isFocusVisible?: boolean | undefined;
+    isSelected?: boolean | undefined;
+    isDisabled?: boolean | undefined;
+} | undefined) => string) & {
+    variants: () => ("isSelected" | "isHovered" | "isDisabled" | "isFocusVisible")[];
+    classNames: import("@baseline-ui/css").RecipeClassNames<{
+        isHovered: {
+            true: {};
+        };
+        isFocusVisible: {
+            true: {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            };
+        };
+        isSelected: {
+            true: {};
+        };
+        isDisabled: {
+            true: (string | {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            })[];
+        };
+    }>;
+};

package/dist/components/ToggleIconButton/ToggleIconButton.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { ToggleIconButtonProps } from "./ToggleIconButton.types";
+export declare const ToggleIconButton: React.ForwardRefExoticComponent<ToggleIconButtonProps & React.RefAttributes<HTMLButtonElement>>;

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

@@ -0,0 +1,30 @@
+import type { StylingProps } from "../../utils";
+import type { StylingWithUIState } from "../ActionButton/ActionButton.types";
+import type { ActionIconButtonProps } from "../ActionIconButton";
+import type { IconProps } from "../Icon";
+import type { ToggleButtonProps } from "../ToggleButton";
+import type React from "react";
+import type { ToggleProps } from "react-stately";
+export interface ToggleIconButtonProps extends Omit<StylingProps, "style" | "className">, Omit<ToggleProps, "children">, Omit<ToggleButtonProps, "size" | "iconStart" | "label" | "variant">, Pick<ActionIconButtonProps, "tooltip">, StylingWithUIState<{
+    isSelected?: boolean;
+}> {
+    /**
+     * The available sizes for a variable.
+     *
+     * @default "md"
+     */
+    size?: "xxs" | "xs" | "sm" | "md" | "lg";
+    /** Represents the variant of a component. */
+    variant?: "primary" | "secondary" | "tertiary" | "toolbar";
+    /**
+     * The icon to be displayed on the button. You can pass an object with
+     * `selected` and `unselected` keys to display different icons based on the
+     * state of the button.
+     */
+    icon: React.FC<IconProps> | {
+        selected: React.FC<IconProps>;
+        unselected: React.FC<IconProps>;
+    };
+    /** Indicates whether focusing should be prevented on press. */
+    preventFocusOnPress?: boolean;
+}

package/dist/components/ToggleIconButton/index.d.ts

@@ -0,0 +1,2 @@
+export { ToggleIconButton } from "./ToggleIconButton";
+export { type ToggleIconButtonProps } from "./ToggleIconButton.types";

package/dist/components/Toolbar/CollapsibleToolbar.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { ToolbarProps } from "./Toolbar.types";
+export declare const CollapsibleToolbar: React.ForwardRefExoticComponent<Omit<ToolbarProps, "isCollapsible"> & React.RefAttributes<HTMLDivElement>>;

package/dist/components/Toolbar/Toolbar.css.d.ts

@@ -0,0 +1,2 @@
+export declare const toolbarCn: Record<"horizontal" | "vertical", string>;
+export declare const collapsibleToolbarWrapperCn: string;

package/dist/components/Toolbar/Toolbar.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { ToolbarProps } from "./Toolbar.types";
+export declare const Toolbar: React.ForwardRefExoticComponent<ToolbarProps & React.RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,47 @@
+import type { StylingProps } from "../../utils";
+import type { MenuProps } from "../Menu";
+import type { KeyboardProps } from "@react-aria/interactions";
+import type { AriaToolbarProps } from "@react-aria/toolbar";
+import type React from "react";
+export interface ToolbarProps extends StylingProps, AriaToolbarProps {
+    /** The children of the toolbar. */
+    children: React.ReactNode;
+    /**
+     * Identifies the element (or elements) whose contents or presence are
+     * controlled by the current element.
+     */
+    "aria-controls"?: string;
+    /**
+     * This prop is used to determine if the toolbar should be collapsible. If
+     * true, the buttons in the toolbar will be hidden behind a menu when the
+     * toolbar is too small to display all of the buttons.
+     *
+     * @default false
+     */
+    isCollapsible?: boolean;
+    /**
+     * The props to pass to the Menu component when the toolbar is collapsible.
+     * This prop is only relevant when `isCollapsible` is true.
+     */
+    collapsibleMenuProps?: Omit<MenuProps, "items" | "onAction" | "placement" | "disabledKeys">;
+    /**
+     * A boolean indicating whether to render a spacer element in the collapsible
+     * toolbar between the toolbar buttons and the menu trigger. This prop is only
+     * relevant when `isCollapsible` is true.
+     */
+    renderSpacer?: boolean;
+    /** The callback to call when any key is pressed. */
+    onKeyDown?: KeyboardProps["onKeyDown"];
+    /**
+     * When set to true, the toolbar will act as a normal toolbar and will not
+     * contain the navigation within it when the user presses tab again.
+     *
+     * When set to false, the toolbar will allow for navigating through all
+     * elements within it if the user presses tab, and move to the next focusable
+     * element outside of the toolbar only after user navigates through all
+     * elements within the toolbar.
+     *
+     * @default true
+     */
+    isSingleTabStop?: boolean;
+}

package/dist/components/Toolbar/WrappedToolbar.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { ToolbarProps } from "./Toolbar.types";
+export declare const WrappedToolbar: React.ForwardRefExoticComponent<ToolbarProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/Toolbar/hooks/useFormattedList.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+export declare const UNSUPPORTED_IN_MENU = "UNSUPPORTED_IN_MENU";
+export declare function useFormattedList(children: React.ReactNode): React.JSX.Element[];

package/dist/components/Toolbar/hooks/useInputAwareToolbar.d.ts

@@ -0,0 +1,6 @@
+import type { AriaToolbarProps, ToolbarAria } from "@react-aria/toolbar";
+import type { RefObject } from "react";
+export declare function useInputAwareToolbar({ props, ref, }: {
+    props: AriaToolbarProps;
+    ref: RefObject<HTMLDivElement | null>;
+}): ToolbarAria;

package/dist/components/Toolbar/index.d.ts

@@ -0,0 +1,3 @@
+export { Toolbar } from "./Toolbar";
+export { type ToolbarProps } from "./Toolbar.types";
+export * from "./Toolbar";

package/dist/components/Tooltip/Tooltip.css.d.ts

@@ -0,0 +1,44 @@
+export declare const ARROW_HEIGHT = 8;
+export declare const arrowCn: import("@vanilla-extract/recipes").RuntimeFn<{
+    placement: {
+        bottom: {
+            transform: "translate(-50%, -7px)";
+        };
+        left: {
+            transform: "translate(10px, -50%) rotate(90deg)";
+            right: number;
+        };
+        right: {
+            transform: "translate(-10px, -50%) rotate(270deg)";
+            left: number;
+        };
+        top: {
+            transform: "translate(-50%, 7px) rotate(180deg)";
+            bottom: number;
+        };
+    };
+    variant: {
+        default: {
+            borderBottomColor: `var(--${string})`;
+        };
+        inverse: {
+            borderBottomColor: `var(--${string})`;
+        };
+    };
+}>;
+export declare const tooltipContentCn: ((options?: {
+    size?: "sm" | "md" | undefined;
+    variant?: "default" | "inverse" | undefined;
+} | undefined) => string) & {
+    variants: () => ("size" | "variant")[];
+    classNames: import("@baseline-ui/css").RecipeClassNames<{
+        size: {
+            md: string;
+            sm: string;
+        };
+        variant: {
+            default: string;
+            inverse: string;
+        };
+    }>;
+};

package/dist/components/Tooltip/Tooltip.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { TooltipProps } from "./Tooltip.types";
+export declare const Tooltip: React.ForwardRefExoticComponent<TooltipProps & React.RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,55 @@
+import type { StylingProps } from "../../utils";
+import type { DOMAttributes } from "@react-types/shared";
+import type React from "react";
+import type { AriaPositionProps, AriaTooltipProps, FocusableOptions } from "react-aria";
+import type { TooltipTriggerProps } from "react-stately";
+export interface TooltipProps extends StylingProps, TooltipTriggerProps, AriaTooltipProps, Omit<AriaPositionProps, "overlayRef" | "targetRef" | "maxHeight" | "isOpen" | "arrowSize"> {
+    /** The content of the tooltip. */
+    text?: string;
+    /** The tooltip trigger element. */
+    children: React.ReactNode | ((props: {
+        triggerProps: DOMAttributes;
+        triggerRef: React.RefObject<HTMLElement>;
+    }) => React.ReactNode);
+    /**
+     * The delay time for the tooltip to show up.
+     *
+     * @default 1000
+     */
+    delay?: number;
+    /**
+     * The delay time for the tooltip to hide.
+     *
+     * @default 500
+     */
+    closeDelay?: number;
+    /**
+     * Represents the size of an element.
+     *
+     * @default md
+     */
+    size?: "sm" | "md";
+    /**
+     * The variant that can be applied to an element.
+     *
+     * @default default
+     */
+    variant?: "default" | "inverse";
+    /**
+     * Indicates whether to include an arrow in the output.
+     *
+     * @default true
+     */
+    includeArrow?: boolean;
+    /**
+     * The container element for the modal. By default, the modal is rendered as a
+     * child of the body element.
+     *
+     * @default document.body
+     */
+    portalContainer?: HTMLElement;
+}
+export interface FocusableProps extends FocusableOptions, StylingProps {
+    /** The content of the focusable element. */
+    children: React.ReactNode;
+}

package/dist/components/Tooltip/TooltipContent.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+import type { TooltipProps } from "./Tooltip.types";
+import type { DOMAttributes } from "@react-types/shared";
+import type { PlacementAxis } from "react-aria";
+import type { TooltipTriggerState } from "react-stately";
+export declare const TooltipContent: React.ForwardRefExoticComponent<TooltipContentProps & React.RefAttributes<HTMLDivElement>>;
+interface TooltipContentProps extends Pick<TooltipProps, "variant" | "size" | "includeArrow"> {
+    children: React.ReactNode;
+    state: TooltipTriggerState;
+    arrowProps: DOMAttributes;
+    overlayProps: DOMAttributes;
+    placement: PlacementAxis;
+    tooltipProps: DOMAttributes;
+}
+export {};

package/dist/components/Tooltip/index.d.ts

@@ -0,0 +1,3 @@
+export { Tooltip } from "./Tooltip";
+export { type TooltipProps, type FocusableProps } from "./Tooltip.types";
+export { Focusable, Pressable } from "react-aria";

package/dist/components/TreeView/TreeItem.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import type { TreeListItem, TreeViewProps } from "./TreeView.types";
+interface TreeLeafProps extends Pick<TreeViewProps, "actionsPosition" | "onPrimaryAction" | "onSecondaryAction" | "primaryActionIcon" | "secondaryActionIcon" | "primaryActionAriaLabel" | "secondaryActionAriaLabel" | "onRename" | "renderItemTitle"> {
+    item: TreeListItem;
+}
+export declare const TreeLeaf: React.FC<TreeLeafProps>;
+export {};

package/dist/components/TreeView/TreeView.css.d.ts

@@ -0,0 +1,34 @@
+export declare const treeItemCn: ((options?: {
+    isSelected?: boolean | undefined;
+    isHovered?: boolean | undefined;
+    isRenaming?: boolean | undefined;
+    isFocusVisible?: boolean | undefined;
+} | undefined) => string) & {
+    variants: () => ("isSelected" | "isHovered" | "isFocusVisible" | "isRenaming")[];
+    classNames: import("@baseline-ui/css").RecipeClassNames<{
+        isSelected: {
+            true: {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            };
+        };
+        isHovered: {
+            true: {};
+        };
+        isRenaming: {
+            true: {};
+        };
+        isFocusVisible: {
+            true: {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            };
+        };
+    }>;
+};
+export declare const treeItemAliasCn: string;
+export declare const chevronButtonCn: string;

package/dist/components/TreeView/TreeView.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import type { TreeViewProps } from "./TreeView.types";
+import type { Key } from "@react-types/shared";
+export declare const RenamingContext: React.Context<{
+    renamingKey: Key | null;
+    setRenamingKey: (key: Key | null) => void;
+}>;
+export declare const TreeView: React.ForwardRefExoticComponent<TreeViewProps & React.RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,95 @@
+import type { StylingProps } from "../../utils";
+import type { ListOption } from "../shared/types/List";
+import type { ToggleIconButtonProps } from "../ToggleIconButton";
+import type { AriaLabelingProps } from "@react-types/shared";
+import type { Key, ReactNode } from "react";
+import type { TreeProps } from "react-stately";
+export interface TreeListItem extends ListOption {
+    children?: TreeListItem[];
+}
+export interface TreeViewProps extends StylingProps, Omit<AriaLabelingProps, "aria-describedby" | "aria-details">, Omit<TreeProps<TreeListItem>, "items" | "children" | "disabledKeys" | "defaultSelectedKeys" | "onSelectionChange" | "collection" | "selectionMode"> {
+    /**
+     * The items to display in the tree view. Each item can be a leaf or a
+     * section.
+     *
+     * @example
+     *   ```tsx
+     *   const treeItems = {
+     *     id: "root",
+     *     label: "Root item",
+     *     children: [
+     *       {
+     *         id: "documents",
+     *         label: "Documents",
+     *         icon: EllipseIcon,
+     *         children: [
+     *           {
+     *             id: "work",
+     *             icon: EllipseIcon,
+     *             label: "Work",
+     *             children: [
+     *               {
+     *                 id: "project-a",
+     *                 icon: EllipseIcon,
+     *                 label: "Project A",
+     *               },
+     *             ],
+     *           },
+     *           {
+     *             id: "personal",
+     *             icon: EllipseIcon,
+     *             label: "Personal",
+     *           },
+     *         ],
+     *       },
+     *       {
+     *         id: "downloads",
+     *         icon: EllipseIcon,
+     *         label: "Downloads",
+     *       },
+     *     ],
+     *   };
+     *   ```;
+     */
+    items: TreeListItem;
+    /**
+     * The callback function that is called when the primary action is triggered.
+     * If not provided, the primary action will not be shown.
+     */
+    onPrimaryAction?: (key: Key) => void;
+    /**
+     * The callback function that is called when the secondary action is
+     * triggered. If not provided, the secondary action will not be shown.
+     */
+    onSecondaryAction?: (key: Key) => void;
+    /** The icon to use for the primary action. */
+    primaryActionIcon?: ToggleIconButtonProps["icon"] | ((key: Key) => ToggleIconButtonProps["icon"]);
+    /** The icon to use for the secondary action. */
+    secondaryActionIcon?: ToggleIconButtonProps["icon"] | ((key: Key) => ToggleIconButtonProps["icon"]);
+    /** The aria label for the primary action. */
+    primaryActionAriaLabel?: string | ((key: Key) => string);
+    /** The aria label for the secondary action. */
+    secondaryActionAriaLabel?: string | ((key: Key) => string);
+    /**
+     * The position of the actions.
+     *
+     * @default "start"
+     */
+    actionsPosition?: "start" | "end";
+    /**
+     * The callback function that is called when the item is renamed. The rename
+     * functionality is disabled if not provided.
+     */
+    onRename?: (options: {
+        key: Key;
+        value: string;
+    }) => void;
+    /** The callback function that is called when the item is clicked. */
+    onAction?: (key: Key) => void;
+    /**
+     * The callback function that is called to render the item title.
+     *
+     * @default item => item.label
+     */
+    renderItemTitle?: (item: TreeListItem) => ReactNode;
+}

package/dist/components/TreeView/index.d.ts

@@ -0,0 +1,2 @@
+export { TreeView } from "./TreeView";
+export type { TreeViewProps, TreeListItem } from "./TreeView.types";

package/dist/components/UNSAFE_ListBox/ListBox.css.d.ts

@@ -0,0 +1,92 @@
+export declare const resetCn: string;
+export declare const listBoxSectionLiCn: string;
+export declare const listBoxOptionCn: ((options?: {
+    isSelected?: undefined;
+    isFocused?: boolean | undefined;
+    isFirstChild?: boolean | undefined;
+    isLastChild?: boolean | undefined;
+    isHovered?: boolean | undefined;
+    isDisabled?: boolean | undefined;
+} | undefined) => string) & {
+    variants: () => ("isSelected" | "isFocused" | "isHovered" | "isFirstChild" | "isLastChild" | "isDisabled")[];
+    classNames: import("@baseline-ui/css").RecipeClassNames<{
+        isSelected: {};
+        isFocused: {
+            true: {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            };
+        };
+        isFirstChild: {
+            true: {
+                borderTopWidth: number;
+            };
+        };
+        isLastChild: {
+            true: {
+                borderBottomWidth: number;
+            };
+        };
+        isHovered: {
+            true: {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            };
+            false: {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            };
+        };
+        isDisabled: {
+            true: (string | {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            })[];
+        };
+    }>;
+};
+export declare const listBoxCn: string;
+export declare const listBoxHelperTextCn: import("@vanilla-extract/recipes").RuntimeFn<{
+    isDisabled: {
+        true: string;
+    };
+}>;
+export declare const dropIndicatorCn: ((options?: {
+    isDropTarget?: boolean | undefined;
+    orientation?: "horizontal" | "vertical" | undefined;
+} | undefined) => string) & {
+    variants: () => ("isDropTarget" | "orientation")[];
+    classNames: import("@baseline-ui/css").RecipeClassNames<{
+        isDropTarget: {
+            true: {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            };
+        };
+        orientation: {
+            vertical: {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            };
+            horizontal: {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            };
+        };
+    }>;
+};
+export declare const listBoxSectionHeaderCn: string;

package/dist/components/UNSAFE_ListBox/ListBox.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import type { ListItem } from "../shared/types/List";
+import type { CollectionRenderProps, UNSAFE_ListBoxProps as ListBoxProps } from "./ListBox.types";
+import type { PressEvent } from "react-aria-components";
+export declare const ListOptionContext: React.Context<{
+    onPress?: (e: PressEvent, key: string) => void;
+}>;
+export declare const UNSAFE_ListBox: React.ForwardRefExoticComponent<ListBoxProps & React.RefAttributes<HTMLDivElement>>;
+type ListCollectionItemContextValue = {
+    item?: ListItem;
+} & CollectionRenderProps;
+export declare const ListCollectionItem: React.FC<ListCollectionItemContextValue>;
+export {};