@reapit/elements 5.0.0-beta.3 → 5.0.0-beta.30

package/dist/js/components/side-bar/menu-group/styles.d.ts

@@ -0,0 +1,14 @@
+export declare const elSideBarMenuGroup: import('@linaria/core').LinariaClassName;
+export declare const elSideBarMenuGroupSummary: import('@linaria/core').LinariaClassName;
+export declare const ElSideBarMenuGroupSummaryIcon: {
+    __wyw_meta: unknown;
+} & import('react').FunctionComponent<import('react').ClassAttributes<HTMLSpanElement> & import('react').HTMLAttributes<HTMLSpanElement> & Record<never, unknown> & {
+    as?: React.ElementType;
+}>;
+export declare const ElSideBarMenuGroupSummaryLabel: {
+    __wyw_meta: unknown;
+} & import('react').FunctionComponent<import('react').ClassAttributes<HTMLSpanElement> & import('react').HTMLAttributes<HTMLSpanElement> & Record<never, unknown> & {
+    as?: React.ElementType;
+}>;
+export declare const ElSideBarMenuGroupSummaryDropdownIcon: import('@linaria/react').StyledComponent<import('react').ClassAttributes<HTMLSpanElement> & import('react').HTMLAttributes<HTMLSpanElement> & Record<never, unknown>>;
+//# sourceMappingURL=styles.d.ts.map

package/dist/js/components/side-bar/menu-group/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"/","sources":["../../../../../components/side-bar/menu-group/components/side-bar/menu-group/styles.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,kBAAkB,0CAU9B,CAAA;AAGD,eAAO,MAAM,yBAAyB,0CAMrC,CAAA;AAED,eAAO,MAAM,6BAA6B;;;eA0BzB,WAAW;EAtB3B,CAAA;AAED,eAAO,MAAM,8BAA8B;;;eAoB1B,WAAW;EAf3B,CAAA;AAED,eAAO,MAAM,qCAAqC,uKAejD,CAAA"}

package/dist/js/components/side-bar/menu-group/use-menu-group-controller.d.ts

@@ -0,0 +1,8 @@
+import { RefObject } from 'react';
+import { SideBarState } from '../use-side-bar';
+/**
+ * Controls the open state of a `SideBar.MenuGroup` when the `SideBar` is expanded or collapsed or when a descendant
+ * comes to represent, or stops representing, the current page.
+ */
+export declare function useSideBarMenuGroupController(sideBarState: SideBarState): RefObject<HTMLDetailsElement>;
+//# sourceMappingURL=use-menu-group-controller.d.ts.map

package/dist/js/components/side-bar/menu-group/use-menu-group-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-menu-group-controller.d.ts","sourceRoot":"/","sources":["../../../../../components/side-bar/menu-group/components/side-bar/menu-group/use-menu-group-controller.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAEnD;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,YAAY,EAAE,YAAY,GAAG,SAAS,CAAC,kBAAkB,CAAC,CAmCvG"}

package/dist/js/components/side-bar/menu-item/__test__/menu-item.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=menu-item.test.d.ts.map

package/dist/js/components/side-bar/menu-item/__test__/menu-item.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-item.test.d.ts","sourceRoot":"/","sources":["../../../../../../components/side-bar/menu-item/__test__/components/side-bar/menu-item/__test__/menu-item.test.tsx"],"names":[],"mappings":""}

package/dist/js/components/side-bar/menu-item/index.d.ts

@@ -0,0 +1,3 @@
+export * from './styles';
+export * from './menu-item';
+//# sourceMappingURL=index.d.ts.map

package/dist/js/components/side-bar/menu-item/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"/","sources":["../../../../../components/side-bar/menu-item/components/side-bar/menu-item/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA"}

package/dist/js/components/side-bar/menu-item/menu-item.d.ts

@@ -0,0 +1,38 @@
+import { AnchorHTMLAttributes, ReactNode } from 'react';
+type AttributesToOmit = 'aria-current';
+interface SideBarMenuItemProps extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, AttributesToOmit> {
+    /** The label of the menu item */
+    children: ReactNode;
+    /** The URL to navigate to when this item is activated. */
+    href: string;
+    /** The icon to display next to the label. */
+    icon: ReactNode;
+    /**
+     * When the item represents the current page, `isActive` should be supplied to communicate to visual and accessible
+     * users that the item is currently "selected".
+     */
+    isActive?: boolean;
+}
+/**
+ * Standard menu item for use in a `SideBar`. Is always an anchor element because side bar navigation
+ * items should always navigate users to another page in the product.
+ *
+ * **Important:** ⚠️ This component should rarely be used directly. Instead, use `SideBar.MenuItem` as it wraps the
+ * anchor element in a list item (`<li>`) to ensure good semantics and accessibility when used with `SideBar.MenuList`.
+ *
+ * To integrate this component with React Router, simply wrap `SideBar.MenuItem`. For example, with React Router 6,
+ * you would do:
+ *
+ * ```
+ * function MySideBarMenuItem({ to, ...rest}) {
+ *   const href = useHref(to)
+ *   const isActive = useMatch(to)
+ *   return (
+ *     <SideBarMenu.Item {...rest} href={href} isActive={isActive} />
+ *   )
+ * }
+ * ```
+ */
+export declare function SideBarMenuItem({ children, className, icon, isActive, ...rest }: SideBarMenuItemProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=menu-item.d.ts.map

package/dist/js/components/side-bar/menu-item/menu-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-item.d.ts","sourceRoot":"/","sources":["../../../../../components/side-bar/menu-item/components/side-bar/menu-item/menu-item.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAI5D,KAAK,gBAAgB,GAAG,cAAc,CAAA;AAEtC,UAAU,oBAAqB,SAAQ,IAAI,CAAC,oBAAoB,CAAC,iBAAiB,CAAC,EAAE,gBAAgB,CAAC;IACpG,iCAAiC;IACjC,QAAQ,EAAE,SAAS,CAAA;IACnB,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAA;IACZ,6CAA6C;IAC7C,IAAI,EAAE,SAAS,CAAA;IACf;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,EAAE,oBAAoB,2CAOrG"}

package/dist/js/components/side-bar/menu-item/menu-item.stories.d.ts

@@ -0,0 +1,324 @@
+import { SideBarMenuItem } from './menu-item';
+import { StoryObj } from '@storybook/react';
+declare const meta: {
+    title: string;
+    component: typeof SideBarMenuItem;
+    argTypes: {
+        children: {
+            control: string;
+        };
+        icon: {
+            control: string;
+            options: string[];
+            mapping: {
+                Property: import("react/jsx-runtime").JSX.Element;
+                Dashboard: import("react/jsx-runtime").JSX.Element;
+                Settings: import("react/jsx-runtime").JSX.Element;
+                User: import("react/jsx-runtime").JSX.Element;
+            };
+        };
+    };
+    decorators: import('@storybook/react').Decorator[];
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Example: Story;
+/**
+ * When the item represents the current page, `isActive` should be supplied to communicate to visual and accessible
+ * users that the item is currently "selected". For accessible users, this internally facilitated via
+ * `aria-current="page"` on the underlying `<a>` element. The visual styling of the item is also applied based on
+ * this ARIA attribute, so CSS-only consumers just need to ensure they provide `aria-current="page"` to their anchor
+ * when appropriate.
+ */
+export declare const Selected: {
+    args: {
+        isActive: boolean;
+        children: import('react').ReactNode;
+        href: string;
+        icon: import('react').ReactNode;
+        slot?: string | undefined;
+        style?: import('react').CSSProperties | undefined;
+        title?: string | undefined;
+        property?: string | undefined;
+        className?: string | undefined;
+        defaultChecked?: boolean | undefined;
+        defaultValue?: string | number | readonly string[] | undefined;
+        suppressContentEditableWarning?: boolean | undefined;
+        suppressHydrationWarning?: boolean | undefined;
+        accessKey?: string | undefined;
+        autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {});
+        autoFocus?: boolean | undefined;
+        contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only" | undefined;
+        contextMenu?: string | undefined;
+        dir?: string | undefined;
+        draggable?: (boolean | "true" | "false") | undefined;
+        enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined;
+        hidden?: boolean | undefined;
+        id?: string | undefined;
+        lang?: string | undefined;
+        nonce?: string | undefined;
+        spellCheck?: (boolean | "true" | "false") | undefined;
+        tabIndex?: number | undefined;
+        translate?: "yes" | "no" | undefined;
+        radioGroup?: string | undefined;
+        role?: import('react').AriaRole | undefined;
+        about?: string | undefined;
+        content?: string | undefined;
+        datatype?: string | undefined;
+        inlist?: any;
+        prefix?: string | undefined;
+        rel?: string | undefined;
+        resource?: string | undefined;
+        rev?: string | undefined;
+        typeof?: string | undefined;
+        vocab?: string | undefined;
+        autoCorrect?: string | undefined;
+        autoSave?: string | undefined;
+        color?: string | undefined;
+        itemProp?: string | undefined;
+        itemScope?: boolean | undefined;
+        itemType?: string | undefined;
+        itemID?: string | undefined;
+        itemRef?: string | undefined;
+        results?: number | undefined;
+        security?: string | undefined;
+        unselectable?: "on" | "off" | undefined;
+        inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
+        is?: string | undefined;
+        "aria-activedescendant"?: string | undefined;
+        "aria-atomic"?: (boolean | "true" | "false") | undefined;
+        "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined;
+        "aria-braillelabel"?: string | undefined;
+        "aria-brailleroledescription"?: string | undefined;
+        "aria-busy"?: (boolean | "true" | "false") | undefined;
+        "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined;
+        "aria-colcount"?: number | undefined;
+        "aria-colindex"?: number | undefined;
+        "aria-colindextext"?: string | undefined;
+        "aria-colspan"?: number | undefined;
+        "aria-controls"?: string | undefined;
+        "aria-describedby"?: string | undefined;
+        "aria-description"?: string | undefined;
+        "aria-details"?: string | undefined;
+        "aria-disabled"?: (boolean | "true" | "false") | undefined;
+        "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined;
+        "aria-errormessage"?: string | undefined;
+        "aria-expanded"?: (boolean | "true" | "false") | undefined;
+        "aria-flowto"?: string | undefined;
+        "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+        "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined;
+        "aria-hidden"?: (boolean | "true" | "false") | undefined;
+        "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined;
+        "aria-keyshortcuts"?: string | undefined;
+        "aria-label"?: string | undefined;
+        "aria-labelledby"?: string | undefined;
+        "aria-level"?: number | undefined;
+        "aria-live"?: "off" | "assertive" | "polite" | undefined;
+        "aria-modal"?: (boolean | "true" | "false") | undefined;
+        "aria-multiline"?: (boolean | "true" | "false") | undefined;
+        "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+        "aria-orientation"?: "horizontal" | "vertical" | undefined;
+        "aria-owns"?: string | undefined;
+        "aria-placeholder"?: string | undefined;
+        "aria-posinset"?: number | undefined;
+        "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined;
+        "aria-readonly"?: (boolean | "true" | "false") | undefined;
+        "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined;
+        "aria-required"?: (boolean | "true" | "false") | undefined;
+        "aria-roledescription"?: string | undefined;
+        "aria-rowcount"?: number | undefined;
+        "aria-rowindex"?: number | undefined;
+        "aria-rowindextext"?: string | undefined;
+        "aria-rowspan"?: number | undefined;
+        "aria-selected"?: (boolean | "true" | "false") | undefined;
+        "aria-setsize"?: number | undefined;
+        "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
+        "aria-valuemax"?: number | undefined;
+        "aria-valuemin"?: number | undefined;
+        "aria-valuenow"?: number | undefined;
+        "aria-valuetext"?: string | undefined;
+        dangerouslySetInnerHTML?: {
+            __html: string | TrustedHTML;
+        } | undefined;
+        onCopy?: import('react').ClipboardEventHandler<HTMLAnchorElement> | undefined;
+        onCopyCapture?: import('react').ClipboardEventHandler<HTMLAnchorElement> | undefined;
+        onCut?: import('react').ClipboardEventHandler<HTMLAnchorElement> | undefined;
+        onCutCapture?: import('react').ClipboardEventHandler<HTMLAnchorElement> | undefined;
+        onPaste?: import('react').ClipboardEventHandler<HTMLAnchorElement> | undefined;
+        onPasteCapture?: import('react').ClipboardEventHandler<HTMLAnchorElement> | undefined;
+        onCompositionEnd?: import('react').CompositionEventHandler<HTMLAnchorElement> | undefined;
+        onCompositionEndCapture?: import('react').CompositionEventHandler<HTMLAnchorElement> | undefined;
+        onCompositionStart?: import('react').CompositionEventHandler<HTMLAnchorElement> | undefined;
+        onCompositionStartCapture?: import('react').CompositionEventHandler<HTMLAnchorElement> | undefined;
+        onCompositionUpdate?: import('react').CompositionEventHandler<HTMLAnchorElement> | undefined;
+        onCompositionUpdateCapture?: import('react').CompositionEventHandler<HTMLAnchorElement> | undefined;
+        onFocus?: import('react').FocusEventHandler<HTMLAnchorElement> | undefined;
+        onFocusCapture?: import('react').FocusEventHandler<HTMLAnchorElement> | undefined;
+        onBlur?: import('react').FocusEventHandler<HTMLAnchorElement> | undefined;
+        onBlurCapture?: import('react').FocusEventHandler<HTMLAnchorElement> | undefined;
+        onChange?: import('react').FormEventHandler<HTMLAnchorElement> | undefined;
+        onChangeCapture?: import('react').FormEventHandler<HTMLAnchorElement> | undefined;
+        onBeforeInput?: import('react').FormEventHandler<HTMLAnchorElement> | undefined;
+        onBeforeInputCapture?: import('react').FormEventHandler<HTMLAnchorElement> | undefined;
+        onInput?: import('react').FormEventHandler<HTMLAnchorElement> | undefined;
+        onInputCapture?: import('react').FormEventHandler<HTMLAnchorElement> | undefined;
+        onReset?: import('react').FormEventHandler<HTMLAnchorElement> | undefined;
+        onResetCapture?: import('react').FormEventHandler<HTMLAnchorElement> | undefined;
+        onSubmit?: import('react').FormEventHandler<HTMLAnchorElement> | undefined;
+        onSubmitCapture?: import('react').FormEventHandler<HTMLAnchorElement> | undefined;
+        onInvalid?: import('react').FormEventHandler<HTMLAnchorElement> | undefined;
+        onInvalidCapture?: import('react').FormEventHandler<HTMLAnchorElement> | undefined;
+        onLoad?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onLoadCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onError?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onErrorCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onKeyDown?: import('react').KeyboardEventHandler<HTMLAnchorElement> | undefined;
+        onKeyDownCapture?: import('react').KeyboardEventHandler<HTMLAnchorElement> | undefined;
+        onKeyPress?: import('react').KeyboardEventHandler<HTMLAnchorElement> | undefined;
+        onKeyPressCapture?: import('react').KeyboardEventHandler<HTMLAnchorElement> | undefined;
+        onKeyUp?: import('react').KeyboardEventHandler<HTMLAnchorElement> | undefined;
+        onKeyUpCapture?: import('react').KeyboardEventHandler<HTMLAnchorElement> | undefined;
+        onAbort?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onAbortCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onCanPlay?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onCanPlayCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onCanPlayThrough?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onCanPlayThroughCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onDurationChange?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onDurationChangeCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onEmptied?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onEmptiedCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onEncrypted?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onEncryptedCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onEnded?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onEndedCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onLoadedData?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onLoadedDataCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onLoadedMetadata?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onLoadedMetadataCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onLoadStart?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onLoadStartCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onPause?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onPauseCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onPlay?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onPlayCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onPlaying?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onPlayingCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onProgress?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onProgressCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onRateChange?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onRateChangeCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onResize?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onResizeCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onSeeked?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onSeekedCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onSeeking?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onSeekingCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onStalled?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onStalledCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onSuspend?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onSuspendCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onTimeUpdate?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onTimeUpdateCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onVolumeChange?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onVolumeChangeCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onWaiting?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onWaitingCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onAuxClick?: import('react').MouseEventHandler<HTMLAnchorElement> | undefined;
+        onAuxClickCapture?: import('react').MouseEventHandler<HTMLAnchorElement> | undefined;
+        onClick?: import('react').MouseEventHandler<HTMLAnchorElement> | undefined;
+        onClickCapture?: import('react').MouseEventHandler<HTMLAnchorElement> | undefined;
+        onContextMenu?: import('react').MouseEventHandler<HTMLAnchorElement> | undefined;
+        onContextMenuCapture?: import('react').MouseEventHandler<HTMLAnchorElement> | undefined;
+        onDoubleClick?: import('react').MouseEventHandler<HTMLAnchorElement> | undefined;
+        onDoubleClickCapture?: import('react').MouseEventHandler<HTMLAnchorElement> | undefined;
+        onDrag?: import('react').DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragCapture?: import('react').DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragEnd?: import('react').DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragEndCapture?: import('react').DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragEnter?: import('react').DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragEnterCapture?: import('react').DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragExit?: import('react').DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragExitCapture?: import('react').DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragLeave?: import('react').DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragLeaveCapture?: import('react').DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragOver?: import('react').DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragOverCapture?: import('react').DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragStart?: import('react').DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragStartCapture?: import('react').DragEventHandler<HTMLAnchorElement> | undefined;
+        onDrop?: import('react').DragEventHandler<HTMLAnchorElement> | undefined;
+        onDropCapture?: import('react').DragEventHandler<HTMLAnchorElement> | undefined;
+        onMouseDown?: import('react').MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseDownCapture?: import('react').MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseEnter?: import('react').MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseLeave?: import('react').MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseMove?: import('react').MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseMoveCapture?: import('react').MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseOut?: import('react').MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseOutCapture?: import('react').MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseOver?: import('react').MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseOverCapture?: import('react').MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseUp?: import('react').MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseUpCapture?: import('react').MouseEventHandler<HTMLAnchorElement> | undefined;
+        onSelect?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onSelectCapture?: import('react').ReactEventHandler<HTMLAnchorElement> | undefined;
+        onTouchCancel?: import('react').TouchEventHandler<HTMLAnchorElement> | undefined;
+        onTouchCancelCapture?: import('react').TouchEventHandler<HTMLAnchorElement> | undefined;
+        onTouchEnd?: import('react').TouchEventHandler<HTMLAnchorElement> | undefined;
+        onTouchEndCapture?: import('react').TouchEventHandler<HTMLAnchorElement> | undefined;
+        onTouchMove?: import('react').TouchEventHandler<HTMLAnchorElement> | undefined;
+        onTouchMoveCapture?: import('react').TouchEventHandler<HTMLAnchorElement> | undefined;
+        onTouchStart?: import('react').TouchEventHandler<HTMLAnchorElement> | undefined;
+        onTouchStartCapture?: import('react').TouchEventHandler<HTMLAnchorElement> | undefined;
+        onPointerDown?: import('react').PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerDownCapture?: import('react').PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerMove?: import('react').PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerMoveCapture?: import('react').PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerUp?: import('react').PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerUpCapture?: import('react').PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerCancel?: import('react').PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerCancelCapture?: import('react').PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerEnter?: import('react').PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerLeave?: import('react').PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerOver?: import('react').PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerOverCapture?: import('react').PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerOut?: import('react').PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerOutCapture?: import('react').PointerEventHandler<HTMLAnchorElement> | undefined;
+        onGotPointerCapture?: import('react').PointerEventHandler<HTMLAnchorElement> | undefined;
+        onGotPointerCaptureCapture?: import('react').PointerEventHandler<HTMLAnchorElement> | undefined;
+        onLostPointerCapture?: import('react').PointerEventHandler<HTMLAnchorElement> | undefined;
+        onLostPointerCaptureCapture?: import('react').PointerEventHandler<HTMLAnchorElement> | undefined;
+        onScroll?: import('react').UIEventHandler<HTMLAnchorElement> | undefined;
+        onScrollCapture?: import('react').UIEventHandler<HTMLAnchorElement> | undefined;
+        onWheel?: import('react').WheelEventHandler<HTMLAnchorElement> | undefined;
+        onWheelCapture?: import('react').WheelEventHandler<HTMLAnchorElement> | undefined;
+        onAnimationStart?: import('react').AnimationEventHandler<HTMLAnchorElement> | undefined;
+        onAnimationStartCapture?: import('react').AnimationEventHandler<HTMLAnchorElement> | undefined;
+        onAnimationEnd?: import('react').AnimationEventHandler<HTMLAnchorElement> | undefined;
+        onAnimationEndCapture?: import('react').AnimationEventHandler<HTMLAnchorElement> | undefined;
+        onAnimationIteration?: import('react').AnimationEventHandler<HTMLAnchorElement> | undefined;
+        onAnimationIterationCapture?: import('react').AnimationEventHandler<HTMLAnchorElement> | undefined;
+        onTransitionEnd?: import('react').TransitionEventHandler<HTMLAnchorElement> | undefined;
+        onTransitionEndCapture?: import('react').TransitionEventHandler<HTMLAnchorElement> | undefined;
+        type?: string | undefined;
+        target?: import('react').HTMLAttributeAnchorTarget | undefined;
+        download?: any;
+        hrefLang?: string | undefined;
+        media?: string | undefined;
+        ping?: string | undefined;
+        referrerPolicy?: import('react').HTMLAttributeReferrerPolicy | undefined;
+    };
+};
+/**
+ * When there is not enough space to display the full label, it will be truncated with an ellipsis. That said,
+ * author's should typically ensure menu item labels are short enough to fit within the available space in the
+ * `SideBar`. Importantly, when the `SideBar` is collapsed, the menu item's label will be available in the
+ * accessibility tree despite not being fully visible.
+ */
+export declare const Truncation: Story;
+/**
+ * When the `SideBar` is collapsed, the menu item's label will be completely hidden. Again though, while the label
+ * is not visible, it is still available in the accessibility tree.
+ */
+export declare const Collapsed: Story;
+//# sourceMappingURL=menu-item.stories.d.ts.map

package/dist/js/components/side-bar/menu-item/menu-item.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-item.stories.d.ts","sourceRoot":"/","sources":["../../../../../components/side-bar/menu-item/components/side-bar/menu-item/menu-item.stories.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAI7C,OAAO,KAAK,EAAQ,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEtD,QAAA,MAAM,IAAI;;;;;;;;;;;;;;;;;;;CAmB8B,CAAA;AAExC,eAAe,IAAI,CAAA;AAEnB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,IAAI,CAAC,CAAA;AAElC,eAAO,MAAM,OAAO,EAAE,KAOrB,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKpB,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,KAQxB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAE,KAQvB,CAAA"}

package/dist/js/components/side-bar/menu-item/styles.d.ts

@@ -0,0 +1,4 @@
+export declare const elSideBarMenuItem: import('@linaria/core').LinariaClassName;
+export declare const ElSideBarMenuItemLabel: import('@linaria/react').StyledComponent<import('react').ClassAttributes<HTMLSpanElement> & import('react').HTMLAttributes<HTMLSpanElement> & Record<never, unknown>>;
+export declare const ElSideBarMenuItemIcon: import('@linaria/react').StyledComponent<import('react').ClassAttributes<HTMLSpanElement> & import('react').HTMLAttributes<HTMLSpanElement> & Record<never, unknown>>;
+//# sourceMappingURL=styles.d.ts.map

package/dist/js/components/side-bar/menu-item/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"/","sources":["../../../../../components/side-bar/menu-item/components/side-bar/menu-item/styles.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,iBAAiB,0CAsB7B,CAAA;AAED,eAAO,MAAM,sBAAsB,uKAsBlC,CAAA;AAED,eAAO,MAAM,qBAAqB,uKAmBjC,CAAA"}

package/dist/js/components/side-bar/menu-list/__test__/menu-list-group.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=menu-list-group.test.d.ts.map

package/dist/js/components/side-bar/menu-list/__test__/menu-list-group.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-list-group.test.d.ts","sourceRoot":"/","sources":["../../../../../../components/side-bar/menu-list/__test__/components/side-bar/menu-list/__test__/menu-list-group.test.tsx"],"names":[],"mappings":""}

package/dist/js/components/side-bar/menu-list/__test__/menu-list-item.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=menu-list-item.test.d.ts.map

package/dist/js/components/side-bar/menu-list/__test__/menu-list-item.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-list-item.test.d.ts","sourceRoot":"/","sources":["../../../../../../components/side-bar/menu-list/__test__/components/side-bar/menu-list/__test__/menu-list-item.test.tsx"],"names":[],"mappings":""}

package/dist/js/components/side-bar/menu-list/__test__/menu-list.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=menu-list.test.d.ts.map

package/dist/js/components/side-bar/menu-list/__test__/menu-list.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-list.test.d.ts","sourceRoot":"/","sources":["../../../../../../components/side-bar/menu-list/__test__/components/side-bar/menu-list/__test__/menu-list.test.tsx"],"names":[],"mappings":""}

package/dist/js/components/side-bar/menu-list/index.d.ts

@@ -0,0 +1,3 @@
+export * from './styles';
+export * from './menu-list';
+//# sourceMappingURL=index.d.ts.map

package/dist/js/components/side-bar/menu-list/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"/","sources":["../../../../../components/side-bar/menu-list/components/side-bar/menu-list/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA"}

package/dist/js/components/side-bar/menu-list/menu-list-group.d.ts

@@ -0,0 +1,16 @@
+import { SideBarMenuGroup } from '../menu-group';
+import { ComponentProps } from 'react';
+interface SideBarMenuListGroupProps extends ComponentProps<typeof SideBarMenuGroup> {
+}
+/**
+ * A thin wrapper around `SideBarMenuGroup` that ensures it is contained within a list item (`<li>`) for
+ * correct semantics and accessibility when used with `SideBar.MenuList`.
+ *
+ * All props are passed through to `SideBarMenuGroup`.
+ */
+export declare function SideBarMenuListGroup({ children, ...props }: SideBarMenuListGroupProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace SideBarMenuListGroup {
+    var Summary: typeof import("..").SideBarMenuGroupSummary;
+}
+export {};
+//# sourceMappingURL=menu-list-group.d.ts.map

package/dist/js/components/side-bar/menu-list/menu-list-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-list-group.d.ts","sourceRoot":"/","sources":["../../../../../components/side-bar/menu-list/components/side-bar/menu-list/menu-list-group.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAGhD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAA;AAE3C,UAAU,yBAA0B,SAAQ,cAAc,CAAC,OAAO,gBAAgB,CAAC;CAAG;AAEtF;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,QAAQ,EAAE,GAAG,KAAK,EAAE,EAAE,yBAAyB,2CAMrF;yBANe,oBAAoB"}

package/dist/js/components/side-bar/menu-list/menu-list-item.d.ts

@@ -0,0 +1,13 @@
+import { SideBarMenuItem as BaseSideBarMenuItem } from '../menu-item';
+import { ComponentProps } from 'react';
+interface SideBarMenuListItemProps extends ComponentProps<typeof BaseSideBarMenuItem> {
+}
+/**
+ * A thin wrapper around `SideBarMenuItem` that ensures it is contained within a list item (`<li>`) for
+ * correct semantics and accessibility when used with `SideBar.MenuList`.
+ *
+ * All props are passed through to `SideBarMenuItem`.
+ */
+export declare function SideBarMenuListItem({ children, ...props }: SideBarMenuListItemProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=menu-list-item.d.ts.map

package/dist/js/components/side-bar/menu-list/menu-list-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-list-item.d.ts","sourceRoot":"/","sources":["../../../../../components/side-bar/menu-list/components/side-bar/menu-list/menu-list-item.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,IAAI,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAGrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAA;AAE3C,UAAU,wBAAyB,SAAQ,cAAc,CAAC,OAAO,mBAAmB,CAAC;CAAG;AAExF;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,QAAQ,EAAE,GAAG,KAAK,EAAE,EAAE,wBAAwB,2CAMnF"}

package/dist/js/components/side-bar/menu-list/menu-list.d.ts

@@ -0,0 +1,21 @@
+import { ElSideBarMenuList } from './styles';
+import { SideBarMenuListItem } from './menu-list-item';
+import { SideBarMenuListGroup } from './menu-list-group';
+import { ComponentProps } from 'react';
+import { SideBarSubmenu } from '../submenu';
+interface SideBarMenuListProps extends ComponentProps<typeof ElSideBarMenuList> {
+}
+/**
+ * Main menu list for the `SideBar`. Typically provided a collection of `SideBar.MenuItem` and `SideBar.MenuGroup`
+ * components as children.
+ */
+export declare function SideBarMenuList({ children, ...rest }: SideBarMenuListProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace SideBarMenuList {
+    var Item: typeof SideBarMenuListItem;
+    var Group: typeof SideBarMenuListGroup;
+    var GroupSummary: typeof import("..").SideBarMenuGroupSummary;
+    var Submenu: typeof SideBarSubmenu;
+    var SubmenuItem: typeof import("../submenu/submenu-list-item").SideBarSubmenuListItem;
+}
+export {};
+//# sourceMappingURL=menu-list.d.ts.map

package/dist/js/components/side-bar/menu-list/menu-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-list.d.ts","sourceRoot":"/","sources":["../../../../../components/side-bar/menu-list/components/side-bar/menu-list/menu-list.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAA;AAExD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAA;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAE3C,UAAU,oBAAqB,SAAQ,cAAc,CAAC,OAAO,iBAAiB,CAAC;CAAG;AAElF;;;GAGG;AACH,wBAAgB,eAAe,CAAC,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,EAAE,oBAAoB,2CAE1E;yBAFe,eAAe"}

package/dist/js/components/side-bar/menu-list/menu-list.stories.d.ts

@@ -0,0 +1,44 @@
+import { SideBarMenuList } from './menu-list';
+import { StoryObj } from '@storybook/react';
+declare const meta: {
+    title: string;
+    component: typeof SideBarMenuList;
+    argTypes: {
+        children: {
+            control: string;
+            options: string[];
+            mapping: {
+                'No selected item': import("react/jsx-runtime").JSX.Element[];
+                'Selected item': import("react/jsx-runtime").JSX.Element[];
+                'Selected submenu item': import("react/jsx-runtime").JSX.Element[];
+            };
+        };
+    };
+    decorators: import('@storybook/react').Decorator[];
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Example: Story;
+/**
+ * If a menu item represents the current page, it should be marked as "selected". See the `SideBar.MenuItem`
+ * documentation for details on how.
+ */
+export declare const SelectedItem: Story;
+/**
+ * Likewise, if a submenu item represents the current page, it should be marked as "selected". This will
+ * automatically cause the parent `SideBar.MenuGroup` to be displayed as "selected" itself. See the
+ * `SideBar.SubmenuItem` documentation for details on how.
+ */
+export declare const SelectedSubmenuItem: Story;
+/**
+ * The menu list simply fills it parent container. If that parent does not have enough space for the labels
+ * of some or all of the submenu items, those labels will truncate as per the behaviour documented for each
+ * individual component. That said, authors (both designers and engineers) should typically ensure the side bar
+ * is afforded enough space for the menu items it contains.
+ */
+export declare const Truncation: Story;
+/**
+ * When the side bar is collapsed, only the menu item's icons will be visible.
+ */
+export declare const Collapsed: Story;
+//# sourceMappingURL=menu-list.stories.d.ts.map

package/dist/js/components/side-bar/menu-list/menu-list.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-list.stories.d.ts","sourceRoot":"/","sources":["../../../../../components/side-bar/menu-list/components/side-bar/menu-list/menu-list.stories.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAI7C,OAAO,KAAK,EAAQ,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAKtD,QAAA,MAAM,IAAI;;;;;;;;;;;;;;;CAe8B,CAAA;AAExC,eAAe,IAAI,CAAA;AAEnB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,IAAI,CAAC,CAAA;AAElC,eAAO,MAAM,OAAO,EAAE,KAIrB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,KAI1B,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,KAIjC,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,KAUxB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,KAUvB,CAAA"}

package/dist/js/components/side-bar/menu-list/styles.d.ts

@@ -0,0 +1,3 @@
+export declare const ElSideBarMenuList: import('@linaria/react').StyledComponent<import('react').ClassAttributes<HTMLUListElement> & import('react').HTMLAttributes<HTMLUListElement> & Record<never, unknown>>;
+export declare const ElSideBarMenuListItem: import('@linaria/react').StyledComponent<import('react').ClassAttributes<HTMLLIElement> & import('react').LiHTMLAttributes<HTMLLIElement> & Record<never, unknown>>;
+//# sourceMappingURL=styles.d.ts.map

package/dist/js/components/side-bar/menu-list/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"/","sources":["../../../../../components/side-bar/menu-list/components/side-bar/menu-list/styles.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB,yKAY7B,CAAA;AAED,eAAO,MAAM,qBAAqB,qKAEjC,CAAA"}

package/dist/js/components/side-bar/side-bar-context.d.ts

@@ -0,0 +1,12 @@
+import { UseSideBarResult } from './use-side-bar';
+interface SideBarContextValue extends UseSideBarResult {
+    id: string;
+}
+export declare const SideBarContext: import('react').Context<SideBarContextValue | undefined>;
+interface SideBarContextPublisherProps extends SideBarContextValue {
+    children: React.ReactNode;
+}
+export declare function SideBarContextPublisher(props: SideBarContextPublisherProps): import("react/jsx-runtime").JSX.Element;
+export declare function useSideBarContext(): SideBarContextValue;
+export {};
+//# sourceMappingURL=side-bar-context.d.ts.map

package/dist/js/components/side-bar/side-bar-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"side-bar-context.d.ts","sourceRoot":"/","sources":["../../../../components/side-bar/components/side-bar/side-bar-context.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAEtD,UAAU,mBAAoB,SAAQ,gBAAgB;IACpD,EAAE,EAAE,MAAM,CAAA;CACX;AAED,eAAO,MAAM,cAAc,0DAA4D,CAAA;AAEvF,UAAU,4BAA6B,SAAQ,mBAAmB;IAChE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAC1B;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,4BAA4B,2CAQ1E;AAED,wBAAgB,iBAAiB,IAAI,mBAAmB,CAMvD"}