import * as react_jsx_runtime from 'react/jsx-runtime';
import * as _reduxjs_toolkit from '@reduxjs/toolkit';
import { PayloadAction, Store } from '@reduxjs/toolkit';
import { W as WritableDraft } from '../immer.d-CoRThNOF.mjs';
import { b as UnstablePlatformModifier } from '../keyboardUtilities-BCP3UcLb.mjs';
import { m as ThSettingsContainerKeys, e as ThColorScheme, f as ThContrast, T as ThLineHeightOptions, c as ThTextAlignOptions, a as ThSpacingPresetKeys } from '../useContrast-Bl08zDTU.mjs';
import { q as ThLayoutDirection, d as ThBreakpoints, i as ThProgressionFormat, h as ThRunningHeadFormat, n as ThPaginatedAffordancePrefValue, j as ThLayoutUI } from '../ui-DnZZhozX.mjs';
import { F as FontFamilyStateObject, e as SpacingStateObject, S as SetFontFamilyPayload, c as SetSpacingPresetPayload, d as SpacingStateKey, f as SettingsReducerState } from '../settingsReducer-Pp9aoiiC.mjs';
export { L as LineLengthStateObject, a as SetLineLengthPayload, b as SetSpacingSettingPayload, h as handleSpacingSetting, i as initialSettingsState, g as setColumnCount, l as setFontFamily, j as setFontSize, k as setFontWeight, m as setHyphens, o as setLetterSpacing, n as setLigatures, p as setLineHeight, q as setLineLength, z as setNoRuby, r as setParagraphIndent, t as setParagraphSpacing, u as setPublisherStyles, v as setScroll, w as setSpacingPreset, x as setTextAlign, y as setTextNormalization, A as setWordSpacing, s as settingsSlice } from '../settingsReducer-Pp9aoiiC.mjs';
import { m as ActionsReducerState } from '../actionsReducer-Bzcj3wk3.mjs';
export { l as ActionKeysState, f as ActionOverflowOpenPayload, c as ActionStateDockPayload, g as ActionStateDockedPayload, a as ActionStateObject, d as ActionStateOpenPayload, h as ActionStateSlotPayload, i as ActionStateSlotPayloadWithProfile, j as ActionStateSlotWidthPayload, e as ActionStateTogglePayload, A as ActionsStateKeys, k as DockState, D as DockStateObject, O as OverflowStateKeys, b as OverflowStateObject, n as actionsSlice, q as activateDockPanel, u as collapseDockPanel, r as deactivateDockPanel, o as dockAction, v as expandDockPanel, s as setActionOpen, w as setDockPanelWidth, p as setOverflow, t as toggleActionOpen } from '../actionsReducer-Bzcj3wk3.mjs';
import { Locator } from '@readium/shared';
import { a as ThemeTokens, e as ThPreferences, C as CustomizableKeys, d as ThPreferencesAdapter, g as ThGlobalPreferencesAdapter, f as ThGlobalPreferences } from '../ThPreferencesAdapter-B3a-f5v-.mjs';
import { ScriptMode } from '@readium/navigator';
import { U as UnstableTimeline, b as TocItem } from '../useTimeline-DCZ1qoCO.mjs';
import { TypedUseSelectorHook } from 'react-redux';
import '../actions-C33UN3Ji.mjs';
import 'react';
import 'react-aria-components';
import '@readium/navigator-html-injectables';

type ReaderProfile = "epub" | "webPub" | "audio" | undefined;
interface ReaderReducerState {
    profile: ReaderProfile;
    direction: ThLayoutDirection;
    isLoading: boolean;
    isImmersive: boolean;
    isHovering: boolean;
    hasScrollAffordance: boolean;
    hasArrows: boolean;
    hasUserNavigated: boolean;
    isFullscreen: boolean;
    settingsContainer: ThSettingsContainerKeys;
    platformModifier: UnstablePlatformModifier;
}
declare const readerSlice: _reduxjs_toolkit.Slice<ReaderReducerState, {
    setReaderProfile: (state: WritableDraft<ReaderReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setDirection: (state: WritableDraft<ReaderReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setLoading: (state: WritableDraft<ReaderReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setPlatformModifier: (state: WritableDraft<ReaderReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setImmersive: (state: WritableDraft<ReaderReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    toggleImmersive: (state: WritableDraft<ReaderReducerState>) => void;
    setHovering: (state: WritableDraft<ReaderReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setScrollAffordance: (state: WritableDraft<ReaderReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setHasArrows: (state: WritableDraft<ReaderReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setUserNavigated: (state: WritableDraft<ReaderReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setFullscreen: (state: WritableDraft<ReaderReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setSettingsContainer: (state: WritableDraft<ReaderReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
}, "reader", "reader", _reduxjs_toolkit.SliceSelectors<ReaderReducerState>>;
declare const setReaderProfile: _reduxjs_toolkit.ActionCreatorWithPayload<any, "reader/setReaderProfile">;
declare const setDirection: _reduxjs_toolkit.ActionCreatorWithPayload<any, "reader/setDirection">;
declare const setLoading: _reduxjs_toolkit.ActionCreatorWithPayload<any, "reader/setLoading">;
declare const setPlatformModifier: _reduxjs_toolkit.ActionCreatorWithPayload<any, "reader/setPlatformModifier">;
declare const setImmersive: _reduxjs_toolkit.ActionCreatorWithPayload<any, "reader/setImmersive">;
declare const toggleImmersive: _reduxjs_toolkit.ActionCreatorWithoutPayload<"reader/toggleImmersive">;
declare const setHovering: _reduxjs_toolkit.ActionCreatorWithPayload<any, "reader/setHovering">;
declare const setScrollAffordance: _reduxjs_toolkit.ActionCreatorWithPayload<any, "reader/setScrollAffordance">;
declare const setHasArrows: _reduxjs_toolkit.ActionCreatorWithPayload<any, "reader/setHasArrows">;
declare const setUserNavigated: _reduxjs_toolkit.ActionCreatorWithPayload<any, "reader/setUserNavigated">;
declare const setFullscreen: _reduxjs_toolkit.ActionCreatorWithPayload<any, "reader/setFullscreen">;
declare const setSettingsContainer: _reduxjs_toolkit.ActionCreatorWithPayload<any, "reader/setSettingsContainer">;

interface ThemeStateObject {
    reflow?: string;
    fxl?: string;
    audio?: string;
}
interface ThemeStateChangePayload {
    type: string;
    payload: {
        key: "reflow" | "fxl" | "audio";
        value?: string;
    };
}
interface ThemeReducerState {
    monochrome: boolean;
    colorScheme: ThColorScheme;
    theme: ThemeStateObject;
    prefersReducedMotion: boolean;
    prefersReducedTransparency: boolean;
    prefersContrast: ThContrast;
    forcedColors: boolean;
    breakpoint?: ThBreakpoints;
    containerBreakpoint?: ThBreakpoints;
}
declare const themeSlice: _reduxjs_toolkit.Slice<ThemeReducerState, {
    setMonochrome: (state: WritableDraft<ThemeReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setColorScheme: (state: WritableDraft<ThemeReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setTheme: (state: WritableDraft<ThemeReducerState>, action: ThemeStateChangePayload) => void;
    setReducedMotion: (state: WritableDraft<ThemeReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setReducedTransparency: (state: WritableDraft<ThemeReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setContrast: (state: WritableDraft<ThemeReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setForcedColors: (state: WritableDraft<ThemeReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setBreakpoint: (state: WritableDraft<ThemeReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setContainerBreakpoint: (state: WritableDraft<ThemeReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
}, "theming", "theming", _reduxjs_toolkit.SliceSelectors<ThemeReducerState>>;
declare const setMonochrome: _reduxjs_toolkit.ActionCreatorWithPayload<any, "theming/setMonochrome">;
declare const setColorScheme: _reduxjs_toolkit.ActionCreatorWithPayload<any, "theming/setColorScheme">;
declare const setTheme: _reduxjs_toolkit.ActionCreatorWithPayload<{
    key: "reflow" | "fxl" | "audio";
    value?: string;
}, "theming/setTheme">;
declare const setReducedMotion: _reduxjs_toolkit.ActionCreatorWithPayload<any, "theming/setReducedMotion">;
declare const setReducedTransparency: _reduxjs_toolkit.ActionCreatorWithPayload<any, "theming/setReducedTransparency">;
declare const setContrast: _reduxjs_toolkit.ActionCreatorWithPayload<any, "theming/setContrast">;
declare const setForcedColors: _reduxjs_toolkit.ActionCreatorWithPayload<any, "theming/setForcedColors">;
declare const setBreakpoint: _reduxjs_toolkit.ActionCreatorWithPayload<any, "theming/setBreakpoint">;
declare const setContainerBreakpoint: _reduxjs_toolkit.ActionCreatorWithPayload<any, "theming/setContainerBreakpoint">;

interface AdjacentTimelineItem {
    title: string;
    href: string;
}
interface PublicationReducerState {
    fontLanguage: string;
    isFXL: boolean;
    isRTL: boolean;
    scriptMode: ScriptMode;
    hasDisplayTransformability: boolean;
    positionsList: Locator[];
    atPublicationStart: boolean;
    atPublicationEnd: boolean;
    unstableTimeline?: UnstableTimeline;
    adjacentTimelineItems: {
        previous: AdjacentTimelineItem | null;
        next: AdjacentTimelineItem | null;
    };
    coverTheme?: ThemeTokens;
}
declare const publicationSlice: _reduxjs_toolkit.Slice<PublicationReducerState, {
    setFontLanguage: (state: WritableDraft<PublicationReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setFXL: (state: WritableDraft<PublicationReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setRTL: (state: WritableDraft<PublicationReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setScriptMode: (state: WritableDraft<PublicationReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setHasDisplayTransformability: (state: WritableDraft<PublicationReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setPositionsList: (state: WritableDraft<PublicationReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setPublicationStart: (state: WritableDraft<PublicationReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setPublicationEnd: (state: WritableDraft<PublicationReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setTimeline: (state: WritableDraft<PublicationReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setTocTree: (state: WritableDraft<PublicationReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setAdjacentTimelineItems: (state: WritableDraft<PublicationReducerState>, action: {
        payload: {
            previous: AdjacentTimelineItem | null;
            next: AdjacentTimelineItem | null;
        };
    }) => void;
    setCoverTheme: (state: WritableDraft<PublicationReducerState>, action: {
        payload: ThemeTokens | undefined;
    }) => void;
    setTocEntry: (state: WritableDraft<PublicationReducerState>, action: {
        payload: TocItem | null;
    }) => void;
}, "publication", "publication", _reduxjs_toolkit.SliceSelectors<PublicationReducerState>>;
declare const setFontLanguage: _reduxjs_toolkit.ActionCreatorWithPayload<any, "publication/setFontLanguage">;
declare const setFXL: _reduxjs_toolkit.ActionCreatorWithPayload<any, "publication/setFXL">;
declare const setRTL: _reduxjs_toolkit.ActionCreatorWithPayload<any, "publication/setRTL">;
declare const setScriptMode: _reduxjs_toolkit.ActionCreatorWithPayload<any, "publication/setScriptMode">;
declare const setHasDisplayTransformability: _reduxjs_toolkit.ActionCreatorWithPayload<any, "publication/setHasDisplayTransformability">;
declare const setPositionsList: _reduxjs_toolkit.ActionCreatorWithPayload<any, "publication/setPositionsList">;
declare const setPublicationStart: _reduxjs_toolkit.ActionCreatorWithPayload<any, "publication/setPublicationStart">;
declare const setPublicationEnd: _reduxjs_toolkit.ActionCreatorWithPayload<any, "publication/setPublicationEnd">;
declare const setTimeline: _reduxjs_toolkit.ActionCreatorWithPayload<any, "publication/setTimeline">;
declare const setTocTree: _reduxjs_toolkit.ActionCreatorWithPayload<any, "publication/setTocTree">;
declare const setTocEntry: _reduxjs_toolkit.ActionCreatorWithPayload<TocItem | null, "publication/setTocEntry">;
declare const setAdjacentTimelineItems: _reduxjs_toolkit.ActionCreatorWithPayload<{
    previous: AdjacentTimelineItem | null;
    next: AdjacentTimelineItem | null;
}, "publication/setAdjacentTimelineItems">;
declare const setCoverTheme: _reduxjs_toolkit.ActionCreatorWithOptionalPayload<ThemeTokens | undefined, "publication/setCoverTheme">;

interface RenditionProperties<T extends string | Array<string>> {
    default?: T;
    breakpoints?: {
        [key in ThBreakpoints]?: T;
    };
}
interface RenditionObject<T extends string | Array<string>> {
    reflow?: RenditionProperties<T>;
    fxl?: RenditionProperties<T>;
    webPub?: RenditionProperties<T>;
}
interface RenditionChangePayload<T extends string | Array<string>> {
    type: string;
    payload: {
        key: "reflow" | "fxl" | "webPub";
        value?: T;
        breakpoint?: ThBreakpoints;
    };
}
interface UIChangePayload {
    type: string;
    payload: {
        key: "reflow" | "fxl" | "webPub";
        value?: ThLayoutUI;
    };
}
interface PaginatedAffordanceProperties {
    default?: ThPaginatedAffordancePrefValue;
    breakpoints?: {
        [key in ThBreakpoints]?: ThPaginatedAffordancePrefValue;
    };
}
interface PaginatedAffordanceObject {
    reflow?: PaginatedAffordanceProperties;
    fxl?: PaginatedAffordanceProperties;
}
interface PaginatedAffordancePayload {
    type: string;
    payload: {
        key: "reflow" | "fxl";
        value: ThPaginatedAffordancePrefValue;
        breakpoint?: ThBreakpoints;
    };
}
interface PreferencesReducerState {
    progressionFormat?: RenditionObject<ThProgressionFormat | Array<ThProgressionFormat>>;
    runningHeadFormat?: RenditionObject<ThRunningHeadFormat>;
    paginatedAffordances?: PaginatedAffordanceObject;
    ui?: {
        reflow?: ThLayoutUI;
        fxl?: ThLayoutUI;
        webPub?: ThLayoutUI;
    };
    scrollAffordances?: {
        hintInImmersive?: boolean;
        toggleOnMiddlePointer?: Array<"tap" | "click">;
        hideOnForwardScroll?: boolean;
        showOnBackwardScroll?: boolean;
    };
}
declare const preferencesSlice: _reduxjs_toolkit.Slice<PreferencesReducerState, {
    setProgressionFormat: (state: WritableDraft<PreferencesReducerState>, action: RenditionChangePayload<ThProgressionFormat | Array<ThProgressionFormat>>) => void;
    setRunningHeadFormat: (state: WritableDraft<PreferencesReducerState>, action: RenditionChangePayload<ThRunningHeadFormat>) => void;
    setUI: (state: WritableDraft<PreferencesReducerState>, action: UIChangePayload) => void;
    setScrollAffordances: (state: WritableDraft<PreferencesReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setPaginatedAffordance: (state: WritableDraft<PreferencesReducerState>, action: PaginatedAffordancePayload) => void;
    updateFromPreferences(state: WritableDraft<PreferencesReducerState>, action: PayloadAction<ThPreferences<CustomizableKeys>>): PreferencesReducerState;
}, "preferences", "preferences", _reduxjs_toolkit.SliceSelectors<PreferencesReducerState>>;
declare const setProgressionFormat: _reduxjs_toolkit.ActionCreatorWithPayload<{
    key: "reflow" | "fxl" | "webPub";
    value?: ThProgressionFormat | ThProgressionFormat[] | undefined;
    breakpoint?: ThBreakpoints;
}, "preferences/setProgressionFormat">;
declare const setRunningHeadFormat: _reduxjs_toolkit.ActionCreatorWithPayload<{
    key: "reflow" | "fxl" | "webPub";
    value?: ThRunningHeadFormat | undefined;
    breakpoint?: ThBreakpoints;
}, "preferences/setRunningHeadFormat">;
declare const setUI: _reduxjs_toolkit.ActionCreatorWithPayload<{
    key: "reflow" | "fxl" | "webPub";
    value?: ThLayoutUI;
}, "preferences/setUI">;
declare const setScrollAffordances: _reduxjs_toolkit.ActionCreatorWithPayload<any, "preferences/setScrollAffordances">;
declare const setPaginatedAffordance: _reduxjs_toolkit.ActionCreatorWithPayload<{
    key: "reflow" | "fxl";
    value: ThPaginatedAffordancePrefValue;
    breakpoint?: ThBreakpoints;
}, "preferences/setPaginatedAffordance">;
declare const updateFromPreferences: _reduxjs_toolkit.ActionCreatorWithPayload<ThPreferences<CustomizableKeys>, "preferences/updateFromPreferences">;

interface GlobalPreferencesReducerState {
    locale?: string;
}
declare const globalPreferencesSlice: _reduxjs_toolkit.Slice<GlobalPreferencesReducerState, {
    setLocale: (state: WritableDraft<GlobalPreferencesReducerState>, action: PayloadAction<string | undefined>) => void;
}, "globalPreferences", "globalPreferences", _reduxjs_toolkit.SliceSelectors<GlobalPreferencesReducerState>>;
declare const setLocale: _reduxjs_toolkit.ActionCreatorWithOptionalPayload<string | undefined, "globalPreferences/setLocale">;

interface WebPubSettingsReducerState {
    fontFamily: FontFamilyStateObject;
    fontWeight: number;
    hyphens: boolean | null;
    letterSpacing: number | null;
    ligatures: boolean | null;
    lineHeight: ThLineHeightOptions | null;
    noRuby: boolean | null;
    paragraphIndent: number | null;
    paragraphSpacing: number | null;
    publisherStyles: boolean;
    spacing: SpacingStateObject;
    textAlign: ThTextAlignOptions;
    textNormalization: boolean;
    wordSpacing: number | null;
    zoom: number;
}
declare const webPubSettingsSlice: _reduxjs_toolkit.Slice<WebPubSettingsReducerState, {
    setWebPubFontFamily: (state: WritableDraft<WebPubSettingsReducerState>, action: SetFontFamilyPayload) => void;
    setWebPubFontWeight: (state: WritableDraft<WebPubSettingsReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setWebPubHyphens: (state: WritableDraft<WebPubSettingsReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setWebPubLigatures: (state: WritableDraft<WebPubSettingsReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setWebPubLetterSpacing: (state: WritableDraft<WebPubSettingsReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setWebPubLineHeight: (state: WritableDraft<WebPubSettingsReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setWebPubParagraphIndent: (state: WritableDraft<WebPubSettingsReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setWebPubParagraphSpacing: (state: WritableDraft<WebPubSettingsReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setWebPubPublisherStyles: (state: WritableDraft<WebPubSettingsReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setWebPubSpacingPreset: (state: WritableDraft<WebPubSettingsReducerState>, action: SetSpacingPresetPayload) => void;
    setWebPubTextAlign: (state: WritableDraft<WebPubSettingsReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setWebPubTextNormalization: (state: WritableDraft<WebPubSettingsReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setWebPubNoRuby: (state: WritableDraft<WebPubSettingsReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setWebPubWordSpacing: (state: WritableDraft<WebPubSettingsReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
    setWebPubZoom: (state: WritableDraft<WebPubSettingsReducerState>, action: {
        payload: any;
        type: string;
    }) => void;
}, "webPubSettings", "webPubSettings", _reduxjs_toolkit.SliceSelectors<WebPubSettingsReducerState>>;
declare const initialWebPubSettingsState: WebPubSettingsReducerState;
declare const setWebPubFontFamily: _reduxjs_toolkit.ActionCreatorWithPayload<{
    key: "default" | string;
    value: string;
}, "webPubSettings/setWebPubFontFamily">;
declare const setWebPubFontWeight: _reduxjs_toolkit.ActionCreatorWithPayload<any, "webPubSettings/setWebPubFontWeight">;
declare const setWebPubHyphens: _reduxjs_toolkit.ActionCreatorWithPayload<any, "webPubSettings/setWebPubHyphens">;
declare const setWebPubLigatures: _reduxjs_toolkit.ActionCreatorWithPayload<any, "webPubSettings/setWebPubLigatures">;
declare const setWebPubLetterSpacing: _reduxjs_toolkit.ActionCreatorWithPayload<any, "webPubSettings/setWebPubLetterSpacing">;
declare const setWebPubLineHeight: _reduxjs_toolkit.ActionCreatorWithPayload<any, "webPubSettings/setWebPubLineHeight">;
declare const setWebPubParagraphIndent: _reduxjs_toolkit.ActionCreatorWithPayload<any, "webPubSettings/setWebPubParagraphIndent">;
declare const setWebPubParagraphSpacing: _reduxjs_toolkit.ActionCreatorWithPayload<any, "webPubSettings/setWebPubParagraphSpacing">;
declare const setWebPubPublisherStyles: _reduxjs_toolkit.ActionCreatorWithPayload<any, "webPubSettings/setWebPubPublisherStyles">;
declare const setWebPubSpacingPreset: _reduxjs_toolkit.ActionCreatorWithPayload<{
    preset: ThSpacingPresetKeys;
    values: Partial<Record<SpacingStateKey, number | ThLineHeightOptions | null>>;
}, "webPubSettings/setWebPubSpacingPreset">;
declare const setWebPubTextAlign: _reduxjs_toolkit.ActionCreatorWithPayload<any, "webPubSettings/setWebPubTextAlign">;
declare const setWebPubTextNormalization: _reduxjs_toolkit.ActionCreatorWithPayload<any, "webPubSettings/setWebPubTextNormalization">;
declare const setWebPubNoRuby: _reduxjs_toolkit.ActionCreatorWithPayload<any, "webPubSettings/setWebPubNoRuby">;
declare const setWebPubWordSpacing: _reduxjs_toolkit.ActionCreatorWithPayload<any, "webPubSettings/setWebPubWordSpacing">;
declare const setWebPubZoom: _reduxjs_toolkit.ActionCreatorWithPayload<any, "webPubSettings/setWebPubZoom">;

interface AudioSettingsState {
    volume: number;
    playbackRate: number;
    preservePitch: boolean;
    skipBackwardInterval: number;
    skipForwardInterval: number;
    skipInterval: number;
    pollInterval: number;
    autoPlay: boolean;
    enableMediaSession: boolean;
}
declare const audioSettingsSlice: _reduxjs_toolkit.Slice<AudioSettingsState, {
    setVolume: (state: WritableDraft<AudioSettingsState>, action: {
        payload: any;
        type: string;
    }) => void;
    setPlaybackRate: (state: WritableDraft<AudioSettingsState>, action: {
        payload: any;
        type: string;
    }) => void;
    setPreservePitch: (state: WritableDraft<AudioSettingsState>, action: {
        payload: any;
        type: string;
    }) => void;
    setSkipBackwardInterval: (state: WritableDraft<AudioSettingsState>, action: {
        payload: any;
        type: string;
    }) => void;
    setSkipForwardInterval: (state: WritableDraft<AudioSettingsState>, action: {
        payload: any;
        type: string;
    }) => void;
    setSkipInterval: (state: WritableDraft<AudioSettingsState>, action: {
        payload: any;
        type: string;
    }) => void;
    setPollInterval: (state: WritableDraft<AudioSettingsState>, action: {
        payload: any;
        type: string;
    }) => void;
    setAutoPlay: (state: WritableDraft<AudioSettingsState>, action: {
        payload: any;
        type: string;
    }) => void;
    setEnableMediaSession: (state: WritableDraft<AudioSettingsState>, action: {
        payload: any;
        type: string;
    }) => void;
}, "audioSettings", "audioSettings", _reduxjs_toolkit.SliceSelectors<AudioSettingsState>>;
declare const setVolume: _reduxjs_toolkit.ActionCreatorWithPayload<any, "audioSettings/setVolume">;
declare const setPlaybackRate: _reduxjs_toolkit.ActionCreatorWithPayload<any, "audioSettings/setPlaybackRate">;
declare const setPreservePitch: _reduxjs_toolkit.ActionCreatorWithPayload<any, "audioSettings/setPreservePitch">;
declare const setSkipBackwardInterval: _reduxjs_toolkit.ActionCreatorWithPayload<any, "audioSettings/setSkipBackwardInterval">;
declare const setSkipForwardInterval: _reduxjs_toolkit.ActionCreatorWithPayload<any, "audioSettings/setSkipForwardInterval">;
declare const setSkipInterval: _reduxjs_toolkit.ActionCreatorWithPayload<any, "audioSettings/setSkipInterval">;
declare const setPollInterval: _reduxjs_toolkit.ActionCreatorWithPayload<any, "audioSettings/setPollInterval">;
declare const setAutoPlay: _reduxjs_toolkit.ActionCreatorWithPayload<any, "audioSettings/setAutoPlay">;
declare const setEnableMediaSession: _reduxjs_toolkit.ActionCreatorWithPayload<any, "audioSettings/setEnableMediaSession">;

type PlayerStatus = "idle" | "playing" | "paused";
interface SeekableRange {
    start: number;
    end: number;
}
interface SleepTimerState {
    remainingSeconds: number | null;
    onTrackEnd: boolean;
    onFragmentEnd: boolean;
}
type RemotePlaybackState = "connecting" | "connected" | "disconnected" | "error";
interface PlayerReducerState {
    status: PlayerStatus;
    isSeeking: boolean;
    isStalled: boolean;
    isTrackReady: boolean;
    sleepTimer: SleepTimerState;
    remotePlaybackState: RemotePlaybackState | null;
    seekableRanges: SeekableRange[];
}
declare const playerSlice: _reduxjs_toolkit.Slice<PlayerReducerState, {
    setStatus: (state: WritableDraft<PlayerReducerState>, action: {
        payload: PlayerStatus;
    }) => void;
    setSeeking: (state: WritableDraft<PlayerReducerState>, action: {
        payload: boolean;
    }) => void;
    setStalled: (state: WritableDraft<PlayerReducerState>, action: {
        payload: boolean;
    }) => void;
    setTrackReady: (state: WritableDraft<PlayerReducerState>, action: {
        payload: boolean;
    }) => void;
    setSleepTimerRemainingSeconds: (state: WritableDraft<PlayerReducerState>, action: {
        payload: number | null;
    }) => void;
    setSleepTimerOnTrackEnd: (state: WritableDraft<PlayerReducerState>, action: {
        payload: boolean;
    }) => void;
    setSleepTimerOnFragmentEnd: (state: WritableDraft<PlayerReducerState>, action: {
        payload: boolean;
    }) => void;
    setRemotePlaybackState: (state: WritableDraft<PlayerReducerState>, action: {
        payload: RemotePlaybackState | null;
    }) => void;
    setSeekableRanges: (state: WritableDraft<PlayerReducerState>, action: {
        payload: SeekableRange[];
    }) => void;
}, "player", "player", _reduxjs_toolkit.SliceSelectors<PlayerReducerState>>;
declare const setStatus: _reduxjs_toolkit.ActionCreatorWithPayload<PlayerStatus, "player/setStatus">;
declare const setSeeking: _reduxjs_toolkit.ActionCreatorWithPayload<boolean, "player/setSeeking">;
declare const setStalled: _reduxjs_toolkit.ActionCreatorWithPayload<boolean, "player/setStalled">;
declare const setTrackReady: _reduxjs_toolkit.ActionCreatorWithPayload<boolean, "player/setTrackReady">;
declare const setSleepTimerRemainingSeconds: _reduxjs_toolkit.ActionCreatorWithPayload<number | null, "player/setSleepTimerRemainingSeconds">;
declare const setSleepTimerOnTrackEnd: _reduxjs_toolkit.ActionCreatorWithPayload<boolean, "player/setSleepTimerOnTrackEnd">;
declare const setSleepTimerOnFragmentEnd: _reduxjs_toolkit.ActionCreatorWithPayload<boolean, "player/setSleepTimerOnFragmentEnd">;
declare const setRemotePlaybackState: _reduxjs_toolkit.ActionCreatorWithPayload<RemotePlaybackState | null, "player/setRemotePlaybackState">;
declare const setSeekableRanges: _reduxjs_toolkit.ActionCreatorWithPayload<SeekableRange[], "player/setSeekableRanges">;

interface ExternalReducerConfig {
    reducer: any;
    persist?: boolean;
}
type RootState = {
    reader: ReaderReducerState;
    settings: SettingsReducerState;
    theming: ThemeReducerState;
    actions: ActionsReducerState;
    publication: PublicationReducerState;
    preferences: PreferencesReducerState;
    globalPreferences: GlobalPreferencesReducerState;
    webPubSettings: WebPubSettingsReducerState;
    audioSettings: AudioSettingsState;
    player: PlayerReducerState;
    [key: string]: any;
};
declare const makeStore: (storageKey?: string, externalReducers?: Record<string, ExternalReducerConfig>) => _reduxjs_toolkit.EnhancedStore<RootState, _reduxjs_toolkit.UnknownAction, _reduxjs_toolkit.Tuple<[_reduxjs_toolkit.StoreEnhancer<{
    dispatch: _reduxjs_toolkit.ThunkDispatch<RootState, undefined, _reduxjs_toolkit.UnknownAction>;
}>, _reduxjs_toolkit.StoreEnhancer]>>;
type AppStore = ReturnType<typeof makeStore>;
type AppState = RootState;
type AppDispatch = AppStore["dispatch"];

declare const ThStoreProvider: ({ storageKey, store, children }: {
    storageKey?: string;
    store?: AppStore;
    children: React.ReactNode;
}) => react_jsx_runtime.JSX.Element;

declare class ThReduxPreferencesAdapter<T extends CustomizableKeys = CustomizableKeys> implements ThPreferencesAdapter<T> {
    private store;
    private listeners;
    private currentPreferences;
    constructor(store: Store<AppState>, initialPreferences: ThPreferences<T>);
    getPreferences(): ThPreferences<T>;
    setPreferences(prefs: ThPreferences<T>): void;
    subscribe(listener: (prefs: ThPreferences<T>) => void): void;
    unsubscribe(listener: (prefs: ThPreferences<T>) => void): void;
    private mapStateToPreferences;
    private notifyListeners;
}

declare class ThReduxGlobalPreferencesAdapter implements ThGlobalPreferencesAdapter {
    private store;
    private listeners;
    private currentPreferences;
    constructor(store: Store<AppState>, initialPreferences?: ThGlobalPreferences);
    getPreferences(): ThGlobalPreferences;
    setPreferences(prefs: ThGlobalPreferences): void;
    subscribe(callback: (prefs: ThGlobalPreferences) => void): void;
    unsubscribe(callback: (prefs: ThGlobalPreferences) => void): void;
    private notifyListeners;
}

declare const useAppDispatch: () => AppDispatch;
declare const useAppSelector: TypedUseSelectorHook<RootState>;
declare const useAppStore: () => AppStore;

export { ActionsReducerState, type AdjacentTimelineItem, type AppDispatch, type AppState, type AppStore, type AudioSettingsState, FontFamilyStateObject, type GlobalPreferencesReducerState, type PaginatedAffordanceObject, type PaginatedAffordancePayload, type PaginatedAffordanceProperties, type PlayerReducerState, type PlayerStatus, type PreferencesReducerState, type PublicationReducerState, type ReaderProfile, type ReaderReducerState, type RemotePlaybackState, type RenditionChangePayload, type RenditionObject, type RenditionProperties, type RootState, type SeekableRange, SetFontFamilyPayload, SetSpacingPresetPayload, SettingsReducerState, type SleepTimerState, SpacingStateKey, SpacingStateObject, ThReduxGlobalPreferencesAdapter, ThReduxPreferencesAdapter, ThStoreProvider, type ThemeReducerState, type ThemeStateChangePayload, type ThemeStateObject, type UIChangePayload, type WebPubSettingsReducerState, audioSettingsSlice, globalPreferencesSlice, initialWebPubSettingsState, makeStore, playerSlice, preferencesSlice, publicationSlice, readerSlice, setAdjacentTimelineItems, setAutoPlay, setBreakpoint, setColorScheme, setContainerBreakpoint, setContrast, setCoverTheme, setDirection, setEnableMediaSession, setFXL, setFontLanguage, setForcedColors, setFullscreen, setHasArrows, setHasDisplayTransformability, setHovering, setImmersive, setLoading, setLocale, setMonochrome, setPaginatedAffordance, setPlatformModifier, setPlaybackRate, setPollInterval, setPositionsList, setPreservePitch, setProgressionFormat, setPublicationEnd, setPublicationStart, setRTL, setReaderProfile, setReducedMotion, setReducedTransparency, setRemotePlaybackState, setRunningHeadFormat, setScriptMode, setScrollAffordance, setScrollAffordances, setSeekableRanges, setSeeking, setSettingsContainer, setSkipBackwardInterval, setSkipForwardInterval, setSkipInterval, setSleepTimerOnFragmentEnd, setSleepTimerOnTrackEnd, setSleepTimerRemainingSeconds, setStalled, setStatus, setTheme, setTimeline, setTocEntry, setTocTree, setTrackReady, setUI, setUserNavigated, setVolume, setWebPubFontFamily, setWebPubFontWeight, setWebPubHyphens, setWebPubLetterSpacing, setWebPubLigatures, setWebPubLineHeight, setWebPubNoRuby, setWebPubParagraphIndent, setWebPubParagraphSpacing, setWebPubPublisherStyles, setWebPubSpacingPreset, setWebPubTextAlign, setWebPubTextNormalization, setWebPubWordSpacing, setWebPubZoom, themeSlice, toggleImmersive, updateFromPreferences, useAppDispatch, useAppSelector, useAppStore, webPubSettingsSlice };