@react-hive/honey-layout 5.2.0-beta → 5.6.0-beta

package/dist/__mocks__/index.d.ts

@@ -0,0 +1 @@
+export * from './theme-mock';

package/dist/__mocks__/theme-mock.d.ts

@@ -0,0 +1,2 @@
+import { HoneyTheme } from '../types';
+export declare const themeMock: HoneyTheme;

package/dist/components/HoneyBox/HoneyBox.d.ts

@@ -0,0 +1,8 @@
+import { DataAttributes } from 'styled-components';
+import { ComponentPropsWithRef, ElementType } from 'react';
+import { HoneyPrefixedCSSProperties, HoneyEffectResultFn } from '../../types';
+export type HoneyBoxProps<Element extends ElementType = 'div'> = DataAttributes & ComponentPropsWithRef<Element> & HoneyPrefixedCSSProperties & {
+    as?: Element;
+    effects?: HoneyEffectResultFn<object>[];
+};
+export declare const HoneyBox: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, HoneyBoxProps<"div">>, never>> & string;

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

@@ -0,0 +1 @@
+export * from './HoneyBox';

package/dist/components/HoneyContextMenu/HoneyContextMenu.d.ts

@@ -2,7 +2,8 @@ import { ReactNode } from 'react';
 import { HoneyPopupProps, HoneyPopupChildrenContextProps } from '../HoneyPopup';
 import { HoneyContextMenuOption } from './HoneyContextMenu.types';
 import { HoneyContextMenuContentProps } from './HoneyContextMenuContent';
-export interface HoneyContextMenuProps<Option extends HoneyContextMenuOption<Context>, Context = undefined> extends Pick<HoneyPopupProps<Context>, 'context'>, HoneyContextMenuContentProps<Option, Context> {
+export interface HoneyContextMenuProps<Option extends HoneyContextMenuOption<Context>, Context = undefined, UseAutoSize extends boolean = boolean> extends Omit<HoneyPopupProps<Context, UseAutoSize>, 'content'>, Pick<HoneyContextMenuContentProps<Option, Context>, 'options' | 'optionProps'> {
     children: (context: HoneyPopupChildrenContextProps) => ReactNode;
+    subProps?: Omit<HoneyContextMenuContentProps<Option, Context>, 'options' | 'optionProps'>;
 }
-export declare const HoneyContextMenu: <Option extends HoneyContextMenuOption<Context>, Context = undefined>({ children, options, optionProps, context, }: HoneyContextMenuProps<Option, Context>) => import("react/jsx-runtime").JSX.Element;
+export declare const HoneyContextMenu: <Option extends HoneyContextMenuOption<Context>, Context = undefined, UseAutoSize extends boolean = boolean>({ children, subProps, options, optionProps, clickOptions, context, ...popupProps }: HoneyContextMenuProps<Option, Context, UseAutoSize>) => import("react/jsx-runtime").JSX.Element;

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

@@ -5,7 +5,7 @@ export interface HoneyContextMenuOption<Context = undefined> {
     id: string;
     label: string;
     options?: HoneyContextMenuOption<Context>[];
-    isVisible?: boolean | ((executionContext: HoneyContextMenuOptionExecutionContext<Context>) => boolean);
+    visible?: boolean | ((executionContext: HoneyContextMenuOptionExecutionContext<Context>) => boolean);
     onClick?: (executionContext: HoneyContextMenuOptionExecutionContext<Context>) => void;
 }
 export {};

package/dist/components/HoneyContextMenu/HoneyContextMenuContent.d.ts

@@ -1,7 +1,8 @@
+import { HoneyPopupProps } from '../HoneyPopup';
 import { HoneyContextMenuOption } from './HoneyContextMenu.types';
 import { HoneyContextMenuContentOptionProps } from './HoneyContextMenuContentOption';
-export interface HoneyContextMenuContentProps<Option extends HoneyContextMenuOption<Context>, Context> {
+export interface HoneyContextMenuContentProps<Option extends HoneyContextMenuOption<Context>, Context> extends Omit<HoneyPopupProps<Context>, 'children' | 'context' | 'content'> {
     options: Option[] | undefined;
     optionProps?: Omit<HoneyContextMenuContentOptionProps<Option, Context>, 'option'>;
 }
-export declare const HoneyContextMenuContent: <Option extends HoneyContextMenuOption<Context>, Context = undefined>({ options, optionProps, }: HoneyContextMenuContentProps<Option, Context>) => import("react/jsx-runtime").JSX.Element;
+export declare const HoneyContextMenuContent: <Option extends HoneyContextMenuOption<Context>, Context = undefined>({ options, optionProps, floatingOptions, ...popupProps }: HoneyContextMenuContentProps<Option, Context>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/HoneyContextMenu/HoneyContextMenuContentOption.d.ts

@@ -1,7 +1,6 @@
-import { HTMLAttributes } from 'react';
 import { HoneyBoxProps } from '../HoneyBox';
 import { HoneyContextMenuOption } from './HoneyContextMenu.types';
-export interface HoneyContextMenuContentOptionProps<Option extends HoneyContextMenuOption<Context>, Context> extends HTMLAttributes<HTMLDivElement>, HoneyBoxProps {
+export interface HoneyContextMenuContentOptionProps<Option extends HoneyContextMenuOption<Context>, Context> extends HoneyBoxProps {
     option: Option;
 }
-export declare const HoneyContextMenuContentOption: <Option extends HoneyContextMenuOption<Context>, Context = undefined>({ option, ...props }: HoneyContextMenuContentOptionProps<Option, Context>) => import("react/jsx-runtime").JSX.Element;
+export declare const HoneyContextMenuContentOption: <Option extends HoneyContextMenuOption<Context>, Context>({ option, ...props }: HoneyContextMenuContentOptionProps<Option, Context>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/HoneyFlexBox.d.ts

@@ -1,3 +1,4 @@
+import { ElementType } from 'react';
 import { HoneyBoxProps } from './HoneyBox';
-export type HoneyFlexBoxProps = HoneyBoxProps;
-export declare const HoneyFlexBox: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').HTMLAttributes<HTMLDivElement> | keyof HoneyBoxProps> & import('react').HTMLAttributes<HTMLDivElement> & HoneyBoxProps, import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').HTMLAttributes<HTMLDivElement> | keyof HoneyBoxProps> & import('react').HTMLAttributes<HTMLDivElement> & HoneyBoxProps>, never>, HoneyBoxProps>> & string;
+export type HoneyFlexBoxProps<Element extends ElementType = 'div'> = HoneyBoxProps<Element>;
+export declare const HoneyFlexBox: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, HoneyBoxProps<"div">>, never>, import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, HoneyBoxProps<"div">>, never>>, HoneyFlexBoxProps<"div">>, never>> & string;

package/dist/components/HoneyGrid/HoneyGrid.d.ts

@@ -1,4 +1,3 @@
-import { default as React } from 'react';
 import { HoneyGridStyledProps } from './HoneyGridStyled';
 import { HoneyGridColumnStyledProps } from '../HoneyGridColumn';
 export interface HoneyGridProps extends HoneyGridStyledProps {
@@ -20,6 +19,4 @@ export interface HoneyGridProps extends HoneyGridStyledProps {
      */
     applyColumnMaxWidth?: HoneyGridColumnStyledProps['applyMaxWidth'];
 }
-export declare const HoneyGrid: React.ForwardRefExoticComponent<HoneyGridProps & {
-    children?: React.ReactNode | undefined;
-} & React.RefAttributes<HTMLDivElement>>;
+export declare const HoneyGrid: ({ ref, children, columns, spacing, isColumnGrowing, applyColumnMaxWidth, ...props }: HoneyGridProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/HoneyGrid/HoneyGridStyled.d.ts

@@ -1,7 +1,6 @@
-import { HTMLAttributes } from 'react';
 import { HoneyBoxProps } from '../HoneyBox';
 import * as CSS from 'csstype';
-export interface HoneyGridStyledProps extends HTMLAttributes<HTMLDivElement>, Omit<HoneyBoxProps, '$gap'> {
+export interface HoneyGridStyledProps extends Omit<HoneyBoxProps, '$gap'> {
     /**
      * The height of each grid column.
      */
@@ -17,4 +16,4 @@ export interface HoneyGridStyledProps extends HTMLAttributes<HTMLDivElement>, Om
      */
     spacing?: number;
 }
-export declare const HoneyGridStyled: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof HTMLAttributes<HTMLDivElement> | keyof HoneyBoxProps> & HTMLAttributes<HTMLDivElement> & HoneyBoxProps, import('styled-components').FastOmit<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof HTMLAttributes<HTMLDivElement> | keyof HoneyBoxProps> & HTMLAttributes<HTMLDivElement> & HoneyBoxProps>, never>, HoneyGridStyledProps>> & string;
+export declare const HoneyGridStyled: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, HoneyBoxProps<"div">>, never>, import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, HoneyBoxProps<"div">>, never>>, HoneyGridStyledProps>, never>> & string;

package/dist/components/HoneyGridColumn/HoneyGridColumn.d.ts

@@ -1,3 +1,3 @@
-import { PropsWithChildren } from 'react';
+import { ElementType } from 'react';
 import { HoneyGridColumnProps } from './HoneyGridColumn.types';
-export declare const HoneyGridColumn: ({ children, ...props }: PropsWithChildren<HoneyGridColumnProps>) => import("react/jsx-runtime").JSX.Element;
+export declare const HoneyGridColumn: <Element extends ElementType = "div">({ children, ...props }: Omit<HoneyGridColumnProps<Element>, "$flexGrow">) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,2 +1,3 @@
+import { ElementType } from 'react';
 import { HoneyGridColumnStyledProps } from './HoneyGridColumnStyled';
-export type HoneyGridColumnProps = Omit<HoneyGridColumnStyledProps, 'columns' | 'spacing' | 'totalColumns' | 'totalTakeColumns' | 'applyMaxWidth'>;
+export type HoneyGridColumnProps<Element extends ElementType = 'div'> = Omit<HoneyGridColumnStyledProps<Element>, 'columns' | 'spacing' | 'totalColumns' | 'totalTakeColumns' | 'applyMaxWidth'>;

package/dist/components/HoneyGridColumn/HoneyGridColumnStyled.d.ts

@@ -1,7 +1,7 @@
-import { HTMLAttributes } from 'react';
+import { ElementType } from 'react';
 import { HoneyBreakpointName } from '../../types';
 import { HoneyBoxProps } from '../HoneyBox';
-export interface HoneyGridColumnStyledProps extends HTMLAttributes<HTMLDivElement>, HoneyBoxProps {
+export type HoneyGridColumnStyledProps<Element extends ElementType = 'div'> = HoneyBoxProps<Element> & {
     /**
      * Total number of columns in the grid.
      */
@@ -23,10 +23,10 @@ export interface HoneyGridColumnStyledProps extends HTMLAttributes<HTMLDivElemen
      * Can be a breakpoint name.
      */
     applyMaxWidth?: HoneyBreakpointName | false;
-}
+};
 /**
  * This styled component defines the layout and styling for individual columns in a grid layout.
  * It provides flexibility in specifying the number of columns to take, the total number of columns in the grid,
  * and the spacing between columns.
  */
-export declare const HoneyGridColumnStyled: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof HTMLAttributes<HTMLDivElement> | keyof HoneyBoxProps> & HTMLAttributes<HTMLDivElement> & HoneyBoxProps, import('styled-components').FastOmit<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof HTMLAttributes<HTMLDivElement> | keyof HoneyBoxProps> & HTMLAttributes<HTMLDivElement> & HoneyBoxProps>, never>, keyof HoneyBoxProps> & HoneyBoxProps, HoneyGridColumnStyledProps>> & string;
+export declare const HoneyGridColumnStyled: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, HoneyBoxProps<"div">>, never>, import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, HoneyBoxProps<"div">>, never>>, import('../HoneyFlexBox').HoneyFlexBoxProps<"div">>, never>, HoneyGridColumnStyledProps<"div">>> & string;

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

@@ -0,0 +1 @@
+export * from './HoneyLazyContent';

package/dist/components/HoneyList/HoneyList.d.ts

@@ -1,9 +1,7 @@
-import { default as React, HTMLAttributes, RefAttributes } from 'react';
 import { HoneyListGenericProps, HoneyListItem } from './HoneyList.types';
-import { HoneyBoxProps } from '../HoneyBox';
 import { HoneyStatusContentProps } from '../HoneyStatusContent';
-export interface HoneyListProps<Item extends HoneyListItem> extends Omit<HTMLAttributes<HTMLDivElement>, 'children'>, HoneyBoxProps, HoneyListGenericProps<Item>, Omit<HoneyStatusContentProps, 'isNoContent'> {
-}
+import { HoneyListStyledProps } from './HoneyListStyled';
+export type HoneyListProps<Item extends HoneyListItem> = Omit<HoneyListStyledProps, 'children'> & HoneyListGenericProps<Item> & Omit<HoneyStatusContentProps, 'isNoContent'>;
 /**
  * A generic and reusable list component that handles different states such as loading, error, or no content,
  * and dynamically renders a list of items with custom content for each item.
@@ -14,8 +12,5 @@ export interface HoneyListProps<Item extends HoneyListItem> extends Omit<HTMLAtt
  *
  * @template Item - Represents the type of the items to be rendered in the list. This allows the component
  * to be used with any item type.
- *
- * @template Element - Represents the type of the HTML element (e.g., `HTMLDivElement`, `HTMLUListElement`)
- * that will receive the forwarded ref. This allows precise typing for the element.
  */
-export declare const HoneyList: <Item extends HoneyListItem, Element extends HTMLElement>(props: HoneyListProps<Item> & RefAttributes<Element>) => React.ReactElement;
+export declare const HoneyList: <Item extends HoneyListItem>({ ref, children, items, itemKey, isLoading, isLoadingOverContent, loadingContent, isError, errorContent, noContent, ...props }: HoneyListProps<Item>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/HoneyList/HoneyListStyled.d.ts

@@ -1 +1,3 @@
-export declare const HoneyListStyled: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').HTMLAttributes<HTMLDivElement> | keyof import('..').HoneyBoxProps> & import('react').HTMLAttributes<HTMLDivElement> & import('..').HoneyBoxProps, import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').HTMLAttributes<HTMLDivElement> | keyof import('..').HoneyBoxProps> & import('react').HTMLAttributes<HTMLDivElement> & import('..').HoneyBoxProps>, never>, keyof import('..').HoneyBoxProps> & import('..').HoneyBoxProps, import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').HTMLAttributes<HTMLDivElement> | keyof import('..').HoneyBoxProps> & import('react').HTMLAttributes<HTMLDivElement> & import('..').HoneyBoxProps, import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').HTMLAttributes<HTMLDivElement> | keyof import('..').HoneyBoxProps> & import('react').HTMLAttributes<HTMLDivElement> & import('..').HoneyBoxProps>, never>, keyof import('..').HoneyBoxProps> & import('..').HoneyBoxProps>, never>, never>> & string;
+import { HoneyFlexBoxProps } from '../HoneyFlexBox';
+export type HoneyListStyledProps = HoneyFlexBoxProps;
+export declare const HoneyListStyled: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, import('..').HoneyBoxProps<"div">>, never>, import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, import('..').HoneyBoxProps<"div">>, never>>, HoneyFlexBoxProps<"div">>, never>, import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, import('..').HoneyBoxProps<"div">>, never>, import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, import('..').HoneyBoxProps<"div">>, never>>, HoneyFlexBoxProps<"div">>, never>>, HoneyListStyledProps>, never>> & string;

package/dist/components/HoneyOverlay.d.ts

@@ -1,4 +1,4 @@
-import { default as React, ReactNode, HTMLAttributes } from 'react';
+import { ReactNode } from 'react';
 import { HoneyActiveOverlay, HoneyOverlayId, Nullable } from '../types';
 import { HoneyFlexBoxProps } from './HoneyFlexBox';
 export interface HoneyOverlayContext {
@@ -11,7 +11,7 @@ export interface HoneyOverlayContext {
      */
     deactivateOverlay: () => void;
 }
-export interface HoneyOverlayProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'>, HoneyFlexBoxProps {
+export interface HoneyOverlayProps extends Omit<HoneyFlexBoxProps, 'children'> {
     /**
      * The content of the overlay, either as static nodes or a function that receives the object
      * with the current overlay state and helper methods.
@@ -32,13 +32,25 @@ export interface HoneyOverlayProps extends Omit<HTMLAttributes<HTMLDivElement>,
     onDeactivate: () => void;
 }
 /**
- * A reusable overlay component that manages active states and keyboard interactions.
+ * A reusable overlay component integrated with the `HoneyLayoutProvider` system.
  *
- * The `HoneyOverlay` component integrates with the `useRegisterHoneyOverlay` hook to:
- * - Automatically register/deregister the overlay.
- * - Handle keyboard events, such as closing the overlay with the "Escape" key.
- * - Provide a context to dynamically manage overlay content and state.
+ * Automatically registers/unregisters itself with the layout system and handles key events.
  *
- * @param props - The properties used to configure the overlay.
+ * @param props - Component configuration.
+ *
+ * @example
+ * ```tsx
+ * <HoneyOverlay
+ *   active={isOpen}
+ *   onDeactivate={() => setIsOpen(false)}
+ * >
+ *   {({ deactivateOverlay }) => (
+ *     <div>
+ *       <h2>Settings</h2>
+ *       <button onClick={deactivateOverlay}>Close</button>
+ *     </div>
+ *   )}
+ * </HoneyOverlay>
+ * ```
  */
-export declare const HoneyOverlay: React.ForwardRefExoticComponent<HoneyOverlayProps & React.RefAttributes<HTMLDivElement>>;
+export declare const HoneyOverlay: ({ ref, children, active, overlayId, onDeactivate, ...props }: HoneyOverlayProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/HoneyPopup/HoneyPopup.d.ts

@@ -9,8 +9,9 @@ export interface HoneyPopupChildrenContextProps {
     referenceProps: ReturnType<UseInteractionsReturn['getReferenceProps']>;
 }
 type InheritedHoneyOverlayProps = Omit<HoneyOverlayProps, 'children' | 'active' | 'onDeactivate'>;
-export interface HoneyPopupProps<Context = undefined> extends Omit<HoneyPopupStyledProps, 'children' | 'content'>, UseHoneyPopupOptions {
+export interface HoneyPopupProps<Context = undefined, UseAutoSize extends boolean = boolean> extends UseHoneyPopupOptions<UseAutoSize> {
     children: (context: HoneyPopupChildrenContextProps) => ReactNode;
+    referenceProps?: Omit<HoneyPopupStyledProps, 'children' | 'content'>;
     /**
      * Content inside the popup.
      */
@@ -18,19 +19,13 @@ export interface HoneyPopupProps<Context = undefined> extends Omit<HoneyPopupSty
     /**
      * Additional props for the floating content.
      */
-    contentProps?: InheritedHoneyOverlayProps;
+    contentProps?: UseAutoSize extends true ? Omit<InheritedHoneyOverlayProps, '$minWidth' | '$minHeight' | '$maxWidth' | '$maxHeight'> : InheritedHoneyOverlayProps;
     /**
      * Props for managing focus inside the popup.
      *
      * @see https://floating-ui.com/docs/floatingfocusmanager#props
      */
     focusManagerProps?: Omit<FloatingFocusManagerProps, 'children' | 'context'>;
-    /**
-     * Whether to show an arrow indicator.
-     *
-     * @default false
-     */
-    showArrow?: boolean;
     /**
      * Properties for an arrow component.
      *
@@ -57,5 +52,5 @@ export interface HoneyPopupProps<Context = undefined> extends Omit<HoneyPopupSty
  *
  * @template Context - Optional context type.
  */
-export declare const HoneyPopup: <Context = undefined>({ children, content, contentProps, focusManagerProps, enabled, open, event, arrowOptions, floatingOptions, offsetOptions, shiftOptions, flipOptions, dismissOptions, clickOptions, hoverOptions, focusOptions, clientPointsOptions, roleOptions, transitionOptions, showArrow, useAutoUpdate, autoUpdateOptions, arrowProps, portalProps, adjustStyles, context, onOpen, onClose, ...props }: HoneyPopupProps<Context>) => import("react/jsx-runtime").JSX.Element;
+export declare const HoneyPopup: <Context = undefined, UseAutoSize extends boolean = boolean>({ children, referenceProps, content, contentProps, focusManagerProps, arrowProps, portalProps, adjustStyles, context, ...popupOptions }: HoneyPopupProps<Context, UseAutoSize>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/HoneyPopup/HoneyPopupStyled.d.ts

@@ -1,5 +1,3 @@
-import { HTMLAttributes } from 'react';
 import { HoneyFlexBoxProps } from '../HoneyFlexBox';
-export interface HoneyPopupStyledProps extends HTMLAttributes<HTMLDivElement>, HoneyFlexBoxProps {
-}
-export declare const HoneyPopupStyled: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof HTMLAttributes<HTMLDivElement> | keyof import('..').HoneyBoxProps> & HTMLAttributes<HTMLDivElement> & import('..').HoneyBoxProps, import('styled-components').FastOmit<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof HTMLAttributes<HTMLDivElement> | keyof import('..').HoneyBoxProps> & HTMLAttributes<HTMLDivElement> & import('..').HoneyBoxProps>, never>, keyof import('..').HoneyBoxProps> & import('..').HoneyBoxProps, import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof HTMLAttributes<HTMLDivElement> | keyof import('..').HoneyBoxProps> & HTMLAttributes<HTMLDivElement> & import('..').HoneyBoxProps, import('styled-components').FastOmit<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof HTMLAttributes<HTMLDivElement> | keyof import('..').HoneyBoxProps> & HTMLAttributes<HTMLDivElement> & import('..').HoneyBoxProps>, never>, keyof import('..').HoneyBoxProps> & import('..').HoneyBoxProps>, never>, HoneyPopupStyledProps>> & string;
+export type HoneyPopupStyledProps = HoneyFlexBoxProps;
+export declare const HoneyPopupStyled: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, import('..').HoneyBoxProps<"div">>, never>, import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, import('..').HoneyBoxProps<"div">>, never>>, HoneyFlexBoxProps<"div">>, never>, import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, import('..').HoneyBoxProps<"div">>, never>, import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, import('..').HoneyBoxProps<"div">>, never>>, HoneyFlexBoxProps<"div">>, never>>, HoneyPopupStyledProps>, never>> & string;

package/dist/components/HoneyPopup/hooks/use-honey-popup-interactions.d.ts

@@ -18,7 +18,7 @@ export interface UseHoneyPopupInteractionsOptions {
      *
      * @see https://floating-ui.com/docs/usedismiss
      */
-    dismissOptions?: Omit<UseDismissProps, 'enabled' | 'escapeKey'>;
+    dismissOptions?: Omit<UseDismissProps, 'escapeKey'>;
     /**
      * Configuration for click interactions.
      *
@@ -29,6 +29,7 @@ export interface UseHoneyPopupInteractionsOptions {
      * Configuration for hover interactions.
      *
      * @prop restMs Default is 150.
+     * @prop handleClose Default is `safePolygon()`.
      *
      * @see https://floating-ui.com/docs/usehover
      */

package/dist/components/HoneyPopup/hooks/use-honey-popup.d.ts

@@ -2,12 +2,8 @@ import { useTransitionStyles, AutoUpdateOptions, ArrowOptions, FlipOptions, Offs
 import { RefObject } from 'react';
 import { Nullable } from '../../../types';
 import { UseHoneyPopupInteractionsOptions } from './use-honey-popup-interactions';
-export interface UseHoneyPopupOptions extends UseHoneyPopupInteractionsOptions {
+export interface UseHoneyPopupOptions<UseAutoSize extends boolean = boolean> extends UseHoneyPopupInteractionsOptions {
     open?: boolean;
-    /**
-     * Configuration for the floating arrow.
-     */
-    arrowOptions?: Omit<ArrowOptions, 'element'>;
     /**
      * Options for configuring the floating UI behavior.
      */
@@ -31,6 +27,16 @@ export interface UseHoneyPopupOptions extends UseHoneyPopupInteractionsOptions {
      * @see https://floating-ui.com/docs/shift
      */
     shiftOptions?: ShiftOptions;
+    /**
+     * Whether to show an arrow indicator.
+     *
+     * @default false
+     */
+    useArrow?: boolean;
+    /**
+     * Configuration for the floating arrow.
+     */
+    arrowOptions?: Omit<ArrowOptions, 'element'>;
     /**
      * @prop duration Default is 250.
      *
@@ -49,6 +55,34 @@ export interface UseHoneyPopupOptions extends UseHoneyPopupInteractionsOptions {
      * @see https://floating-ui.com/docs/autoupdate
      */
     autoUpdateOptions?: AutoUpdateOptions;
+    /**
+     * @default false
+     */
+    useAutoSize?: UseAutoSize;
+    /**
+     * @default 0
+     *
+     * @remarks Only works when `useAutoSize` is `true`.
+     */
+    minAcceptableWidth?: number;
+    /**
+     * @default 0
+     *
+     * @remarks Only works when `useAutoSize` is `true`.
+     */
+    minAcceptableHeight?: number;
+    /**
+     * @default undefined
+     *
+     * @remarks Only works when `useAutoSize` is `true`.
+     */
+    maxAcceptableWidth?: number;
+    /**
+     * @default undefined
+     *
+     * @remarks Only works when `useAutoSize` is `true`.
+     */
+    maxAcceptableHeight?: number;
     /**
      * Callback invoked when the popup opens.
      */
@@ -92,5 +126,5 @@ interface UseHoneyPopupApi {
  *
  * @returns An object containing state and utilities for managing the popup.
  */
-export declare const useHoneyPopup: ({ enabled, event, dismissOptions, clickOptions, hoverOptions, focusOptions, clientPointsOptions, roleOptions, open, arrowOptions, floatingOptions, offsetOptions, flipOptions, shiftOptions, transitionOptions, useAutoUpdate, autoUpdateOptions, onOpen, onClose, }: UseHoneyPopupOptions) => UseHoneyPopupApi;
+export declare const useHoneyPopup: ({ enabled, event, dismissOptions, clickOptions, hoverOptions, focusOptions, clientPointsOptions, roleOptions, open, floatingOptions, offsetOptions, flipOptions, shiftOptions, useArrow, arrowOptions, transitionOptions, useAutoUpdate, autoUpdateOptions, useAutoSize, minAcceptableWidth, minAcceptableHeight, maxAcceptableWidth, maxAcceptableHeight, onOpen, onClose, }: UseHoneyPopupOptions) => UseHoneyPopupApi;
 export {};

package/dist/components/index.d.ts

@@ -3,7 +3,6 @@ export * from './HoneyFlexBox';
 export * from './HoneyGrid';
 export * from './HoneyGridColumn';
 export * from './HoneyList';
-export * from './HoneyLoopingList';
 export * from './HoneyStatusContent';
 export * from './HoneyLazyContent';
 export * from './HoneyOverlay';

package/dist/constants.d.ts

@@ -1,3 +1,3 @@
-import { HoneyCSSColorProperty, HoneyCSSDimensionProperty } from './types';
-export declare const CSS_DIMENSION_PROPERTIES: readonly HoneyCSSDimensionProperty[];
+import { HoneyCSSColorProperty, HoneyCSSSpacingProperty } from './types';
+export declare const CSS_SPACING_PROPERTIES: readonly HoneyCSSSpacingProperty[];
 export declare const CSS_COLOR_PROPERTIES: readonly HoneyCSSColorProperty[];

package/dist/contexts/HoneyLayoutContext.d.ts

@@ -1,6 +1,6 @@
 import { DefaultTheme, Interpolation } from 'styled-components';
-import { HoneyColorKey, HoneyCSSColor, HoneyDimensionName, HoneyFontName, HoneyOverlayConfig, HoneySpacings, Nullable, HoneyScreenState, HoneyCSSDimensionUnit, HoneyCSSDimensionValue, HoneyCSSMultiValue, HoneyOverlayId, HoneyActiveOverlay } from '../types';
-import { ResolveSpacingResult } from '../helpers';
+import { HoneyColorKey, HoneyCSSColor, HoneyDimensionName, HoneyFontName, HoneyOverlayConfig, HoneySpacings, Nullable, HoneyScreenState, HoneyCSSDimensionUnit, HoneyCSSDimensionValue, HoneyOverlayId, HoneyActiveOverlay, HoneyCSSSpacingValue } from '../types';
+import { HoneyResolveSpacingResult } from '../helpers';
 /**
  * Function to unregister a previously registered overlay.
  */
@@ -35,7 +35,7 @@ export interface HoneyLayoutContextValue {
     /**
      * Function to resolve spacing values based on a given theme.
      *
-     * @template MultiValue - A type representing the spacing value(s), which could be a single value or an array of values.
+     * @template Value - A type representing the spacing value(s), which could be a single value or an array of values.
      * @template Unit - The CSS unit used for the resolved spacing value, e.g., 'px', 'em'.
      *
      * @param value - The spacing value(s) to be applied, which could be a single number or an array of numbers.
@@ -44,7 +44,7 @@ export interface HoneyLayoutContextValue {
      *
      * @returns The resolved spacing value, formatted as a string with the appropriate unit.
      */
-    resolveSpacing: <MultiValue extends HoneyCSSMultiValue<number>, Unit extends Nullable<HoneyCSSDimensionUnit> = 'px'>(value: MultiValue, unit?: Unit, type?: keyof HoneySpacings) => ResolveSpacingResult<MultiValue, Unit>;
+    resolveSpacing: <Value extends HoneyCSSSpacingValue, Unit extends Nullable<HoneyCSSDimensionUnit> = 'px'>(value: Value, unit?: Unit, type?: keyof HoneySpacings) => HoneyResolveSpacingResult<Value, Unit>;
     /**
      * Function to resolve color values based on the theme.
      *

package/dist/helpers/helpers.d.ts

@@ -1,37 +1,49 @@
+import { css, ExecutionContext, StyleFunction } from 'styled-components';
 import { HTMLAttributes } from 'react';
-import { ExecutionContext, StyleFunction, css } from 'styled-components';
-import { Nullable, HoneyBreakpointName, HoneyCSSArrayValue, HoneyCSSDimensionShortHandValue, HoneyCSSDimensionUnit, HoneyCSSMultiValue, HoneyCSSMediaRule, HoneySpacings, HoneyColorKey, HoneyFontName, HoneyCSSColor, HoneyDimensionName, HoneyPrefixedCSSProperties, HoneyBreakpoints, HoneyScreenState, HoneyCSSDimensionValue } from '../types';
+import { Nullable, HoneyBreakpointName, HoneyCSSShorthandTuple, HoneyCSSShorthandDimensionOutput, HoneyCSSDimensionUnit, HoneyCSSSpacingValue, HoneyCSSMediaRule, HoneySpacings, HoneyColorKey, HoneyFontName, HoneyCSSColor, HoneyDimensionName, HoneyPrefixedCSSProperties, HoneyBreakpoints, HoneyScreenState, HoneyCSSDimensionValue } from '../types';
 export declare const noop: () => void;
 export declare function assert(condition: any, message: string): asserts condition;
 export declare const generateUniqueId: () => string;
 /**
- * Conditional type to determine the return type of the `resolveSpacing` function.
+ * Determines the resolved type for spacing values when processed by `resolveSpacing`.
  *
- * @template MultiValue - Type of the spacing value can be a single value or an array of values.
- * @template Unit - CSS length unit, which can be null or a specific unit type.
+ * The return type adapts based on the shape of the `Value` and presence of a CSS `Unit`:
+ *
+ * - If `Value` is a `string` (e.g., raw `'10px'` or `'auto'`), it is returned as-is.
+ * - If `Unit` is `null`, the original value is returned (either number or shorthand array).
+ * - If `Unit` is provided and `Value` is a shorthand array (e.g., `[1, 2, 3, 4]`),
+ *   it is resolved to a space-separated dimension string (e.g., `'8px 16px 24px 32px'`).
+ * - If `Unit` is provided and `Value` is a number, it is resolved to a single dimension string (e.g., `'16px'`).
+ *
+ * This type helps enforce correct resolution behavior depending on user input and configuration.
+ *
+ * @template Value - The input spacing value (number, shorthand array, or raw string).
+ * @template Unit - A CSS length unit (e.g., 'px', 'em'), or `null` to skip unit formatting.
  */
-export type ResolveSpacingResult<MultiValue extends HoneyCSSMultiValue<number>, Unit extends Nullable<HoneyCSSDimensionUnit>> = Unit extends null ? MultiValue extends HoneyCSSArrayValue<number> ? HoneyCSSArrayValue<number> : number : MultiValue extends HoneyCSSArrayValue<number> ? HoneyCSSDimensionShortHandValue<MultiValue, NonNullable<Unit>> : `${number}${Unit}`;
+export type HoneyResolveSpacingResult<Value extends HoneyCSSSpacingValue, Unit extends Nullable<HoneyCSSDimensionUnit>> = Value extends HoneyCSSDimensionValue ? Value : Unit extends null ? Value : Value extends HoneyCSSShorthandTuple<number | HoneyCSSDimensionValue> ? HoneyCSSShorthandDimensionOutput<Value, NonNullable<Unit>> : HoneyCSSDimensionValue<NonNullable<Unit>>;
 /**
- * Resolves a spacing value or multiple spacing values based on the provided input, CSS unit, and spacing type.
- * This function calculates the appropriate spacing values from a theme and formats them with the specified CSS unit.
- *
- * @template MultiValue - Represents the spacing value(s), which could be a single number or an array of numbers (e.g., [1, 2, 3, 4]).
- * @template Unit - The CSS unit used for the resolved spacing value, e.g., 'px', 'em'. Defaults to 'px'.
- *
- * @param value - The spacing factor(s) to be applied. It can be:
- *                - A single number representing a multiplier for the base spacing value.
- *                - An array of numbers representing multiple multipliers for base spacing values (e.g., for margins or padding).
- * @param [unit='px'] - The CSS unit to use for the calculated value. If `null` or `undefined`, no unit is applied.
- *                      Defaults to 'px'.
- * @param [type='base'] - The type of spacing to use from the theme. Determines which base spacing
- *                        value to use for calculations (e.g., 'base', 'small', 'large'). Defaults to 'base'.
- *
- * @returns A function that takes `ExecutionContext` (containing the theme object) and returns the resolved spacing value(s).
- *          The result is either:
- *            - A single calculated value (e.g., '16px') if the input is a single number.
- *            - A string of space-separated values (e.g., '8px 16px 24px 32px') if the input is an array of numbers.
+ * Resolves a spacing value or shorthand spacing array using the theme and optional unit.
+ *
+ * This function takes spacing multipliers and converts them into pixel or unit-based values
+ * using a theme spacing scale (e.g., `theme.spacings.base`). Useful for applying consistent
+ * layout spacing with theming and token support.
+ *
+ * @template Value - The spacing value(s) to resolve. Can be:
+ *                   - A number (e.g., `1`) representing a multiplier.
+ *                   - An array of numbers (e.g., `[1, 2, 3, 4]`) for shorthand spacing.
+ *                   - A dimension string (e.g., `'10px'`) will be returned as `never`.
+ * @template Unit - Optional CSS unit (`'px'`, `'em'`, etc.), or `null` to skip units.
+ *
+ * @param value - Spacing multiplier(s) to apply.
+ * @param [unit='px'] - The CSS unit to append. If `null`, values remain numeric.
+ * @param [type='base'] - The spacing type to use from the theme (e.g., `'base'`, `'small'`).
+ *
+ * @returns A function that takes a theme context and returns:
+ *          - A single resolved value (e.g., `'16px'`) if `value` is a number.
+ *          - A space-separated string (e.g., `'8px 12px'`) if `value` is an array.
+ *          - `never` if the input is a raw string (unsupported).
  */
-export declare const resolveSpacing: <MultiValue extends HoneyCSSMultiValue<number>, Unit extends Nullable<HoneyCSSDimensionUnit> = "px">(value: MultiValue, unit?: Unit, type?: keyof HoneySpacings) => ((context: ExecutionContext) => ResolveSpacingResult<MultiValue, Unit>);
+export declare const resolveSpacing: <Value extends HoneyCSSSpacingValue, Unit extends Nullable<HoneyCSSDimensionUnit> = "px">(value: Value, unit?: Unit, type?: keyof HoneySpacings) => ((context: ExecutionContext) => HoneyResolveSpacingResult<Value, Unit>);
 /**
  * Resolves a color value from the theme or returns the input color directly if it's a standalone color name or HEX value.
  *

package/dist/hooks/index.d.ts

@@ -1,7 +1,6 @@
+export * from './use-honey-on-change';
 export * from './use-honey-media-query';
 export * from './use-honey-drag';
-export * from './use-honey-infinite-scroll';
-export * from './use-honey-synthetic-scrollable-container';
 export * from './use-honey-document-key-up-handler';
 export * from './use-honey-layout';
 export * from './use-register-honey-overlay';

package/dist/hooks/use-honey-document-key-up-handler.d.ts

@@ -1,19 +1,40 @@
 import { HoneyKeyboardEventCode } from '../types';
 export type HoneyDocumentKeyUpHandler = (keyCode: HoneyKeyboardEventCode, e: KeyboardEvent) => void;
-type UseHoneyDocumentKeyUpHandlerOptions = {
+interface UseHoneyDocumentKeyUpHandlerOptions {
     /**
-     * Determines if the event listener is active.
+     * Whether the event listener should be active.
      *
      * @default true
      */
-    isEnabled?: boolean;
-};
+    enabled?: boolean;
+    /**
+     * Whether to call `preventDefault()` on matching keyup events.
+     *
+     * This is useful for suppressing default browser behavior (e.g., scrolling with Space key).
+     *
+     * @default true
+     */
+    preventDefault?: boolean;
+}
 /**
- * A hook that listens for specific key up events at the document level and triggers a callback function.
+ * Hook for handling specific key up events on the `document` object.
+ *
+ * This hook adds a `keyup` event listener at the document level and triggers the provided `keyUpHandler`
+ * when one of the specified `listenKeys` is released.
+ *
+ * @param keyUpHandler - The callback function invoked when a matching key is released.
+ * @param listenKeys - An array of key codes (`KeyboardEvent.code`) to listen for.
+ * @param options - Optional configuration to control event behavior and listener activation.
  *
- * @param {HoneyDocumentKeyUpHandler} keyUpHandler - The callback function to be triggered when one of the specified keys is released.
- * @param {HoneyKeyboardEventCode[]} listenKeys - An array of key codes to listen for. Only these specified keys will trigger the callback.
- * @param {Object} options - Optional configuration.
+ * @example
+ * ```tsx
+ * useHoneyDocumentKeyUpHandler(
+ *   (keyCode, event) => {
+ *     console.log('Key released:', keyCode);
+ *   },
+ *   ['Escape'],
+ * );
+ * ```
  */
-export declare const useHoneyDocumentKeyUpHandler: (keyUpHandler: HoneyDocumentKeyUpHandler, listenKeys: HoneyKeyboardEventCode[], { isEnabled }?: UseHoneyDocumentKeyUpHandlerOptions) => void;
+export declare const useHoneyDocumentKeyUpHandler: (keyUpHandler: HoneyDocumentKeyUpHandler, listenKeys: HoneyKeyboardEventCode[], { enabled, preventDefault }?: UseHoneyDocumentKeyUpHandlerOptions) => void;
 export {};