import { a as ActionStateObject } from '../../actionsReducer-Bzcj3wk3.mjs';
import { T as ThDockingKeys } from '../../actions-C33UN3Ji.mjs';
export { C as CollapsiblePref, h as ThActionEntry, x as ThActionsBar, i as ThActionsBarProps, w as ThActionsTriggerVariant, d as ThCollapsibility, u as ThCollapsibilityVisibility, v as useCollapsibility } from '../../actions-C33UN3Ji.mjs';
import { T as ThActionButtonProps, W as WithRef, H as HTMLAttributesWithRef } from '../../ThSettingsWrapper-D4WIzlXA.mjs';
export { d as THMenuProps, c as ThActionButton, b as ThCollapsibleActionsBar, a as ThCollapsibleActionsBarProps, u as ThDropdown, s as ThDropdownEntry, t as ThDropdownProps, e as ThMenu, g as ThMenuItem, f as ThMenuItemProps, i as ThNumberField, h as ThNumberFieldProps, l as ThRadioGroup, j as ThRadioGroupItems, k as ThRadioGroupProps, v as ThSettingsEntry, w as ThSettingsPrefs, y as ThSettingsWrapper, x as ThSettingsWrapperProps, n as ThSlider, m as ThSliderProps, p as ThSliderWithPresets, o as ThSliderWithPresetsProps, r as ThSwitch, q as ThSwitchProps } from '../../ThSettingsWrapper-D4WIzlXA.mjs';
import * as react_jsx_runtime from 'react/jsx-runtime';
import { ButtonProps, SliderProps, SliderTrackProps, SliderThumbProps, HeadingProps, PopoverProps, DialogProps, ModalOverlayProps, FormProps, Button, NumberFieldProps, LabelProps, InputProps, FieldErrorProps, TextFieldProps, ValidationResult, SearchFieldProps, LinkProps, TooltipProps } from 'react-aria-components';
import { PositionProps, OverlayContainerProps, AriaOverlayProps, TooltipTriggerProps } from 'react-aria';
import React__default, { RefObject, ReactNode, HTMLAttributes, ComponentType, SVGProps } from 'react';
import { SheetRef, Sheet } from 'react-modal-sheet';
import '@reduxjs/toolkit';
import '../../immer.d-CoRThNOF.mjs';
import '../../ui-DnZZhozX.mjs';
import '@readium/navigator-html-injectables';

declare const ThCloseButton: ({ label, ref, compounds, children, ...props }: ThActionButtonProps) => react_jsx_runtime.JSX.Element;

declare const ThDeleteButton: ({ label, ref, compounds, children, ...props }: ThActionButtonProps) => react_jsx_runtime.JSX.Element;

interface ThDragIndicatorButtonProps extends ButtonProps {
    ref?: React.ForwardedRef<HTMLButtonElement>;
}
declare const ThDragIndicatorButton: ({ ref, children, ...props }: ThDragIndicatorButtonProps) => react_jsx_runtime.JSX.Element;

interface ThNavigationButtonProps extends ThActionButtonProps {
    direction?: "left" | "right";
}
declare const ThNavigationButton: ({ direction, label, ref, compounds, children, ...props }: ThNavigationButtonProps) => react_jsx_runtime.JSX.Element;

interface ThActionMap {
    [key: string | number | symbol]: ActionStateObject | undefined;
}
declare const useActions: <K extends string | number | symbol>(actionMap: ThActionMap) => {
    findOpen: () => K[];
    anyOpen: () => boolean;
    isOpen: (key?: K | null) => boolean;
    findDocked: () => K[];
    anyDocked: () => boolean;
    isDocked: (key?: K | null) => boolean;
    whichDocked: (key?: K | null) => ThDockingKeys | null | undefined;
    getDockedWidth: (key?: K | null) => number | undefined;
    everyOpenDocked: () => boolean;
};

interface SeekableRange {
    start: number;
    end: number;
}
interface TimelineSegment {
    title?: string;
    timestamp: number;
    percentage: number;
}
interface ThAudioProgressProps {
    isDisabled?: boolean;
    currentTime: number;
    duration: number;
    playbackRate?: number;
    onSeek: (time: number) => void;
    currentChapter?: string;
    seekableRanges?: SeekableRange[];
    hoverLabel?: string;
    onHoverProgression?: (progression: number | null) => void;
    segments?: TimelineSegment[];
    compounds?: {
        wrapper?: React.HTMLAttributes<HTMLDivElement>;
        current?: React.HTMLAttributes<HTMLDivElement>;
        slider?: WithRef<SliderProps, HTMLDivElement>;
        track?: WithRef<SliderTrackProps, HTMLDivElement>;
        thumb?: WithRef<SliderThumbProps, HTMLDivElement>;
        elapsedTime?: React.HTMLAttributes<HTMLSpanElement>;
        remainingTime?: React.HTMLAttributes<HTMLSpanElement>;
        seekableRange?: React.HTMLAttributes<HTMLDivElement>;
        fragmentTick?: React.HTMLAttributes<HTMLDivElement>;
        tooltip?: WithRef<PositionProps & React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
        overlayContainer?: OverlayContainerProps;
    };
}
declare const ThAudioProgress: ({ isDisabled, currentTime, duration, playbackRate, onSeek, currentChapter, seekableRanges, hoverLabel, onHoverProgression, segments, compounds }: ThAudioProgressProps) => react_jsx_runtime.JSX.Element;

type ScrollOptions = {
    behavior?: ScrollBehavior;
    block?: ScrollLogicalPosition;
    inline?: ScrollLogicalPosition;
};
type Action = {
    type: "focus";
    options?: {
        preventScroll?: boolean;
        scrollContainerToTop?: boolean;
    };
} | {
    type: "scrollIntoView";
    options?: ScrollOptions;
} | {
    type: "none";
};
interface UseFirstFocusableProps {
    withinRef: RefObject<HTMLElement | null>;
    fallbackRef?: RefObject<HTMLElement | null>;
    scrollerRef?: RefObject<HTMLElement | null>;
    trackedState?: boolean;
    updateState?: unknown;
    action?: Action;
    withSelector?: string;
}
declare const useFirstFocusable: (props?: UseFirstFocusableProps) => HTMLElement | null;

interface ThContainerHeaderProps extends HTMLAttributesWithRef<HTMLDivElement> {
    ref?: React.ForwardedRef<HTMLDivElement>;
    label: string;
    compounds?: {
        heading?: WithRef<HeadingProps, HTMLHeadingElement>;
    };
}
declare const ThContainerHeader: ({ ref, label, compounds, children, ...props }: ThContainerHeaderProps) => react_jsx_runtime.JSX.Element;

interface THContainerWithCloseProps extends ThContainerHeaderProps {
    closeRef?: React.ForwardedRef<HTMLButtonElement>;
    children?: never;
    compounds?: {
        heading: WithRef<HeadingProps, HTMLHeadingElement>;
        button: ThActionButtonProps;
    };
}
declare const ThContainerHeaderWithClose: ({ ref, closeRef, label, compounds, ...props }: THContainerWithCloseProps) => react_jsx_runtime.JSX.Element;

interface THContainerWithPreviousProps extends ThContainerHeaderProps {
    previousRef?: React.ForwardedRef<HTMLButtonElement>;
    children?: never;
    compounds?: {
        heading: WithRef<HeadingProps, HTMLHeadingElement>;
        button: ThNavigationButtonProps;
    };
}
declare const ThContainerHeaderWithPrevious: ({ ref, previousRef, label, compounds, ...props }: THContainerWithPreviousProps) => react_jsx_runtime.JSX.Element;

interface ThContainerBodyProps extends HTMLAttributesWithRef<HTMLDivElement> {
}
declare const ThContainerBody: ({ ref, children, ...props }: ThContainerBodyProps) => react_jsx_runtime.JSX.Element;

interface ThContainerProps {
    id?: string;
    ref?: React__default.RefObject<HTMLDivElement | SheetRef | null>;
    focusOptions?: UseFirstFocusableProps;
    children: [React__default.ReactElement<ThContainerHeaderProps>, React__default.ReactElement<ThContainerBodyProps>];
}

interface ThPopoverProps extends Omit<PopoverProps, "children">, ThContainerProps {
    triggerRef: React__default.RefObject<HTMLElement | null>;
    compounds?: {
        dialog: WithRef<DialogProps, HTMLDivElement>;
    };
}
declare const ThPopover: ({ ref, id, triggerRef, focusOptions, compounds, maxHeight, children, ...props }: ThPopoverProps) => react_jsx_runtime.JSX.Element;

interface ThModalProps extends Omit<ModalOverlayProps, "children">, ThContainerProps {
    compounds?: {
        dialog: WithRef<DialogProps, HTMLDivElement>;
    };
}
declare const ThModal: ({ ref, id, focusOptions, compounds, children, ...props }: ThModalProps) => react_jsx_runtime.JSX.Element;

interface ThDockedPanelProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, "children">, ThContainerProps {
    isOpen: boolean;
    portal: HTMLElement | null;
}
declare const ThDockedPanel: ({ ref, isOpen, portal, focusOptions, children, ...props }: ThDockedPanelProps) => react_jsx_runtime.JSX.Element;

interface ThBottomSheetHeaderProps extends ThContainerHeaderProps {
    wrapper: React__default.ComponentProps<typeof Sheet.Header>;
    dragIndicator: React__default.ComponentProps<typeof ThDragIndicatorButton>;
    header: ThContainerHeaderProps;
    heading: HeadingProps;
}
interface ThBottomSheetCompounds {
    container?: Omit<React__default.ComponentProps<typeof Sheet.Container>, "children">;
    header?: React__default.ComponentProps<typeof Sheet.Header>;
    dragIndicator?: ThDragIndicatorButtonProps;
    scroller?: {
        ref?: React__default.RefObject<HTMLDivElement>;
        className?: string;
    };
    content?: React__default.ComponentProps<typeof Sheet.Content>;
    backdrop?: React__default.ComponentProps<typeof Sheet.Backdrop>;
}
interface ThBottomSheetProps extends Omit<React__default.ComponentProps<typeof Sheet>, "children" | "ref" | "isOpen" | "onClose">, AriaOverlayProps, ThContainerProps {
    onOpenChange?: (isOpen: boolean) => void;
    isKeyboardDismissDisabled?: boolean;
    compounds?: ThBottomSheetCompounds;
}
declare const ThBottomSheet: ({ isOpen, onOpenChange, ref, focusOptions, isKeyboardDismissDisabled, detent, snapPoints, compounds, children, ...props }: ThBottomSheetProps) => react_jsx_runtime.JSX.Element;

type ComponentMap<T extends string> = {
    [type in T]: React__default.ComponentType<any>;
};
interface TypedComponentRendererProps<T extends string, K extends keyof ComponentMap<T>> {
    type: K;
    componentMap: ComponentMap<T>;
    props?: any;
    children?: ReactNode;
}
declare const ThTypedComponentRenderer: <T extends string, K extends keyof ComponentMap<T>>({ type, componentMap, props, children, }: TypedComponentRendererProps<T, K>) => React__default.ReactElement<any, string | React__default.JSXElementConstructor<any>>;

interface ThFormProps extends FormProps {
    ref?: React__default.ForwardedRef<HTMLFormElement>;
    label: string;
    compounds?: {
        button?: Exclude<WithRef<ButtonProps, HTMLButtonElement>, "type"> | React__default.ReactElement<typeof Button>;
    };
}
declare const ThForm: ({ ref, label, compounds, children, ...props }: ThFormProps) => react_jsx_runtime.JSX.Element;

interface ThFormNumberFieldProps extends NumberFieldProps {
    ref?: React.ForwardedRef<HTMLInputElement>;
    onInputChange?: (rawValue: string) => void;
    label?: string;
    compounds?: {
        label?: WithRef<LabelProps, HTMLLabelElement>;
        input?: WithRef<InputProps, HTMLInputElement>;
        description?: string;
        fieldError?: WithRef<FieldErrorProps, HTMLDivElement>;
    };
    errorMessage?: string;
}
declare const ThFormNumberField: ({ ref, onInputChange, label, compounds, children, errorMessage, ...props }: ThFormNumberFieldProps) => react_jsx_runtime.JSX.Element;

interface ThFormTextFieldProps extends TextFieldProps {
    ref?: React.ForwardedRef<HTMLInputElement>;
    label?: string;
    compounds?: {
        label?: WithRef<LabelProps, HTMLLabelElement>;
        input?: WithRef<InputProps, HTMLInputElement>;
        description?: string;
        fieldError?: WithRef<FieldErrorProps, HTMLDivElement>;
    };
    errorMessage?: string | ((validation: ValidationResult) => string);
}
declare const ThFormTextField: ({ ref, label, children, compounds, errorMessage, ...props }: ThFormTextFieldProps) => react_jsx_runtime.JSX.Element;

interface ThFormSearchFieldProps extends SearchFieldProps {
    ref?: React__default.ForwardedRef<HTMLInputElement>;
    label?: string;
    compounds?: {
        label?: WithRef<LabelProps, HTMLLabelElement>;
        input?: WithRef<InputProps, HTMLInputElement>;
        searchIcon?: HTMLAttributes<HTMLDivElement> | React__default.ReactElement<HTMLDivElement>;
        clearButton?: ThActionButtonProps | React__default.ReactElement<ThActionButtonProps>;
        description?: string;
        fieldError?: WithRef<FieldErrorProps, HTMLDivElement>;
    };
    errorMessage?: string | ((validation: ValidationResult) => string);
}
declare const ThFormSearchField: ({ ref, label, children, compounds, errorMessage, ...props }: ThFormSearchFieldProps) => react_jsx_runtime.JSX.Element;

interface ThLinkProps extends LinkProps {
    ref?: React.ForwardedRef<HTMLAnchorElement>;
    href: string;
    children: React.ReactNode;
    compounds?: {
        /**
         * Props for the tooltipTrigger component. See `TooltipTriggerProps` for more information.
         */
        tooltipTrigger?: WithRef<TooltipTriggerProps, HTMLDivElement>;
        /**
         * Props for the tooltip component. See `TooltipProps` for more information.
         */
        tooltip?: WithRef<TooltipProps, HTMLDivElement>;
        /**
         * String for the tooltip
         */
        label: string;
    };
}
interface ThLinkIconProps extends Omit<ThLinkProps, "children"> {
    "aria-label": string;
}
declare const ThLink: ({ ref, href, children, compounds, ...props }: ThLinkProps) => react_jsx_runtime.JSX.Element;

interface ThBackArrowProps extends ThLinkIconProps {
    direction?: "left" | "right";
}
declare const ThBackArrow: ({ ref, href, "aria-label": ariaLabel, direction, ...props }: ThBackArrowProps) => react_jsx_runtime.JSX.Element;

declare const ThHome: ({ ref, href, "aria-label": ariaLabel, ...props }: ThLinkIconProps) => react_jsx_runtime.JSX.Element;

declare const ThLibrary: ({ ref, href, "aria-label": ariaLabel, ...props }: ThLinkIconProps) => react_jsx_runtime.JSX.Element;

declare const ThMenuButton: ({ label, ref, compounds, children, ...props }: ThActionButtonProps) => react_jsx_runtime.JSX.Element;

declare const ThFooter: ({ ref, children, ...props }: HTMLAttributesWithRef<HTMLDivElement>) => react_jsx_runtime.JSX.Element;

interface ThLoaderProps extends Omit<HTMLAttributesWithRef<HTMLDivElement>, "aria-busy" | "aria-live"> {
    ref?: React.ForwardedRef<HTMLDivElement>;
    isLoading: boolean;
    loader: ReactNode;
}
declare const ThLoader: ({ ref, isLoading, loader, children, ...props }: ThLoaderProps) => react_jsx_runtime.JSX.Element;

declare const ThHeader: ({ ref, children, ...props }: HTMLAttributesWithRef<HTMLDivElement>) => react_jsx_runtime.JSX.Element;

interface ThInteractiveOverlayProps extends React.HTMLAttributes<HTMLDivElement> {
    ref?: React.ForwardedRef<HTMLDivElement>;
    isActive: boolean;
    children?: never;
}
declare const ThInteractiveOverlay: ({ ref, isActive, className, style, ...props }: ThInteractiveOverlayProps) => react_jsx_runtime.JSX.Element | undefined;

interface ThPaginationLinkProps {
    icon?: ComponentType<SVGProps<SVGElement>> | null;
    node: React__default.ReactNode;
    onPress: () => void;
}
interface ThPaginationProps extends React__default.HTMLAttributes<HTMLDivElement> {
    ref?: React__default.RefObject<HTMLDivElement>;
    children?: React__default.ReactNode;
    links?: {
        left?: ThPaginationLinkProps;
        right?: ThPaginationLinkProps;
    };
    compounds?: {
        listItem?: React__default.HTMLAttributes<HTMLLIElement>;
        leftButton?: Exclude<WithRef<ButtonProps, HTMLButtonElement>, "type">;
        rightButton?: Exclude<WithRef<ButtonProps, HTMLButtonElement>, "type">;
    };
}
declare const ThPagination: ({ ref, links, compounds, children, dir, ...restProps }: ThPaginationProps) => react_jsx_runtime.JSX.Element | null;

interface ThRunningHeadProps extends HTMLAttributesWithRef<HTMLHeadingElement> {
    ref?: React__default.RefObject<HTMLHeadingElement>;
    label: string;
}
declare const ThRunningHead: ({ ref, label, ...props }: ThRunningHeadProps) => react_jsx_runtime.JSX.Element;

interface ThDropdownButtonProps extends ButtonProps {
    ref?: React.ForwardedRef<HTMLButtonElement>;
}
declare const ThDropdownButton: ({ ref, children, ...props }: ThDropdownButtonProps) => react_jsx_runtime.JSX.Element;

declare const ThSettingsWrapperButton: ({ label, ref, compounds, children, ...props }: ThActionButtonProps) => react_jsx_runtime.JSX.Element;

declare const ThSettingsResetButton: ({ label, ref, compounds, children, ...props }: ThActionButtonProps) => react_jsx_runtime.JSX.Element;

interface ThGridProps<T> extends HTMLAttributesWithRef<HTMLUListElement> {
    items: T[];
    children?: never;
    renderItem: (item: T, index: number) => React__default.ReactNode;
    columnWidth?: number | string;
    gap?: number | string;
}
declare const ThGrid: <T extends unknown>({ ref, items, renderItem, columnWidth, gap, ...props }: ThGridProps<T>) => react_jsx_runtime.JSX.Element;

export { type ComponentMap, type SeekableRange, type THContainerWithCloseProps, type THContainerWithPreviousProps, ThActionButtonProps, type ThActionMap, ThAudioProgress, type ThAudioProgressProps, ThBackArrow, type ThBackArrowProps, ThBottomSheet, type ThBottomSheetCompounds, type ThBottomSheetHeaderProps, type ThBottomSheetProps, ThCloseButton, ThContainerBody, type ThContainerBodyProps, ThContainerHeader, type ThContainerHeaderProps, ThContainerHeaderWithClose, ThContainerHeaderWithPrevious, ThDeleteButton, ThDockedPanel, type ThDockedPanelProps, ThDragIndicatorButton, type ThDragIndicatorButtonProps, ThDropdownButton, type ThDropdownButtonProps, ThFooter, ThForm, ThFormNumberField, type ThFormNumberFieldProps, type ThFormProps, ThFormSearchField, type ThFormSearchFieldProps, ThFormTextField, type ThFormTextFieldProps, ThGrid, type ThGridProps, ThHeader, ThHome, ThInteractiveOverlay, type ThInteractiveOverlayProps, ThLibrary, ThLink, type ThLinkIconProps, type ThLinkProps, ThLoader, type ThLoaderProps, ThMenuButton, ThModal, type ThModalProps, ThNavigationButton, type ThNavigationButtonProps, ThPagination, type ThPaginationLinkProps, type ThPaginationProps, ThPopover, type ThPopoverProps, ThRunningHead, type ThRunningHeadProps, ThSettingsResetButton, ThSettingsWrapperButton, ThTypedComponentRenderer, type TimelineSegment, type TypedComponentRendererProps, type UseFirstFocusableProps, useActions, useFirstFocusable };