import * as react_jsx_runtime from 'react/jsx-runtime';
import React__default, { RefObject, ReactNode } from 'react';
import { w as ThActionsTriggerVariant, a as ThSheetHeaderVariant, u as ThCollapsibilityVisibility, j as ThShortcutConfig, h as ThActionEntry, g as ThActionsKeys, T as ThDockingKeys, e as ThSheetTypes } from './actions-C33UN3Ji.mjs';
import { TooltipProps, Heading, HeadingProps, PopoverProps } from 'react-aria-components';
import { T as ThActionButtonProps, f as ThMenuItemProps, a as ThCollapsibleActionsBarProps, v as ThSettingsEntry, W as WithRef, t as ThDropdownProps, h as ThNumberFieldProps, k as ThRadioGroupProps, m as ThSliderProps, o as ThSliderWithPresetsProps, q as ThSwitchProps } from './ThSettingsWrapper-D4WIzlXA.mjs';
import { h as ThTextSettingsKeys, b as ThSpacingSettingsKeys, j as ThSettingsGroupPref, o as ThSettingsRangePlaceholder, g as ThSettingsKeys, T as ThLineHeightOptions, a as ThSpacingPresetKeys } from './useContrast-Bl08zDTU.mjs';
import { PressEvent } from 'react-aria';
import { f as SettingsReducerState } from './settingsReducer-Pp9aoiiC.mjs';
import { WebPubSettingsReducerState, ReaderProfile } from './lib/index.mjs';
import { A as ActionsStateKeys } from './actionsReducer-Bzcj3wk3.mjs';
import { e as ThPreferences, D as DefaultKeys, f as ThGlobalPreferences, C as CustomizableKeys, d as ThPreferencesAdapter } from './ThPreferencesAdapter-B3a-f5v-.mjs';
import * as _readium_navigator from '@readium/navigator';
import { EpubSettings, WebPubSettings, FXLFrameManager, FrameManager, ScriptMode, WebPubFrameManager } from '@readium/navigator';
import * as _readium_shared from '@readium/shared';
import { Link, Locator, Publication, Fetcher } from '@readium/shared';
import { E as EpubNavigatorLoadProps, W as WebPubNavigatorLoadProps, A as AudioNavigatorLoadProps, c as AudioSettings, a as useEpubNavigator, b as useWebPubNavigator, u as useAudioNavigator } from './useAudioNavigator-9RuOpLGB.mjs';
import { a as ThAudioPreferences, c as ThAudioPreferencesAdapter } from './usePreferences-Cy7-JN2x.mjs';
import { InitOptions } from 'i18next';
import { P as ProcessedError } from './errorHandler-CL2YIfQY.mjs';

interface UseActionComponentStatusOptions {
    actionKey: string;
    orderArray?: string[];
    additionalCondition?: boolean;
}
interface ActionComponentStatus {
    isComponentRegistered: boolean;
    isInOrder: boolean;
    isComponentAvailable: boolean;
}
/**
 * Generic hook to check if an action component is registered in the plugin registry,
 * in the provided display order array, and meets any additional conditions.
 * Parallel to useSettingsComponentStatus for settings.
 *
 * @param options - Configuration options for the action component status check
 * @returns Object containing status flags for the action component
 */
declare const useActionComponentStatus: (options: UseActionComponentStatusOptions) => ActionComponentStatus;

interface StatefulActionsMapObject {
    Trigger: React.ComponentType<StatefulActionTriggerProps>;
    Target?: React.ComponentType<StatefulActionContainerProps>;
}
interface StatefulActionTriggerProps {
    variant: ThActionsTriggerVariant;
    associatedKey?: ActionsStateKeys;
    ref?: React.Ref<HTMLButtonElement>;
}
interface StatefulActionContainerProps {
    triggerRef: RefObject<HTMLElement | null>;
    placement?: "top" | "bottom";
}

declare const StatefulFullscreenTrigger: ({ variant }: StatefulActionTriggerProps) => react_jsx_runtime.JSX.Element | null;

declare const StatefulJumpToPositionContainer: ({ triggerRef }: StatefulActionContainerProps) => react_jsx_runtime.JSX.Element | null;

declare const StatefulJumpToPositionTrigger: ({ variant }: StatefulActionTriggerProps) => react_jsx_runtime.JSX.Element | null;

interface StatefulSettingsWrapperProps extends StatefulActionContainerProps {
    heading: string;
    headerVariant: ThSheetHeaderVariant;
    onClosePress: () => void;
    dismissEscapeKeyClose?: boolean;
    resetFocus?: unknown;
    onReset?: () => void;
    children: ReactNode;
}
declare const StatefulSettingsWrapper: ({ triggerRef, heading, headerVariant, onClosePress, dismissEscapeKeyClose, resetFocus, onReset, children }: StatefulSettingsWrapperProps) => react_jsx_runtime.JSX.Element;

declare const StatefulAudioSettingsContainer: ({ triggerRef }: StatefulActionContainerProps) => react_jsx_runtime.JSX.Element;

declare const StatefulVisualSettingsContainer: ({ triggerRef }: StatefulActionContainerProps) => react_jsx_runtime.JSX.Element;

declare const StatefulSettingsTrigger: ({ variant }: StatefulActionTriggerProps) => react_jsx_runtime.JSX.Element;

declare const StatefulTocContainer: ({ triggerRef }: StatefulActionContainerProps) => react_jsx_runtime.JSX.Element;

declare const StatefulTocTrigger: ({ variant }: StatefulActionTriggerProps) => react_jsx_runtime.JSX.Element;

interface StatefulActionIconProps extends ThActionButtonProps {
    visibility?: ThCollapsibilityVisibility;
    placement?: TooltipProps["placement"];
    tooltipLabel?: string;
    shortcut?: ThShortcutConfig | null;
}
declare const StatefulActionIcon: ({ ref: externalRef, visibility, placement, tooltipLabel, shortcut, children, ...props }: StatefulActionIconProps) => react_jsx_runtime.JSX.Element;

interface StatefulOverflowMenuItemProps extends Omit<ThMenuItemProps, "shortcut"> {
    shortcut?: ThShortcutConfig | null;
}
declare const StatefulOverflowMenuItem: ({ id, label, SVGIcon, shortcut, ...props }: StatefulOverflowMenuItemProps) => react_jsx_runtime.JSX.Element;

interface StatefulCollapsibleActionsBarProps extends ThCollapsibleActionsBarProps {
    items: ThActionEntry<string | ThActionsKeys | ThDockingKeys>[];
    overflowMenuClassName?: string;
}
declare const StatefulCollapsibleActionsBar: ({ id, items, overflowMenuClassName, ...props }: StatefulCollapsibleActionsBarProps) => react_jsx_runtime.JSX.Element;

interface StatefulOverflowMenuProps {
    id: string;
    items: ThActionEntry<string | ThActionsKeys | ThDockingKeys>[];
    triggerRef: RefObject<HTMLElement | null>;
    className?: string;
    children?: ReactNode;
}
declare const StatefulOverflowMenu: ({ id, className, items, triggerRef }: StatefulOverflowMenuProps) => react_jsx_runtime.JSX.Element | undefined;

declare const useDocking: <T extends string>(key: T) => {
    getDocker: () => ThDockingKeys[];
    sheetType: ThSheetTypes;
};

type ActionComponent = StatefulActionsMapObject;
interface SettingComponent extends ThSettingsEntry {
    type?: "text" | "spacing";
    props?: any;
}
interface ThPlugin {
    id: string;
    name: string;
    description?: string;
    version?: string;
    components: {
        actions?: Record<string, ActionComponent>;
        settings?: Record<string, SettingComponent>;
        primaryAudioActions?: Record<string, ActionComponent>;
    };
}

declare const createDefaultPlugin: () => ThPlugin;

declare const createAudioDefaultPlugin: () => ThPlugin;

interface StatefulGroupWrapperProps<T extends string = ThTextSettingsKeys | ThSpacingSettingsKeys> {
    label: string;
    moreLabel: string;
    moreTooltip: string;
    onPressMore: (e: PressEvent) => void;
    componentsMap: Record<string, SettingComponent>;
    prefs?: ThSettingsGroupPref<T>;
    defaultPrefs: {
        main: T[];
        subPanel: T[];
    };
    isDisabled?: boolean;
    compounds?: {
        /**
         * Custom heading. Can be either:
         * - A React element that will be rendered directly
         * - Props that will be spread onto the default Heading component
         */
        heading?: React.ReactElement<typeof Heading> | WithRef<HeadingProps, HTMLHeadingElement>;
    };
}
declare const StatefulGroupWrapper: <T extends string = ThTextSettingsKeys | ThSpacingSettingsKeys>({ label, moreLabel, moreTooltip, onPressMore, componentsMap, prefs, defaultPrefs, isDisabled, compounds }: StatefulGroupWrapperProps<T>) => react_jsx_runtime.JSX.Element;

interface StatefulDropdownProps extends Omit<ThDropdownProps, "classNames"> {
    standalone?: boolean;
}
declare const StatefulDropdown: ({ standalone, label, className, compounds, ...props }: StatefulDropdownProps) => react_jsx_runtime.JSX.Element;

interface StatefulNumberFieldProps extends Omit<ThNumberFieldProps, "classNames"> {
    standalone?: boolean;
    resetLabel?: string;
    placeholder?: string;
}
declare const StatefulNumberField: ({ standalone, label, placeholder, value, resetLabel, ...props }: StatefulNumberFieldProps) => react_jsx_runtime.JSX.Element;

interface StatefulRadioGroupProps extends Omit<ThRadioGroupProps, "classNames"> {
    standalone?: boolean;
    useGraphicalNavigation?: boolean;
    onEscape?: () => void;
}
declare const StatefulRadioGroup: ({ ref, standalone, useGraphicalNavigation, label, items, value, children, onChange, onEscape, ...props }: StatefulRadioGroupProps) => react_jsx_runtime.JSX.Element;

interface StatefulSliderProps extends Omit<ThSliderProps, "classNames"> {
    standalone?: boolean;
    placeholder?: string;
    resetLabel?: string;
    displayTicks?: boolean;
}
declare const StatefulSlider: ({ standalone, label, placeholder, displayTicks, value, resetLabel, ...props }: StatefulSliderProps) => react_jsx_runtime.JSX.Element;

interface StatefulSliderWithPresetsProps extends Omit<ThSliderWithPresetsProps, "compounds"> {
    standalone?: boolean;
    placeholder?: string;
    resetLabel?: string;
    displayTicks?: boolean;
    hideOutput?: boolean;
    onEscape?: () => void;
}
declare const StatefulSliderWithPresets: ({ standalone, label, placeholder, displayTicks, hideOutput, value, resetLabel, presets, formatValue, onEscape, ...props }: StatefulSliderWithPresetsProps) => react_jsx_runtime.JSX.Element;

interface StatefulSwitchProps extends Omit<ThSwitchProps, "classNames"> {
    standalone?: boolean;
}
declare const StatefulSwitch: ({ standalone, label, heading, ...props }: StatefulSwitchProps) => react_jsx_runtime.JSX.Element;

interface EffectiveRangeResult {
    range: [number, number];
    presets?: number[];
}
/**
 * Returns the effective range and presets to use for a range setting, clamped
 * to the navigator's supported range when provided. Falls back to the preferred
 * range if it fits within the supported range, otherwise uses the supported
 * range directly. Presets outside the effective range are filtered out.
 */
declare const useEffectiveRange: (preferred: [number, number], supportedRange: [number, number] | undefined, presets?: number[]) => EffectiveRangeResult;

interface useGridNavigationProps {
    containerRef: React__default.RefObject<HTMLDivElement | null>;
    items: React__default.RefObject<any[]>;
    currentValue: any;
    onChange: (value: any) => void;
    isRTL?: boolean;
    onEscape?: () => void;
    onFocus?: (value: string) => void;
}
declare const useGridNavigation: ({ containerRef, items, currentValue, onChange, isRTL, onEscape, onFocus }: useGridNavigationProps) => {
    onKeyDown: (e: React__default.KeyboardEvent) => void;
};

declare const useGridTemplate: (ref: React.RefObject<HTMLDivElement | null>, type?: "columns" | "rows") => number | null;

declare const usePlaceholder: (placeholder: ThSettingsRangePlaceholder | string | {
    key: string;
    fallback?: string;
} | undefined, range: [number, number], format?: "percent" | "number" | "multiplier") => string | undefined;

type SharedSettingsKey = keyof SettingsReducerState & keyof WebPubSettingsReducerState;
declare function useReaderSetting(key: "zoom"): number;
declare function useReaderSetting<K extends SharedSettingsKey>(key: K): SettingsReducerState[K];

interface UseSettingsComponentStatusOptions {
    /** The settings key to check (e.g., ThSettingsKeys.spacingPresets) */
    settingsKey: ThSettingsKeys | ThTextSettingsKeys | ThSpacingSettingsKeys;
    /** The publication type to determine which order array to check */
    publicationType?: "reflow" | "fxl" | "webpub";
    /** Optional additional condition that must be true for the component to be considered displayed */
    additionalCondition?: boolean;
}
interface SettingsComponentStatus {
    /** Whether the component is registered in the component map */
    isComponentRegistered: boolean;
    /** Whether the component is included in the main panel display order */
    isInMainPanel: boolean;
    /** Whether the component is included in the sub-panel display order */
    isInSubPanel: boolean;
    /** Whether the component is displayed (in either panel and meets additional conditions) */
    isDisplayed: boolean;
    /** Whether the component is currently being used (both registered AND displayed) */
    isComponentUsed: boolean;
}
/**
 * Generic hook to check if a settings component is registered and displayed.
 * This abstracts the common pattern of checking component registration and display order.
 *
 * @param options - Configuration options for the component status check
 * @returns Object containing various status flags for the component
 */
declare function useSettingsComponentStatus(options: UseSettingsComponentStatusOptions): SettingsComponentStatus;

interface StatefulSettingsItemProps {
    standalone?: boolean;
}

declare const StatefulLetterSpacing: ({ standalone }: StatefulSettingsItemProps) => react_jsx_runtime.JSX.Element;

declare const StatefulLineHeight: ({ standalone }: StatefulSettingsItemProps) => react_jsx_runtime.JSX.Element;

declare const StatefulParagraphIndent: ({ standalone }: StatefulSettingsItemProps) => react_jsx_runtime.JSX.Element;

declare const StatefulParagraphSpacing: ({ standalone }: StatefulSettingsItemProps) => react_jsx_runtime.JSX.Element;

declare const StatefulSpacingGroup: () => react_jsx_runtime.JSX.Element;
declare const StatefulSpacingGroupContainer: () => react_jsx_runtime.JSX.Element;

declare const StatefulSpacingPresets: ({ standalone }: StatefulSettingsItemProps) => react_jsx_runtime.JSX.Element | null;

declare const StatefulWordSpacing: ({ standalone }: StatefulSettingsItemProps) => react_jsx_runtime.JSX.Element;

declare const ORDERED_LINE_HEIGHT_OPTIONS: readonly [ThLineHeightOptions.small, ThLineHeightOptions.medium, ThLineHeightOptions.large];
declare const useLineHeight: () => {
    values: {
        publisher: null;
        small: any;
        medium: any;
        large: any;
    };
    compensatedValues: {
        publisher: null;
        small: number | null;
        medium: number | null;
        large: number | null;
    };
    processedValues: Record<ThLineHeightOptions.small | ThLineHeightOptions.medium | ThLineHeightOptions.large, number>;
    compensate: (v: number | null) => number | null;
};

/**
 * Hook to determine if preset system should be active
 * Only active when component is both registered AND displayed
 * This allows us to correctly handle overrides for presets,
 * and states for spacing components
 */
declare const useSpacingPresets: () => {
    currentPreset: ThSpacingPresetKeys;
    getPresetValues: (presetKey: ThSpacingPresetKeys) => {
        letterSpacing: any;
        lineHeight: any;
        paragraphIndent: any;
        paragraphSpacing: any;
        wordSpacing: any;
    };
    getEffectiveSpacingValue: {
        (key: ThSpacingSettingsKeys.letterSpacing): number | null;
        (key: ThSpacingSettingsKeys.lineHeight): ThLineHeightOptions | null;
        (key: ThSpacingSettingsKeys.paragraphIndent): number | null;
        (key: ThSpacingSettingsKeys.paragraphSpacing): number | null;
        (key: ThSpacingSettingsKeys.wordSpacing): number | null;
    };
    getSpacingResetValue: {
        (key: ThSpacingSettingsKeys.letterSpacing): number | null;
        (key: ThSpacingSettingsKeys.lineHeight): ThLineHeightOptions | null;
        (key: ThSpacingSettingsKeys.paragraphIndent): number | null;
        (key: ThSpacingSettingsKeys.paragraphSpacing): number | null;
        (key: ThSpacingSettingsKeys.wordSpacing): number | null;
    };
    canBeReset: (key: ThSpacingSettingsKeys) => boolean;
    setLetterSpacing: (value: number | null) => void;
    setLineHeight: (value: ThLineHeightOptions) => void;
    setParagraphIndent: (value: number | null) => void;
    setParagraphSpacing: (value: number | null) => void;
    setWordSpacing: (value: number | null) => void;
    setPublisherStyles: (value: boolean) => void;
};

declare const StatefulFontFamily: ({ standalone }: StatefulSettingsItemProps & {
    publicationLanguage?: string;
}) => react_jsx_runtime.JSX.Element;

declare const UnstableStatefulFontWeight: ({ standalone }: StatefulSettingsItemProps) => react_jsx_runtime.JSX.Element;

declare const StatefulHyphens: ({ standalone }: StatefulSettingsItemProps) => react_jsx_runtime.JSX.Element;

declare const StatefulTextAlign: ({ standalone }: StatefulSettingsItemProps) => react_jsx_runtime.JSX.Element;

declare const StatefulTextGroup: () => react_jsx_runtime.JSX.Element;
declare const StatefulTextGroupContainer: () => react_jsx_runtime.JSX.Element;

declare const StatefulTextNormalize: ({ standalone }: StatefulSettingsItemProps) => react_jsx_runtime.JSX.Element;

declare const StatefulLigatures: ({ standalone }: StatefulSettingsItemProps) => react_jsx_runtime.JSX.Element;

declare const StatefulNoRuby: ({ standalone }: StatefulSettingsItemProps) => react_jsx_runtime.JSX.Element;

declare const StatefulPublisherStyles: ({ standalone }: StatefulSettingsItemProps) => react_jsx_runtime.JSX.Element;

declare const StatefulTheme: () => react_jsx_runtime.JSX.Element;

declare const StatefulZoom: () => react_jsx_runtime.JSX.Element;

interface StatefulSheet {
    id: ActionsStateKeys;
    triggerRef: RefObject<HTMLElement | null>;
    heading: string;
    headerVariant?: ThSheetHeaderVariant;
    className?: string;
    underlayClassName?: string;
    headerClassName?: string;
    isOpen: boolean;
    onOpenChange: (isOpen: boolean) => void;
    onClosePress: () => void;
    docker?: ThDockingKeys[];
    children?: ReactNode;
    resetFocus?: unknown;
    focusWithinRef?: RefObject<HTMLElement | null>;
    focusSelector?: string;
    scrollTopOnFocus?: boolean;
    dismissEscapeKeyClose?: boolean;
}

interface StatefulBottomSheetProps extends StatefulSheet {
}
interface ScrimPref {
    active: boolean;
    override?: string;
}
declare const StatefulBottomSheet: ({ id, heading, headerVariant, className, isOpen, onOpenChange, onClosePress, children, resetFocus, focusWithinRef, focusSelector, scrollTopOnFocus, dismissEscapeKeyClose }: StatefulBottomSheetProps) => react_jsx_runtime.JSX.Element | undefined;

interface StatefulCompactPopoverSheetProps extends StatefulSheet {
    placement?: PopoverProps["placement"];
}
declare const StatefulCompactPopoverSheet: ({ id, triggerRef, heading, className, isOpen, onOpenChange, placement, children, resetFocus, focusWithinRef, focusSelector, scrollTopOnFocus, dismissEscapeKeyClose }: StatefulCompactPopoverSheetProps) => react_jsx_runtime.JSX.Element | undefined;

interface StatefulDockedSheetProps extends StatefulSheet {
    flow: ThDockingKeys.start | ThDockingKeys.end | null;
}
declare const StatefulDockedSheet: ({ id, heading, headerVariant, className, isOpen, onClosePress, docker, flow, children, resetFocus, focusSelector, focusWithinRef }: StatefulDockedSheetProps) => react_jsx_runtime.JSX.Element | undefined;

interface StatefulFullScreenSheetProps extends StatefulSheet {
}
declare const StatefulFullScreenSheet: (props: StatefulFullScreenSheetProps) => react_jsx_runtime.JSX.Element;

interface StatefulModalSheetProps extends StatefulSheet {
}
declare const StatefulModalSheet: (props: StatefulModalSheetProps) => react_jsx_runtime.JSX.Element;

interface StatefulPopoverSheetProps extends StatefulSheet {
    placement?: PopoverProps["placement"];
}
declare const StatefulPopoverSheet: ({ id, triggerRef, heading, headerVariant, className, headerClassName, isOpen, onOpenChange, onClosePress, placement, docker, children, resetFocus, focusWithinRef, focusSelector, scrollTopOnFocus, dismissEscapeKeyClose }: StatefulPopoverSheetProps) => react_jsx_runtime.JSX.Element | undefined;

interface StatefulModalBaseProps extends StatefulSheet {
    sheetClassName: string;
    dialogClassName?: string;
}
declare const StatefulModalBase: ({ id, heading, headerVariant, className, sheetClassName, dialogClassName, isOpen, onOpenChange, onClosePress, docker, children, resetFocus, focusWithinRef, focusSelector, scrollTopOnFocus, dismissEscapeKeyClose }: StatefulModalBaseProps) => react_jsx_runtime.JSX.Element | undefined;

declare const StatefulSheetWrapper: ({ sheetType, sheetProps, children }: {
    sheetType: ThSheetTypes;
    sheetProps: StatefulPopoverSheetProps | StatefulModalSheetProps | StatefulFullScreenSheetProps | StatefulDockedSheetProps | StatefulBottomSheetProps;
    children: ReactNode;
}) => react_jsx_runtime.JSX.Element;

declare const StatefulPreferencesProvider: ({ children, initialPreferences }: {
    children: ReactNode;
    initialPreferences?: ThPreferences<DefaultKeys>;
}) => react_jsx_runtime.JSX.Element;

declare const StatefulGlobalPreferencesProvider: ({ children, initialPreferences, }: {
    children: ReactNode;
    initialPreferences?: ThGlobalPreferences;
}) => react_jsx_runtime.JSX.Element;

type VisualNavigator = ReturnType<typeof useEpubNavigator> | ReturnType<typeof useWebPubNavigator>;
type MediaNavigator = ReturnType<typeof useAudioNavigator>;
type AllVisualSettings = EpubSettings & WebPubSettings;
type NavigationCallback = (ok: boolean) => void;
interface UnifiedNavigator {
    go(locator: Locator, animated: boolean, callback: NavigationCallback): void;
    goLink(link: Link, animated: boolean, callback: NavigationCallback): void;
    currentLocator(): Locator | undefined;
    previousLocator(): Locator | null;
    nextLocator(): Locator | null;
    goForward(animated: boolean, callback: NavigationCallback): void;
    goBackward(animated: boolean, callback: NavigationCallback): void;
    isVisual(): boolean;
    getScriptMode(): ScriptMode | undefined;
    getCframes?(): (FXLFrameManager | FrameManager | WebPubFrameManager | undefined)[] | undefined;
    underlying: VisualNavigator | MediaNavigator;
}
declare const useNavigator: () => {
    readonly visual: {
        getSetting: <K extends keyof AllVisualSettings>(settingKey: K) => AllVisualSettings[K];
        EpubNavigatorLoad: (config: EpubNavigatorLoadProps, cb: Function) => void;
        EpubNavigatorDestroy: (cb: Function) => void;
        goRight: (animated: boolean, callback: (ok: boolean) => void) => void;
        goLeft: (animated: boolean, callback: (ok: boolean) => void) => void;
        goBackward: (animated: boolean, callback: (ok: boolean) => void) => void;
        goForward: (animated: boolean, callback: (ok: boolean) => void) => void;
        goLink: (link: Link, animated: boolean, callback: (ok: boolean) => void) => void;
        go: (locator: Locator, animated: boolean, callback: (ok: boolean) => void) => void;
        navLayout: () => _readium_shared.Layout | undefined;
        currentLocator: () => Locator | undefined;
        previousLocator: () => Locator | null | undefined;
        nextLocator: () => Locator | null | undefined;
        currentPositions: () => number[] | null | undefined;
        canGoBackward: () => boolean | undefined;
        canGoForward: () => boolean | undefined;
        isScrollStart: () => boolean | undefined;
        isScrollEnd: () => boolean | undefined;
        preferencesEditor: _readium_navigator.EpubPreferencesEditor | undefined;
        submitPreferences: (preferences: _readium_navigator.IEpubPreferences) => Promise<void>;
        getCframes: () => (FXLFrameManager | FrameManager | undefined)[] | undefined;
        getScriptMode: () => ScriptMode | undefined;
    } | {
        getSetting: <K extends keyof AllVisualSettings>(settingKey: K) => AllVisualSettings[K];
        WebPubNavigatorLoad: (config: WebPubNavigatorLoadProps, cb: Function) => void;
        WebPubNavigatorDestroy: (cb: Function) => void;
        goRight: (animated: boolean, callback: (ok: boolean) => void) => void;
        goLeft: (animated: boolean, callback: (ok: boolean) => void) => void;
        goBackward: (animated: boolean, callback: (ok: boolean) => void) => void;
        goForward: (animated: boolean, callback: (ok: boolean) => void) => void;
        goLink: (link: Link, animated: boolean, callback: (ok: boolean) => void) => void;
        go: (locator: Locator, animated: boolean, callback: (ok: boolean) => void) => void;
        currentLocator: () => Locator | undefined;
        previousLocator: () => Locator | null | undefined;
        nextLocator: () => Locator | null | undefined;
        currentPositions: () => number[] | null | undefined;
        canGoBackward: () => boolean | undefined;
        canGoForward: () => boolean | undefined;
        isScrollStart: () => boolean | undefined;
        isScrollEnd: () => boolean | undefined;
        preferencesEditor: _readium_navigator.WebPubPreferencesEditor | undefined;
        submitPreferences: (preferences: _readium_navigator.IWebPubPreferences) => Promise<void>;
        getCframes: () => (WebPubFrameManager | undefined)[] | undefined;
        getScriptMode: () => ScriptMode | undefined;
    };
    readonly media: {
        AudioNavigatorLoad: (config: AudioNavigatorLoadProps, cb: Function) => void;
        AudioNavigatorDestroy: (cb: Function) => void;
        play: () => void;
        pause: () => void;
        stop: () => void;
        seek: (time: number) => void;
        jump: (seconds: number) => void;
        skipForward: () => void;
        skipBackward: () => void;
        go: (locator: Locator, animated: boolean, callback: (ok: boolean) => void) => void;
        goLink: (link: Link, animated: boolean, callback: (ok: boolean) => void) => void;
        goForward: (animated: boolean, callback: (ok: boolean) => void) => void;
        goBackward: (animated: boolean, callback: (ok: boolean) => void) => void;
        currentLocator: () => Locator | undefined;
        canGoBackward: () => boolean;
        canGoForward: () => boolean;
        isTrackStart: () => boolean;
        isTrackEnd: () => boolean;
        isPlaying: () => boolean;
        isPaused: () => boolean;
        duration: () => number;
        currentTime: () => number;
        preferencesEditor: _readium_navigator.AudioPreferencesEditor | undefined;
        remotePlayback: RemotePlayback | undefined;
        getSetting: <K extends keyof AudioSettings>(settingKey: K) => number | boolean | undefined;
        submitPreferences: (preferences: _readium_navigator.IAudioPreferences) => Promise<void>;
        timeline: () => _readium_shared.Timeline | undefined;
    };
    readonly unified: UnifiedNavigator;
};

interface PositionStorage {
    get: () => Locator | undefined;
    set: (locator: Locator) => void | Promise<void>;
}
interface StatefulReaderProps {
    publication: Publication;
    localDataKey: string | null;
    plugins?: ThPlugin[];
    positionStorage?: PositionStorage;
    containerRefSetter?: (el: Element | null) => void;
}
type ThPluginFactory = () => ThPlugin[] | Promise<ThPlugin[]>;
interface ReaderPlugins {
    epub?: ThPluginFactory;
    webPub?: ThPluginFactory;
    audio?: ThPluginFactory;
}
interface ReaderComponentProps<P extends "epub" | "webPub" | "audio" | undefined | null = undefined, K extends CustomizableKeys = {}> {
    profile: P;
    publication: Publication;
    localDataKey: string | null;
    isLoading?: boolean;
    positionStorage?: PositionStorage;
    plugins?: ReaderPlugins;
    i18n?: Partial<InitOptions>;
    preferences?: P extends "audio" ? {
        initialPreferences?: ThAudioPreferences<K>;
        adapter?: ThAudioPreferencesAdapter<K>;
    } : P extends "epub" | "webPub" ? {
        initialPreferences?: ThPreferences<K>;
        adapter?: ThPreferencesAdapter<K>;
    } : never;
}
declare const StatefulReaderWrapper: ({ profile, plugins, isLoading, preferences, i18n: i18nOptions, ...props }: ReaderComponentProps<any, any>) => react_jsx_runtime.JSX.Element | null;

interface UsePublicationOptions {
    url: string;
    onError?: (error: ProcessedError) => void;
    fetcher?: Fetcher;
}
interface UsePublicationReturn {
    isLoading: boolean;
    error: ProcessedError | null;
    publication: Publication | null;
    manifest: object | null;
    selfLink: string | null;
    localDataKey: string | null;
    profile: ReaderProfile | null;
    isRTL: boolean;
    isFXL: boolean;
    hasDisplayTransformability: boolean;
}
declare const usePublication: ({ url, onError, fetcher: customFetcher }: UsePublicationOptions) => UsePublicationReturn;

interface ReaderTransitions {
    isImmersive: boolean;
    isFullscreen: boolean;
    isScroll: boolean;
    hasUserNavigated: boolean;
    wasImmersive: boolean;
    wasFullscreen: boolean;
    wasScroll: boolean;
    wasUserNavigated: boolean;
    fromImmersive: boolean;
    toImmersive: boolean;
    fromFullscreen: boolean;
    toFullscreen: boolean;
    fromScroll: boolean;
    toScroll: boolean;
    fromUserNavigation: boolean;
    toUserNavigation: boolean;
}
declare const useReaderTransitions: () => ReaderTransitions;

export { StatefulParagraphSpacing as $, type StatefulGroupWrapperProps as A, StatefulGroupWrapper as B, type StatefulDropdownProps as C, StatefulDropdown as D, type StatefulNumberFieldProps as E, StatefulNumberField as F, type StatefulRadioGroupProps as G, StatefulRadioGroup as H, type StatefulSliderProps as I, StatefulSlider as J, type StatefulSliderWithPresetsProps as K, StatefulSliderWithPresets as L, type StatefulSwitchProps as M, StatefulSwitch as N, useEffectiveRange as O, type useGridNavigationProps as P, useGridNavigation as Q, useGridTemplate as R, type StatefulActionsMapObject as S, type ThPlugin as T, usePlaceholder as U, useReaderSetting as V, useSettingsComponentStatus as W, type StatefulSettingsItemProps as X, StatefulLetterSpacing as Y, StatefulLineHeight as Z, StatefulParagraphIndent as _, usePublication as a, StatefulSpacingGroup as a0, StatefulSpacingGroupContainer as a1, StatefulSpacingPresets as a2, StatefulWordSpacing as a3, ORDERED_LINE_HEIGHT_OPTIONS as a4, useLineHeight as a5, useSpacingPresets as a6, StatefulFontFamily as a7, UnstableStatefulFontWeight as a8, StatefulHyphens as a9, StatefulPreferencesProvider as aA, StatefulGlobalPreferencesProvider as aB, type PositionStorage as aC, type StatefulReaderProps as aD, type ThPluginFactory as aE, type ReaderPlugins as aF, type ReaderComponentProps as aG, StatefulReaderWrapper as aH, StatefulTextAlign as aa, StatefulTextGroup as ab, StatefulTextGroupContainer as ac, StatefulTextNormalize as ad, StatefulLigatures as ae, StatefulNoRuby as af, StatefulPublisherStyles as ag, StatefulTheme as ah, StatefulZoom as ai, type StatefulBottomSheetProps as aj, type ScrimPref as ak, StatefulBottomSheet as al, type StatefulCompactPopoverSheetProps as am, StatefulCompactPopoverSheet as an, type StatefulDockedSheetProps as ao, StatefulDockedSheet as ap, type StatefulFullScreenSheetProps as aq, StatefulFullScreenSheet as ar, type StatefulModalSheetProps as as, StatefulModalSheet as at, type StatefulPopoverSheetProps as au, StatefulPopoverSheet as av, type StatefulModalBaseProps as aw, StatefulModalBase as ax, StatefulSheetWrapper as ay, type StatefulSheet as az, useReaderTransitions as b, useActionComponentStatus as c, type StatefulActionTriggerProps as d, type StatefulActionContainerProps as e, StatefulFullscreenTrigger as f, StatefulJumpToPositionContainer as g, StatefulJumpToPositionTrigger as h, StatefulSettingsWrapper as i, StatefulAudioSettingsContainer as j, StatefulVisualSettingsContainer as k, StatefulSettingsTrigger as l, StatefulTocContainer as m, StatefulTocTrigger as n, type StatefulActionIconProps as o, StatefulActionIcon as p, type StatefulOverflowMenuItemProps as q, StatefulOverflowMenuItem as r, type StatefulCollapsibleActionsBarProps as s, StatefulCollapsibleActionsBar as t, useNavigator as u, type StatefulOverflowMenuProps as v, StatefulOverflowMenu as w, useDocking as x, createDefaultPlugin as y, createAudioDefaultPlugin as z };