@vellira-ui/react 2.126.9 → 2.126.10

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

@@ -0,0 +1,186 @@
+import { Placement, Strategy } from '@floating-ui/react';
+import { BaseDropdownContentProps, BaseDropdownItemProps, BaseDropdownProps, BaseDropdownSearchProps, BaseDropdownSelectableItemProps, BaseDropdownTriggerProps } from '@vellira-ui/types';
+import { AnchorHTMLAttributes, CSSProperties, KeyboardEvent as ReactKeyboardEvent, MouseEvent, ReactNode } from 'react';
+export type DropdownSelectEvent = {
+    /** Original pointer or keyboard event that selected the item. */
+    originalEvent: MouseEvent<HTMLElement> | KeyboardEvent | ReactKeyboardEvent<HTMLElement>;
+    /** Prevents the dropdown from performing its default select behavior. */
+    preventDefault: () => void;
+    /** Whether default select behavior has been prevented. */
+    defaultPrevented: boolean;
+};
+export type DropdownProps = BaseDropdownProps & {
+    /** Trigger, content, and optional compound dropdown children. */
+    children: ReactNode;
+    /** Floating content placement relative to the trigger. */
+    placement?: Placement;
+    /** CSS positioning strategy used by the floating content. */
+    strategy?: Strategy;
+    /** Distance between the trigger and dropdown content. */
+    offset?: number;
+    /** Padding used when avoiding viewport collisions. */
+    collisionPadding?: number;
+    /** Matches dropdown content width to the trigger width. */
+    matchTriggerWidth?: boolean;
+    /** Minimum dropdown content width. */
+    minWidth?: number | string;
+    /** Maximum dropdown content width. */
+    maxWidth?: number | string;
+    /** Renders dropdown content through a portal. */
+    portal?: boolean;
+    /** Allows the dropdown to flip or shift to stay visible. */
+    avoidCollisions?: boolean;
+    /** Uses modal interaction semantics while the dropdown is open. */
+    modal?: boolean;
+    /** Allows keyboard navigation to wrap between first and last items. */
+    loop?: boolean;
+    /** Class name applied to the root element. */
+    className?: string;
+    /** Content shown while dropdown items are loading. */
+    loadingText?: ReactNode;
+    /** Content shown when no items match the current query. */
+    empty?: ReactNode;
+};
+export type DropdownTriggerProps = BaseDropdownTriggerProps & {
+    /** Trigger content. */
+    children: ReactNode;
+    /** Composes trigger behavior onto a single child element. */
+    asChild?: boolean;
+    /** Class name applied to the trigger element. */
+    className?: string;
+};
+export type DropdownContentProps = BaseDropdownContentProps & {
+    /** Dropdown item and slot content. */
+    children?: ReactNode;
+    /** Class name applied to the content element. */
+    className?: string;
+    /** Inline style applied to the content element. */
+    style?: CSSProperties;
+};
+export type DropdownSearchProps = BaseDropdownSearchProps & {
+    /** Accessible name for the search input. */
+    'aria-label'?: string;
+    /** Class name applied to the search input. */
+    className?: string;
+};
+export type DropdownArrowProps = {
+    /** Class name applied to the floating arrow element. */
+    className?: string;
+};
+export type DropdownItemProps = BaseDropdownItemProps & {
+    /** Item label or custom item content. */
+    children: ReactNode;
+    /** Composes item behavior onto a single child element. */
+    asChild?: boolean;
+    /** Icon rendered before the item label. */
+    icon?: ReactNode;
+    /** Supporting text rendered below the item label. */
+    description?: ReactNode;
+    /** Badge content rendered after the item label. */
+    badge?: ReactNode;
+    /** Keyboard shortcut hint rendered after the item label. */
+    shortcut?: ReactNode;
+    /** Called when this item is selected. */
+    onSelect?: (event: DropdownSelectEvent) => void;
+    /** Link target rendered when the item acts as an anchor. */
+    href?: string;
+    /** Anchor target used when href is provided. */
+    target?: AnchorHTMLAttributes<HTMLAnchorElement>['target'];
+    /** Anchor rel attribute used when href is provided. */
+    rel?: string;
+    /** Anchor download attribute used when href is provided. */
+    download?: boolean | string;
+    /** Class name applied to the item element. */
+    className?: string;
+};
+export type DropdownCheckboxItemProps = BaseDropdownSelectableItemProps & {
+    /** Composes checkbox item behavior onto a single child element. */
+    asChild?: boolean;
+    /** Controlled checked state. */
+    checked?: boolean;
+    /** Initial checked state for uncontrolled usage. */
+    defaultChecked?: boolean;
+    /** Called when the checked state changes. */
+    onCheckedChange?: (checked: boolean) => void;
+    /** Indicator icon shown when the item is checked. */
+    icon?: ReactNode;
+    /** Keyboard shortcut hint rendered after the item label. */
+    shortcut?: ReactNode;
+    /** Checkbox item label or custom content. */
+    children: ReactNode;
+    /** Class name applied to the checkbox item element. */
+    className?: string;
+};
+export type DropdownRadioGroupProps = {
+    /** Radio item children. */
+    children?: ReactNode;
+    /** Controlled selected radio value. */
+    value?: string;
+    /** Initial selected radio value for uncontrolled usage. */
+    defaultValue?: string;
+    /** Called when the selected radio value changes. */
+    onValueChange?: (value: string) => void;
+};
+export type DropdownRadioItemProps = BaseDropdownSelectableItemProps & {
+    /** Radio item label or custom content. */
+    children: ReactNode;
+    /** Composes radio item behavior onto a single child element. */
+    asChild?: boolean;
+    /** Value represented by this radio item. */
+    value: string;
+    /** Indicator icon shown when the item is selected. */
+    icon?: ReactNode;
+    /** Keyboard shortcut hint rendered after the item label. */
+    shortcut?: ReactNode;
+    /** Class name applied to the radio item element. */
+    className?: string;
+};
+export type DropdownSeparatorProps = {
+    /** Class name applied to the separator element. */
+    className?: string;
+};
+export type DropdownSubProps = {
+    /** Submenu trigger and content. */
+    children?: ReactNode;
+};
+export type DropdownSubTriggerProps = Omit<DropdownItemProps, 'onSelect'>;
+export type DropdownSubContentProps = {
+    /** Submenu item and slot content. */
+    children?: ReactNode;
+    /** Class name applied to the submenu content element. */
+    className?: string;
+};
+export type DropdownItemIconProps = {
+    /** Icon slot content. */
+    children?: ReactNode;
+};
+export type DropdownItemDescriptionProps = {
+    /** Description slot content. */
+    children?: ReactNode;
+};
+export type DropdownItemBadgeProps = {
+    /** Badge slot content. */
+    children?: ReactNode;
+};
+export type DropdownItemShortcutProps = {
+    /** Shortcut slot content. */
+    children?: ReactNode;
+};
+export type DropdownGroupProps = {
+    /** Grouped dropdown items. */
+    children?: ReactNode;
+};
+export type DropdownLabelProps = {
+    /** Label content for a dropdown group. */
+    children?: ReactNode;
+    /** Class name applied to the label element. */
+    className?: string;
+};
+export type DropdownEmptyProps = {
+    /** Empty state content. */
+    children?: ReactNode;
+};
+export type DropdownLoadingProps = {
+    /** Loading state content. */
+    children?: ReactNode;
+};

package/dist/components/Modal/Body/ModalBody.d.ts

@@ -0,0 +1,5 @@
+import { ModalBodyProps } from './types';
+export declare const ModalBody: {
+    ({ children, className }: ModalBodyProps): import('react').JSX.Element;
+    displayName: string;
+};

package/dist/components/Modal/Body/index.d.ts

@@ -0,0 +1,2 @@
+export { ModalBody } from './ModalBody';
+export type { ModalBodyProps } from './types';

package/dist/components/Modal/Body/types.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+export interface ModalBodyProps {
+    /** Main modal body content. */
+    children: ReactNode;
+    /** Class name applied to the body element. */
+    className?: string;
+}

package/dist/components/Modal/Close/ModalClose.d.ts

@@ -0,0 +1,5 @@
+import { ModalCloseProps } from './types';
+export declare const ModalClose: {
+    ({ asChild, children, className, "aria-label": ariaLabel, }: ModalCloseProps): import('react').JSX.Element;
+    displayName: string;
+};

package/dist/components/Modal/Close/index.d.ts

@@ -0,0 +1,2 @@
+export { ModalClose } from './ModalClose';
+export type { ModalCloseProps } from './types';

package/dist/components/Modal/Close/types.d.ts

@@ -0,0 +1,11 @@
+import { ReactElement } from 'react';
+export type ModalCloseProps = {
+    /** Composes close behavior onto a single child element. */
+    asChild?: boolean;
+    /** Custom close button element. */
+    children?: ReactElement;
+    /** Accessible name for the close button. */
+    'aria-label'?: string;
+    /** Class name applied to the close button. */
+    className?: string;
+};

package/dist/components/Modal/Content/ModalContent.d.ts

@@ -0,0 +1,5 @@
+import { ModalContentProps } from './types';
+export declare const ModalContent: {
+    ({ children, size, placement, scrollBehavior, animated, forceMount, ariaLabel, ariaLabelledBy, ariaDescribedBy, className, style, }: ModalContentProps): import('react').JSX.Element | null;
+    displayName: string;
+};

package/dist/components/Modal/Content/index.d.ts

@@ -0,0 +1,2 @@
+export { ModalContent } from './ModalContent';
+export type { ModalContentPlacement, ModalContentProps, ModalContentSize, ModalScrollBehavior, } from './types';

package/dist/components/Modal/Content/types.d.ts

@@ -0,0 +1,28 @@
+import { CSSProperties, ReactNode } from 'react';
+export type ModalContentSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+export type ModalContentPlacement = 'center' | 'top';
+export type ModalScrollBehavior = 'inside' | 'outside';
+export interface ModalContentProps {
+    /** Modal panel content. */
+    children: ReactNode;
+    /** Preset modal panel width. */
+    size?: ModalContentSize;
+    /** Vertical placement for the modal panel. */
+    placement?: ModalContentPlacement;
+    /** Controls whether scrolling happens inside the panel or outside it. */
+    scrollBehavior?: ModalScrollBehavior;
+    /** Enables enter and exit animation for the panel. */
+    animated?: boolean;
+    /** Keeps content mounted even when the modal is closed. */
+    forceMount?: boolean;
+    /** Accessible label applied directly to the modal panel. */
+    ariaLabel?: string;
+    /** Id of the element that labels the modal panel. */
+    ariaLabelledBy?: string;
+    /** Id of the element that describes the modal panel. */
+    ariaDescribedBy?: string;
+    /** Class name applied to the modal panel. */
+    className?: string;
+    /** Inline style applied to the modal panel. */
+    style?: CSSProperties;
+}

package/dist/components/Modal/Footer/ModalFooter.d.ts

@@ -0,0 +1,5 @@
+import { ModalFooterProps } from './types';
+export declare const ModalFooter: {
+    ({ children, className }: ModalFooterProps): import('react').JSX.Element;
+    displayName: string;
+};

package/dist/components/Modal/Footer/index.d.ts

@@ -0,0 +1,2 @@
+export { ModalFooter } from './ModalFooter';
+export type { ModalFooterProps } from './types';

package/dist/components/Modal/Footer/types.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+export interface ModalFooterProps {
+    /** Footer actions or custom footer content. */
+    children: ReactNode;
+    /** Class name applied to the footer element. */
+    className?: string;
+}

package/dist/components/Modal/Header/ModalDescription.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+export declare const ModalDescription: {
+    ({ children }: {
+        children: ReactNode;
+    }): import('react').JSX.Element;
+    displayName: string;
+};

package/dist/components/Modal/Header/ModalHeader.d.ts

@@ -0,0 +1,5 @@
+import { ModalHeaderProps } from './types';
+export declare const ModalHeader: {
+    ({ children, className }: ModalHeaderProps): import('react').JSX.Element;
+    displayName: string;
+};

package/dist/components/Modal/Header/ModalTitle.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+export declare const ModalTitle: {
+    ({ children }: {
+        children: ReactNode;
+    }): import('react').JSX.Element;
+    displayName: string;
+};

package/dist/components/Modal/Header/index.d.ts

@@ -0,0 +1,4 @@
+export { ModalDescription } from './ModalDescription';
+export { ModalHeader } from './ModalHeader';
+export { ModalTitle } from './ModalTitle';
+export type { ModalHeaderProps } from './types';

package/dist/components/Modal/Header/types.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+export interface ModalHeaderProps {
+    /** Header content, typically title and description. */
+    children: ReactNode;
+    /** Class name applied to the header element. */
+    className?: string;
+}

package/dist/components/Modal/Modal.d.ts

@@ -0,0 +1,45 @@
+export declare const Modal: {
+    ({ children, className, ...props }: import('./types').ModalProps): import('react').JSX.Element;
+    displayName: string;
+} & {
+    Trigger: {
+        ({ children, asChild, disabled, className, }: import('./Trigger').ModalTriggerProps): import('react').JSX.Element;
+        displayName: string;
+    };
+    Overlay: {
+        ({ className, animated, forceMount, }: import('./Overlay').ModalOverlayProps): import('react').JSX.Element | null;
+        displayName: string;
+    };
+    Content: {
+        ({ children, size, placement, scrollBehavior, animated, forceMount, ariaLabel, ariaLabelledBy, ariaDescribedBy, className, style, }: import('./Content').ModalContentProps): import('react').JSX.Element | null;
+        displayName: string;
+    };
+    Header: {
+        ({ children, className }: import('./Header').ModalHeaderProps): import('react').JSX.Element;
+        displayName: string;
+    };
+    Title: {
+        ({ children }: {
+            children: import('react').ReactNode;
+        }): import('react').JSX.Element;
+        displayName: string;
+    };
+    Description: {
+        ({ children }: {
+            children: import('react').ReactNode;
+        }): import('react').JSX.Element;
+        displayName: string;
+    };
+    Body: {
+        ({ children, className }: import('./Body').ModalBodyProps): import('react').JSX.Element;
+        displayName: string;
+    };
+    Footer: {
+        ({ children, className }: import('./Footer').ModalFooterProps): import('react').JSX.Element;
+        displayName: string;
+    };
+    Close: {
+        ({ asChild, children, className, "aria-label": ariaLabel, }: import('./Close').ModalCloseProps): import('react').JSX.Element;
+        displayName: string;
+    };
+};

package/dist/components/Modal/Overlay/ModalOverlay.d.ts

@@ -0,0 +1,5 @@
+import { ModalOverlayProps } from './types';
+export declare const ModalOverlay: {
+    ({ className, animated, forceMount, }: ModalOverlayProps): import('react').JSX.Element | null;
+    displayName: string;
+};

package/dist/components/Modal/Overlay/index.d.ts

@@ -0,0 +1,2 @@
+export { ModalOverlay } from './ModalOverlay';
+export type { ModalOverlayProps } from './types';

package/dist/components/Modal/Overlay/types.d.ts

@@ -0,0 +1,8 @@
+export type ModalOverlayProps = {
+    /** Enables enter and exit animation for the overlay. */
+    animated?: boolean;
+    /** Class name applied to the overlay element. */
+    className?: string;
+    /** Keeps the overlay mounted even when the modal is closed. */
+    forceMount?: boolean;
+};

package/dist/components/Modal/Root/ModalRoot.d.ts

@@ -0,0 +1,5 @@
+import { ModalProps } from '../types';
+export declare const ModalRoot: {
+    ({ children, className, ...props }: ModalProps): import('react').JSX.Element;
+    displayName: string;
+};

package/dist/components/Modal/Root/index.d.ts

@@ -0,0 +1,2 @@
+export { ModalRoot } from './ModalRoot';
+export type { ModalProps } from './types';

package/dist/components/Modal/Root/types.d.ts

@@ -0,0 +1 @@
+export type { ModalProps } from '../types';

package/dist/components/Modal/Root/useModalRootState.d.ts

@@ -0,0 +1,37 @@
+import { CSSProperties } from 'react';
+import { ModalProps } from '../types';
+export type UseModalRootStateOptions = Omit<ModalProps, 'children' | 'className'>;
+export declare const useModalRootState: ({ open, defaultOpen, onOpenChange, animation, duration, easing, modal, closeOnEscape, closeOnOutsidePress, preventScroll, restoreFocus, trapFocus, initialFocus, finalFocus, onOpenAutoFocus, onCloseAutoFocus, onEscapeKeyDown, onPointerDownOutside, onInteractOutside, role, }: UseModalRootStateOptions) => {
+    context: {
+        animation: import('@vellira-ui/types').ModalAnimation;
+        animationStyle: CSSProperties;
+        closeOnEscape: boolean;
+        closeOnOutsidePress: boolean;
+        contentId: string;
+        contentRef: import('react').RefObject<HTMLElement | null>;
+        descriptionId: string;
+        finalFocus: import('react').RefObject<HTMLElement> | undefined;
+        initialFocus: import('react').RefObject<HTMLElement> | undefined;
+        zIndex: number | undefined;
+        modal: boolean;
+        onCloseAutoFocus: ((event: import('..').ModalAutoFocusEvent) => void) | undefined;
+        onEscapeKeyDown: ((event: import('react').KeyboardEvent) => void) | undefined;
+        onInteractOutside: ((event: import('..').ModalOutsideEvent) => void) | undefined;
+        onOpenAutoFocus: ((event: import('..').ModalAutoFocusEvent) => void) | undefined;
+        onPointerDownOutside: ((event: import('..').ModalOutsideEvent) => void) | undefined;
+        open: boolean;
+        preventScroll: boolean;
+        requestClose: () => void;
+        restoreFocus: boolean;
+        role: "dialog" | "alertdialog";
+        setContentRef: (node: HTMLElement | null) => void;
+        setDescriptionPresent: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+        setOpen: (next: boolean) => void;
+        setTitlePresent: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+        shouldRender: boolean;
+        titleId: string;
+        trapFocus: boolean;
+        triggerRef: import('react').RefObject<HTMLElement | null>;
+    };
+    open: boolean;
+};

package/dist/components/Modal/Trigger/ModalTrigger.d.ts

@@ -0,0 +1,5 @@
+import { ModalTriggerProps } from './types';
+export declare const ModalTrigger: {
+    ({ children, asChild, disabled, className, }: ModalTriggerProps): import('react').JSX.Element;
+    displayName: string;
+};

package/dist/components/Modal/Trigger/index.d.ts

@@ -0,0 +1,2 @@
+export { ModalTrigger } from './ModalTrigger';
+export type { ModalTriggerProps } from './types';

package/dist/components/Modal/Trigger/types.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+export type ModalTriggerProps = {
+    /** Trigger content. */
+    children: ReactNode;
+    /** Composes trigger behavior onto a single child element. */
+    asChild?: boolean;
+    /** Disables trigger interaction. */
+    disabled?: boolean;
+    /** Class name applied to the trigger element. */
+    className?: string;
+};

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

@@ -0,0 +1,17 @@
+export type { ModalBodyProps } from './Body';
+export { ModalBody } from './Body';
+export type { ModalCloseProps } from './Close';
+export { ModalClose } from './Close';
+export type { ModalContentPlacement, ModalContentProps, ModalContentSize, ModalScrollBehavior, } from './Content';
+export { ModalContent } from './Content';
+export type { ModalFooterProps } from './Footer';
+export { ModalFooter } from './Footer';
+export type { ModalHeaderProps } from './Header';
+export { ModalDescription, ModalHeader, ModalTitle } from './Header';
+export { Modal } from './Modal';
+export type { ModalOverlayProps } from './Overlay';
+export { ModalOverlay } from './Overlay';
+export { ModalRoot } from './Root';
+export type { ModalTriggerProps } from './Trigger';
+export { ModalTrigger } from './Trigger';
+export type { ModalAutoFocusEvent, ModalOutsideEvent, ModalProps, } from './types';

package/dist/components/Modal/internal/ModalContext.d.ts

@@ -0,0 +1,5 @@
+import { ModalContentContextValue, ModalContextValue } from './types';
+export declare const useModalContext: () => ModalContextValue;
+export declare const useModalContentContext: () => ModalContentContextValue | undefined;
+export declare const ModalProvider: import('react').Provider<ModalContextValue | undefined>;
+export declare const ModalContentProvider: import('react').Provider<ModalContentContextValue | undefined>;

package/dist/components/Modal/internal/composeEventHandlers.d.ts

@@ -0,0 +1 @@
+export { composeEventHandlers, composeRefs } from '../../../utils/compose';

package/dist/components/Modal/internal/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const MODAL_CLOSE_LABEL = "Close dialog";
+export declare const MODAL_Z_INDEX = 1000;

package/dist/components/Modal/internal/types.d.ts

@@ -0,0 +1,37 @@
+import { CSSProperties, KeyboardEvent, MutableRefObject, RefObject } from 'react';
+import { ModalAnimation, ModalAutoFocusEvent, ModalOutsideEvent } from '../types';
+export type ModalContextValue = {
+    animation: ModalAnimation;
+    animationStyle: CSSProperties;
+    closeOnEscape: boolean;
+    closeOnOutsidePress: boolean;
+    contentId: string;
+    contentRef: MutableRefObject<HTMLElement | null>;
+    descriptionId: string;
+    finalFocus?: RefObject<HTMLElement>;
+    initialFocus?: RefObject<HTMLElement>;
+    zIndex?: number;
+    modal: boolean;
+    onCloseAutoFocus?: (event: ModalAutoFocusEvent) => void;
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    onInteractOutside?: (event: ModalOutsideEvent) => void;
+    onOpenAutoFocus?: (event: ModalAutoFocusEvent) => void;
+    onPointerDownOutside?: (event: ModalOutsideEvent) => void;
+    open: boolean;
+    preventScroll: boolean;
+    requestClose: () => void;
+    restoreFocus: boolean;
+    role: 'dialog' | 'alertdialog';
+    setContentRef: (node: HTMLElement | null) => void;
+    setDescriptionPresent: (present: boolean) => void;
+    setOpen: (open: boolean) => void;
+    setTitlePresent: (present: boolean) => void;
+    shouldRender: boolean;
+    titleId: string;
+    trapFocus: boolean;
+    triggerRef: MutableRefObject<HTMLElement | null>;
+};
+export type ModalContentContextValue = {
+    scrollBehavior: 'inside' | 'outside';
+    surfaceStyle?: CSSProperties;
+};

package/dist/components/Modal/internal/useModalAccessibility.d.ts

@@ -0,0 +1 @@
+export { useAriaIsolation as useModalAccessibility } from '../../../hooks/index';

package/dist/components/Modal/internal/useModalDismiss.d.ts

@@ -0,0 +1,19 @@
+import { KeyboardEvent, RefObject } from 'react';
+import { ModalOutsideEvent } from '../types';
+export declare const useModalDismiss: ({ active, registrationActive, id, contentRef, closeOnEscape, closeOnOutsidePress, onEscapeKeyDown, onPointerDownOutside, onInteractOutside, requestClose, }: {
+    active: boolean;
+    registrationActive?: boolean;
+    id: string;
+    contentRef: RefObject<HTMLElement | null>;
+    closeOnEscape: boolean;
+    closeOnOutsidePress: boolean;
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    onPointerDownOutside?: (event: ModalOutsideEvent) => void;
+    onInteractOutside?: (event: ModalOutsideEvent) => void;
+    requestClose: () => void;
+}) => {
+    isTopOverlay: () => boolean;
+    isTopmost: boolean;
+    order: number | undefined;
+    zIndex: number | undefined;
+};

package/dist/components/Modal/internal/useModalFocusTrap.d.ts

@@ -0,0 +1 @@
+export { useFocusScope as useModalFocusTrap } from '../../../hooks/index';

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

@@ -0,0 +1,45 @@
+import { BaseModalProps, ModalAnimation, ModalAnimationDuration, ModalAnimationEasing } from '@vellira-ui/types';
+import { KeyboardEvent, ReactNode, RefObject } from 'react';
+export type ModalAutoFocusEvent = {
+    /** Prevents the default focus movement for this lifecycle event. */
+    preventDefault: () => void;
+    /** Whether default focus movement has been prevented. */
+    defaultPrevented: boolean;
+};
+export type ModalOutsideEvent = {
+    /** Original pointer event that occurred outside the modal content. */
+    originalEvent: PointerEvent | React.PointerEvent<HTMLElement>;
+    /** Prevents the default outside-interaction behavior. */
+    preventDefault: () => void;
+    /** Whether default outside-interaction behavior has been prevented. */
+    defaultPrevented: boolean;
+};
+export interface ModalProps extends BaseModalProps {
+    /** Modal trigger, overlay, content, and compound children. */
+    children: ReactNode;
+    /** Uses modal interaction semantics while open. */
+    modal?: boolean;
+    /** Prevents document scrolling while the modal is open. */
+    preventScroll?: boolean;
+    /** Keeps keyboard focus inside the modal while open. */
+    trapFocus?: boolean;
+    /** Element that should receive focus when the modal opens. */
+    initialFocus?: RefObject<HTMLElement>;
+    /** Element that should receive focus when the modal closes. */
+    finalFocus?: RefObject<HTMLElement>;
+    /** Called before focus moves into the modal after opening. */
+    onOpenAutoFocus?: (event: ModalAutoFocusEvent) => void;
+    /** Called before focus is restored after closing. */
+    onCloseAutoFocus?: (event: ModalAutoFocusEvent) => void;
+    /** Called when Escape is pressed while the modal is open. */
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    /** Called when a pointer down occurs outside modal content. */
+    onPointerDownOutside?: (event: ModalOutsideEvent) => void;
+    /** Called when an interaction occurs outside modal content. */
+    onInteractOutside?: (event: ModalOutsideEvent) => void;
+    /** ARIA role applied to the modal content. */
+    role?: 'dialog' | 'alertdialog';
+    /** Class name applied to the modal root. */
+    className?: string;
+}
+export type { ModalAnimation, ModalAnimationDuration, ModalAnimationEasing };

package/dist/components/Popover/Anchor/PopoverAnchor.d.ts

@@ -0,0 +1,5 @@
+import { PopoverAnchorProps } from './types';
+export declare function PopoverAnchor({ children, asChild, className, ...anchorProps }: PopoverAnchorProps): import('react').JSX.Element;
+export declare namespace PopoverAnchor {
+    var displayName: string;
+}

package/dist/components/Popover/Anchor/index.d.ts

@@ -0,0 +1,2 @@
+export { PopoverAnchor } from './PopoverAnchor';
+export type { PopoverAnchorProps } from './types';

package/dist/components/Popover/Anchor/types.d.ts

@@ -0,0 +1,7 @@
+import { HTMLAttributes, ReactNode } from 'react';
+export interface PopoverAnchorProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** Element used as the positioning anchor. */
+    children: ReactNode;
+    /** Composes anchor behavior onto a single child element. */
+    asChild?: boolean;
+}

package/dist/components/Popover/Arrow/PopoverArrow.d.ts

@@ -0,0 +1,5 @@
+import { PopoverArrowProps } from './types';
+export declare function PopoverArrow({ width, height, tipRadius, align, offset, className, ...arrowProps }: PopoverArrowProps): import('react').JSX.Element;
+export declare namespace PopoverArrow {
+    var displayName: string;
+}