@prose-reader/core 0.0.36

package/dist/createReaderWithEnhancer.d.ts

@@ -0,0 +1,2242 @@
+import { ComposableEnhancer, ComposeEnhancer } from './enhancers/composeEnhancer';
+import { Enhancer } from './enhancers/types';
+import { Reader as ReaderPublicApi } from './reader';
+declare const withPublicApiOnly: <Api extends {
+    context: any;
+    registerHook: any;
+    spine: any;
+    manipulateSpineItems: any;
+    manipulateContainer: any;
+    moveTo: any;
+    turnLeft: any;
+    turnRight: any;
+    goToPageOfCurrentChapter: any;
+    goToPage: any;
+    goToUrl: any;
+    goToCfi: any;
+    goToSpineItem: any;
+    getFocusedSpineItemIndex: any;
+    getSpineItem: any;
+    getSpineItems: any;
+    getAbsolutePositionOf: any;
+    getSelection: any;
+    isSelecting: any;
+    normalizeEventForViewport: any;
+    getCfiMetaInformation: any;
+    resolveCfi: any;
+    generateCfi: any;
+    locator: any;
+    getCurrentNavigationPosition: any;
+    getCurrentViewportPosition: any;
+    layout: any;
+    load: any;
+    destroy: any;
+    setSettings: any;
+    $: any;
+}>(reader: Api) => Omit<Api, "context" | "spine" | "manipulateSpineItems" | "manipulateContainer" | "getFocusedSpineItemIndex" | "getSpineItem" | "getAbsolutePositionOf" | "getCfiMetaInformation" | "resolveCfi" | "generateCfi" | "locator" | "getCurrentNavigationPosition">;
+declare type ReaderPublicApiWithSafeExposedKeys = ReturnType<typeof withPublicApiOnly>;
+declare type RemovedKeysOnly = keyof Omit<ReaderPublicApi, keyof ReaderPublicApiWithSafeExposedKeys>;
+declare const internalEnhancer: ComposeEnhancer<Enhancer<{}, {
+    progression: {
+        getPercentageEstimate: (context: {
+            load: (newManifest: import("@prose-reader/shared").Manifest, newLoadOptions: import("./types").LoadOptions) => void;
+            isRTL: () => boolean;
+            areAllItemsPrePaginated: () => boolean;
+            destroy: () => void;
+            getLoadOptions: () => import("./types").LoadOptions | undefined;
+            getCalculatedInnerMargin: () => number;
+            getVisibleAreaRect: () => {
+                width: number;
+                height: number;
+                x: number;
+                y: number;
+            };
+            shouldDisplaySpread: () => boolean;
+            setHasVerticalWriting: () => void;
+            setVisibleAreaRect: (x: number, y: number, width: number, height: number) => void;
+            getManifest: () => import("@prose-reader/shared").Manifest | undefined;
+            getReadingDirection: () => "ltr" | "rtl" | undefined;
+            getPageSize: () => {
+                width: number;
+                height: number;
+            };
+            getSettings: () => import("./settings").PublicSettings & {
+                computedPageTurnMode: "controlled" | "scrollable";
+                computedPageTurnDirection: "vertical" | "horizontal";
+                computedPageTurnAnimation: "none" | "fade" | "slide";
+                computedPageTurnAnimationDuration: number;
+                computedSnapAnimationDuration: number;
+            };
+            setSettings: (data: Partial<import("./settings").PublicSettings>) => void;
+            $: {
+                hasVerticalWriting$: import("rxjs").Observable<boolean>;
+                destroy$: import("rxjs").Observable<void>;
+                settings$: import("rxjs").Observable<import("./settings").PublicSettings & {
+                    computedPageTurnMode: "controlled" | "scrollable";
+                    computedPageTurnDirection: "vertical" | "horizontal";
+                    computedPageTurnAnimation: "none" | "fade" | "slide";
+                    computedPageTurnAnimationDuration: number;
+                    computedSnapAnimationDuration: number;
+                }>;
+                load$: import("rxjs").Observable<import("@prose-reader/shared").Manifest>;
+            };
+        }, currentSpineIndex: number, numberOfPages: number, pageIndex: number, currentPosition: {
+            x: number;
+            y: number;
+        }, currentItem: import("./spineItem/createSpineItem").SpineItem) => number;
+        getScrollPercentageWithinItem: (context: {
+            load: (newManifest: import("@prose-reader/shared").Manifest, newLoadOptions: import("./types").LoadOptions) => void;
+            isRTL: () => boolean;
+            areAllItemsPrePaginated: () => boolean;
+            destroy: () => void;
+            getLoadOptions: () => import("./types").LoadOptions | undefined;
+            getCalculatedInnerMargin: () => number;
+            getVisibleAreaRect: () => {
+                width: number;
+                height: number;
+                x: number;
+                y: number;
+            };
+            shouldDisplaySpread: () => boolean;
+            setHasVerticalWriting: () => void;
+            setVisibleAreaRect: (x: number, y: number, width: number, height: number) => void;
+            getManifest: () => import("@prose-reader/shared").Manifest | undefined;
+            getReadingDirection: () => "ltr" | "rtl" | undefined;
+            getPageSize: () => {
+                width: number;
+                height: number;
+            };
+            getSettings: () => import("./settings").PublicSettings & {
+                computedPageTurnMode: "controlled" | "scrollable";
+                computedPageTurnDirection: "vertical" | "horizontal";
+                computedPageTurnAnimation: "none" | "fade" | "slide";
+                computedPageTurnAnimationDuration: number;
+                computedSnapAnimationDuration: number;
+            };
+            setSettings: (data: Partial<import("./settings").PublicSettings>) => void;
+            $: {
+                hasVerticalWriting$: import("rxjs").Observable<boolean>;
+                destroy$: import("rxjs").Observable<void>;
+                settings$: import("rxjs").Observable<import("./settings").PublicSettings & {
+                    computedPageTurnMode: "controlled" | "scrollable";
+                    computedPageTurnDirection: "vertical" | "horizontal";
+                    computedPageTurnAnimation: "none" | "fade" | "slide";
+                    computedPageTurnAnimationDuration: number;
+                    computedSnapAnimationDuration: number;
+                }>;
+                load$: import("rxjs").Observable<import("@prose-reader/shared").Manifest>;
+            };
+        }, currentPosition: {
+            x: number;
+            y: number;
+        }, currentItem: import("./spineItem/createSpineItem").SpineItem) => number;
+    };
+}, {}, {}, (createReader: (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi) => (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi, ReaderPublicApi>, Enhancer<{}, {
+    $: {
+        pagination$: import("rxjs").Observable<{
+            beginChapterInfo: {
+                title: string;
+                subChapter?: {
+                    title: string;
+                    subChapter?: {
+                        title: string;
+                        subChapter?: {
+                            title: string;
+                            path: string;
+                        } | undefined;
+                        path: string;
+                    } | undefined;
+                    path: string;
+                } | undefined;
+                path: string;
+            } | undefined;
+            beginPageIndexInChapter: number | undefined;
+            beginNumberOfPagesInChapter: number | undefined;
+            beginSpineItemIndex: number | undefined;
+            beginCfi: string | undefined;
+            beginSpineItemReadingDirection: "ltr" | "rtl" | undefined;
+            beginAbsolutePageIndex: number | undefined;
+            endChapterInfo: {
+                title: string;
+                subChapter?: {
+                    title: string;
+                    subChapter?: {
+                        title: string;
+                        subChapter?: {
+                            title: string;
+                            path: string;
+                        } | undefined;
+                        path: string;
+                    } | undefined;
+                    path: string;
+                } | undefined;
+                path: string;
+            } | undefined;
+            endPageIndexInChapter: number | undefined;
+            endNumberOfPagesInChapter: number | undefined;
+            endSpineItemIndex: number | undefined;
+            endCfi: string | undefined;
+            endSpineItemReadingDirection: "ltr" | "rtl" | undefined;
+            endAbsolutePageIndex: number | undefined;
+            percentageEstimateOfBook: number | undefined;
+            numberOfTotalPages: number | undefined;
+            isUsingSpread: boolean;
+        }>;
+    };
+}, {}, {}, Enhancer<{}, {
+    progression: {
+        getPercentageEstimate: (context: {
+            load: (newManifest: import("@prose-reader/shared").Manifest, newLoadOptions: import("./types").LoadOptions) => void;
+            isRTL: () => boolean;
+            areAllItemsPrePaginated: () => boolean;
+            destroy: () => void;
+            getLoadOptions: () => import("./types").LoadOptions | undefined;
+            getCalculatedInnerMargin: () => number;
+            getVisibleAreaRect: () => {
+                width: number;
+                height: number;
+                x: number;
+                y: number;
+            };
+            shouldDisplaySpread: () => boolean;
+            setHasVerticalWriting: () => void;
+            setVisibleAreaRect: (x: number, y: number, width: number, height: number) => void;
+            getManifest: () => import("@prose-reader/shared").Manifest | undefined;
+            getReadingDirection: () => "ltr" | "rtl" | undefined;
+            getPageSize: () => {
+                width: number;
+                height: number;
+            };
+            getSettings: () => import("./settings").PublicSettings & {
+                computedPageTurnMode: "controlled" | "scrollable";
+                computedPageTurnDirection: "vertical" | "horizontal";
+                computedPageTurnAnimation: "none" | "fade" | "slide";
+                computedPageTurnAnimationDuration: number;
+                computedSnapAnimationDuration: number;
+            };
+            setSettings: (data: Partial<import("./settings").PublicSettings>) => void;
+            $: {
+                hasVerticalWriting$: import("rxjs").Observable<boolean>;
+                destroy$: import("rxjs").Observable<void>;
+                settings$: import("rxjs").Observable<import("./settings").PublicSettings & {
+                    computedPageTurnMode: "controlled" | "scrollable";
+                    computedPageTurnDirection: "vertical" | "horizontal";
+                    computedPageTurnAnimation: "none" | "fade" | "slide";
+                    computedPageTurnAnimationDuration: number;
+                    computedSnapAnimationDuration: number;
+                }>;
+                load$: import("rxjs").Observable<import("@prose-reader/shared").Manifest>;
+            };
+        }, currentSpineIndex: number, numberOfPages: number, pageIndex: number, currentPosition: {
+            x: number;
+            y: number;
+        }, currentItem: import("./spineItem/createSpineItem").SpineItem) => number;
+        getScrollPercentageWithinItem: (context: {
+            load: (newManifest: import("@prose-reader/shared").Manifest, newLoadOptions: import("./types").LoadOptions) => void;
+            isRTL: () => boolean;
+            areAllItemsPrePaginated: () => boolean;
+            destroy: () => void;
+            getLoadOptions: () => import("./types").LoadOptions | undefined;
+            getCalculatedInnerMargin: () => number;
+            getVisibleAreaRect: () => {
+                width: number;
+                height: number;
+                x: number;
+                y: number;
+            };
+            shouldDisplaySpread: () => boolean;
+            setHasVerticalWriting: () => void;
+            setVisibleAreaRect: (x: number, y: number, width: number, height: number) => void;
+            getManifest: () => import("@prose-reader/shared").Manifest | undefined;
+            getReadingDirection: () => "ltr" | "rtl" | undefined;
+            getPageSize: () => {
+                width: number;
+                height: number;
+            };
+            getSettings: () => import("./settings").PublicSettings & {
+                computedPageTurnMode: "controlled" | "scrollable";
+                computedPageTurnDirection: "vertical" | "horizontal";
+                computedPageTurnAnimation: "none" | "fade" | "slide";
+                computedPageTurnAnimationDuration: number;
+                computedSnapAnimationDuration: number;
+            };
+            setSettings: (data: Partial<import("./settings").PublicSettings>) => void;
+            $: {
+                hasVerticalWriting$: import("rxjs").Observable<boolean>;
+                destroy$: import("rxjs").Observable<void>;
+                settings$: import("rxjs").Observable<import("./settings").PublicSettings & {
+                    computedPageTurnMode: "controlled" | "scrollable";
+                    computedPageTurnDirection: "vertical" | "horizontal";
+                    computedPageTurnAnimation: "none" | "fade" | "slide";
+                    computedPageTurnAnimationDuration: number;
+                    computedSnapAnimationDuration: number;
+                }>;
+                load$: import("rxjs").Observable<import("@prose-reader/shared").Manifest>;
+            };
+        }, currentPosition: {
+            x: number;
+            y: number;
+        }, currentItem: import("./spineItem/createSpineItem").SpineItem) => number;
+    };
+}, {}, {}, (createReader: (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi) => (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi, ReaderPublicApi>, {
+    setSettings: (settings: Partial<import("./settings").PublicSettings>) => void;
+    context: {
+        load: (newManifest: import("@prose-reader/shared").Manifest, newLoadOptions: import("./types").LoadOptions) => void;
+        isRTL: () => boolean;
+        areAllItemsPrePaginated: () => boolean;
+        destroy: () => void;
+        getLoadOptions: () => import("./types").LoadOptions | undefined;
+        getCalculatedInnerMargin: () => number;
+        getVisibleAreaRect: () => {
+            width: number;
+            height: number;
+            x: number;
+            y: number;
+        };
+        shouldDisplaySpread: () => boolean;
+        setHasVerticalWriting: () => void;
+        setVisibleAreaRect: (x: number, y: number, width: number, height: number) => void;
+        getManifest: () => import("@prose-reader/shared").Manifest | undefined;
+        getReadingDirection: () => "ltr" | "rtl" | undefined;
+        getPageSize: () => {
+            width: number;
+            height: number;
+        };
+        getSettings: () => import("./settings").PublicSettings & {
+            computedPageTurnMode: "controlled" | "scrollable";
+            computedPageTurnDirection: "vertical" | "horizontal";
+            computedPageTurnAnimation: "none" | "fade" | "slide";
+            computedPageTurnAnimationDuration: number;
+            computedSnapAnimationDuration: number;
+        };
+        setSettings: (data: Partial<import("./settings").PublicSettings>) => void;
+        $: {
+            hasVerticalWriting$: import("rxjs").Observable<boolean>;
+            destroy$: import("rxjs").Observable<void>;
+            settings$: import("rxjs").Observable<import("./settings").PublicSettings & {
+                computedPageTurnMode: "controlled" | "scrollable";
+                computedPageTurnDirection: "vertical" | "horizontal";
+                computedPageTurnAnimation: "none" | "fade" | "slide";
+                computedPageTurnAnimationDuration: number;
+                computedSnapAnimationDuration: number;
+            }>;
+            load$: import("rxjs").Observable<import("@prose-reader/shared").Manifest>;
+        };
+    };
+    registerHook: import("./types/Hook").RegisterHook;
+    spine: {
+        viewportNavigator: {
+            destroy: () => void;
+            layout: () => void;
+            getCurrentNavigationPosition: () => import("./spine/navigationResolver").ViewportNavigationEntry;
+            getCurrentViewportPosition: (() => {
+                x: number;
+                y: number;
+            }) | (() => {
+                x: number;
+                y: number;
+            });
+            turnLeft: ({ allowSpineItemChange }?: {
+                allowSpineItemChange?: boolean | undefined;
+            }) => void;
+            turnRight: ({ allowSpineItemChange }?: {
+                allowSpineItemChange?: boolean | undefined;
+            }) => void;
+            goToPage: (pageIndex: number) => void;
+            goToSpineItem: (indexOrId: string | number, options?: {
+                animate: boolean;
+            }) => void;
+            goToUrl: (url: string | URL) => void;
+            goToCfi: (cfi: string, options?: {
+                animate: boolean;
+            }) => void;
+            goToPageOfCurrentChapter: (pageIndex: number) => void;
+            adjustNavigation: (spineItem: import("./spineItem/createSpineItem").SpineItem) => import("rxjs").Observable<{
+                previousNavigationPosition: import("./spine/navigationResolver").ViewportNavigationEntry;
+                adjustedSpinePosition: import("./spine/navigationResolver").ViewportNavigationEntry;
+                areDifferent: boolean;
+            }>;
+            moveTo: ((delta: {
+                x: number;
+                y: number;
+            } | undefined, { final, start }?: {
+                start?: boolean | undefined;
+                final?: boolean | undefined;
+            }) => void) | ((args_0: {
+                x: number;
+                y: number;
+            } | undefined, args_1?: {
+                start?: boolean | undefined;
+                final?: boolean | undefined;
+            } | undefined) => void);
+            getLastUserExpectedNavigation: () => {
+                type: "navigate-from-previous-item";
+            } | {
+                type: "navigate-from-next-item";
+            } | {
+                type: "navigate-from-cfi";
+                data: string;
+            } | {
+                type: "navigate-from-anchor";
+                data: string;
+            } | undefined;
+            $: {
+                state$: import("rxjs").Observable<"free" | "busy">;
+                navigation$: import("rxjs").Observable<{
+                    position: {
+                        x: number;
+                        y: number;
+                        spineItem?: import("./spineItem/createSpineItem").SpineItem | undefined;
+                    };
+                    triggeredBy: "scroll" | "manual" | "adjust";
+                    animation: false | "turn" | "snap";
+                }>;
+            };
+        };
+        element: HTMLElement;
+        locator: {
+            getSpinePositionFromSpineItemPosition: (spineItemPosition: {
+                x: number;
+                y: number;
+                outsideOfBoundaries?: boolean | undefined;
+            }, spineItem: import("./spineItem/createSpineItem").SpineItem) => {
+                x: number;
+                y: number;
+            };
+            getSpinePositionFromSpineItem: (spineItem: import("./spineItem/createSpineItem").SpineItem) => {
+                x: number;
+                y: number;
+            };
+            getSpinePositionFromSpineItemAnchor: (anchor: string, spineItem: import("./spineItem/createSpineItem").SpineItem) => {
+                x: number;
+                y: number;
+            };
+            getSpineItemPositionFromSpinePosition: ((position: {
+                x: number;
+                y: number;
+            }, spineItem: import("./spineItem/createSpineItem").SpineItem) => {
+                x: number;
+                y: number;
+                outsideOfBoundaries?: boolean | undefined;
+            }) | ((position: {
+                x: number;
+                y: number;
+            }, spineItem: import("./spineItem/createSpineItem").SpineItem) => {
+                x: number;
+                y: number;
+                outsideOfBoundaries?: boolean | undefined;
+            });
+            getSpineItemFromPosition: ((position: {
+                x: number;
+                y: number;
+            }) => ({
+                item: {
+                    id: string;
+                    href: string;
+                    path: string;
+                    renditionLayout: "reflowable" | "pre-paginated";
+                    progressionWeight: number;
+                    pageSpreadLeft: true | undefined;
+                    pageSpreadRight: true | undefined;
+                    mediaType?: string | undefined;
+                };
+            } & {
+                layout: (layoutInformation: {
+                    blankPagePosition: "after" | "before" | "none";
+                    minimumWidth: number;
+                    spreadPosition: "right" | "left" | "none";
+                }) => {
+                    width: number;
+                    height: number;
+                };
+                load: () => void;
+                adjustPositionOfElement: ({ right, left, top }: {
+                    right?: number | undefined;
+                    left?: number | undefined;
+                    top?: number | undefined;
+                }) => void;
+                createLoadingElement: (containerElement: HTMLElement, item: {
+                    id: string;
+                    href: string;
+                    path: string;
+                    renditionLayout: "reflowable" | "pre-paginated";
+                    progressionWeight: number;
+                    pageSpreadLeft: true | undefined;
+                    pageSpreadRight: true | undefined;
+                    mediaType?: string | undefined;
+                }, context: {
+                    load: (newManifest: import("@prose-reader/shared").Manifest, newLoadOptions: import("./types").LoadOptions) => void;
+                    isRTL: () => boolean;
+                    areAllItemsPrePaginated: () => boolean;
+                    destroy: () => void;
+                    getLoadOptions: () => import("./types").LoadOptions | undefined;
+                    getCalculatedInnerMargin: () => number;
+                    getVisibleAreaRect: () => {
+                        width: number;
+                        height: number;
+                        x: number;
+                        y: number;
+                    };
+                    shouldDisplaySpread: () => boolean;
+                    setHasVerticalWriting: () => void;
+                    setVisibleAreaRect: (x: number, y: number, width: number, height: number) => void;
+                    getManifest: () => import("@prose-reader/shared").Manifest | undefined;
+                    getReadingDirection: () => "ltr" | "rtl" | undefined;
+                    getPageSize: () => {
+                        width: number;
+                        height: number;
+                    };
+                    getSettings: () => import("./settings").PublicSettings & {
+                        computedPageTurnMode: "controlled" | "scrollable";
+                        computedPageTurnDirection: "vertical" | "horizontal";
+                        computedPageTurnAnimation: "none" | "fade" | "slide";
+                        computedPageTurnAnimationDuration: number;
+                        computedSnapAnimationDuration: number;
+                    };
+                    setSettings: (data: Partial<import("./settings").PublicSettings>) => void;
+                    $: {
+                        hasVerticalWriting$: import("rxjs").Observable<boolean>;
+                        destroy$: import("rxjs").Observable<void>;
+                        settings$: import("rxjs").Observable<import("./settings").PublicSettings & {
+                            computedPageTurnMode: "controlled" | "scrollable";
+                            computedPageTurnDirection: "vertical" | "horizontal";
+                            computedPageTurnAnimation: "none" | "fade" | "slide";
+                            computedPageTurnAnimationDuration: number;
+                            computedSnapAnimationDuration: number;
+                        }>;
+                        load$: import("rxjs").Observable<import("@prose-reader/shared").Manifest>;
+                    };
+                }) => HTMLDivElement;
+                getElementDimensions: () => {
+                    width: number;
+                    height: number;
+                };
+                getHtmlFromResource: (response: Response) => Promise<string>;
+                getResource: () => Promise<Response>;
+                translateFramePositionIntoPage: (position: {
+                    clientX: number;
+                    clientY: number;
+                }) => {
+                    clientX: number;
+                    clientY: number;
+                };
+                setLayoutDirty: () => void;
+                injectStyle: (cssText: string) => void;
+                loadContent: () => void;
+                unloadContent: () => void;
+                spineItemFrame: {
+                    getIsLoaded: () => boolean;
+                    getIsReady: () => boolean;
+                    getViewportDimensions: () => {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    getFrameElement: () => HTMLIFrameElement | undefined;
+                    getHtmlFromResource: (response: Response) => Promise<string>;
+                    load: () => void;
+                    unload: () => void;
+                    staticLayout: (size: {
+                        width: number;
+                        height: number;
+                    }) => void;
+                    getManipulableFrame: () => {
+                        frame: HTMLIFrameElement;
+                        removeStyle: (id: string) => void;
+                        addStyle: (id: string, style: string, prepend?: boolean) => void;
+                    } | undefined;
+                    getReadingDirection: () => "ltr" | "rtl" | undefined;
+                    isUsingVerticalWriting: () => boolean;
+                    getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined;
+                    destroy: () => void;
+                    $: {
+                        unload$: import("rxjs").Observable<void>;
+                        unloaded$: import("rxjs").Observable<void>;
+                        loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                        ready$: import("rxjs").Observable<FontFaceSet | undefined>;
+                        isReady$: import("rxjs").Observable<boolean>;
+                        contentLayoutChange$: import("rxjs").Observable<{
+                            isFirstLayout: boolean;
+                        } | {
+                            isFirstLayout: boolean;
+                        }>;
+                    };
+                };
+                element: HTMLElement;
+                loadingElement: HTMLDivElement;
+                isReflowable: boolean;
+                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+                getViewPortInformation: () => {
+                    computedScale: number;
+                    computedWidthScale: number;
+                    viewportDimensions: {
+                        width: number;
+                        height: number;
+                    };
+                } | {
+                    width?: number | undefined;
+                    height?: number | undefined;
+                    computedScale: number;
+                    computedWidthScale: number;
+                    viewportDimensions?: undefined;
+                };
+                isImageType: () => boolean | undefined;
+                isReady: () => boolean;
+                destroy: () => void;
+                isUsingVerticalWriting: () => boolean | undefined;
+                getReadingDirection: () => "ltr" | "rtl" | undefined;
+                manipulateSpineItem: (cb: (options: {
+                    container: HTMLElement;
+                    loadingElement: HTMLElement;
+                    item: {
+                        id: string;
+                        href: string;
+                        path: string;
+                        renditionLayout: "reflowable" | "pre-paginated";
+                        progressionWeight: number;
+                        pageSpreadLeft: true | undefined;
+                        pageSpreadRight: true | undefined;
+                        mediaType?: string | undefined;
+                    };
+                    overlayElement: HTMLDivElement;
+                } & ({
+                    frame: HTMLIFrameElement;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string, prepend?: boolean) => void;
+                } | {
+                    frame: undefined;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string) => void;
+                })) => boolean) => boolean;
+                executeOnLayoutBeforeMeasurmentHook: (options: {
+                    minimumWidth: number;
+                }) => void;
+                selectionTracker: {
+                    track: (frameToTrack: HTMLIFrameElement) => void;
+                    destroy: () => void;
+                    isSelecting: () => boolean;
+                    getSelection: () => Selection | undefined;
+                    $: import("rxjs").Observable<{
+                        event: "selectionchange";
+                        data: Selection | null;
+                    } | {
+                        event: "selectstart";
+                        data: Selection | null;
+                    } | {
+                        event: "selectend";
+                        data: Selection | null;
+                    }>;
+                };
+                fingerTracker: {
+                    track: (frame: HTMLIFrameElement) => void;
+                    getFingerPositionInIframe(): {
+                        x: number | undefined;
+                        y: number | undefined;
+                    } | undefined;
+                    destroy: () => void;
+                    $: import("rxjs").Observable<{
+                        event: "fingermove";
+                        data: {
+                            x: number;
+                            y: number;
+                        };
+                    } | {
+                        event: "fingerout";
+                        data: undefined;
+                    }>;
+                };
+                $: {
+                    contentLayoutChangeSubject$: import("rxjs").Observable<{
+                        isFirstLayout: boolean;
+                        isReady: boolean;
+                    }>;
+                    loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                };
+            }) | undefined) | ((position: {
+                x: number;
+                y: number;
+            }) => ({
+                item: {
+                    id: string;
+                    href: string;
+                    path: string;
+                    renditionLayout: "reflowable" | "pre-paginated";
+                    progressionWeight: number;
+                    pageSpreadLeft: true | undefined;
+                    pageSpreadRight: true | undefined;
+                    mediaType?: string | undefined;
+                };
+            } & {
+                layout: (layoutInformation: {
+                    blankPagePosition: "after" | "before" | "none";
+                    minimumWidth: number;
+                    spreadPosition: "right" | "left" | "none";
+                }) => {
+                    width: number;
+                    height: number;
+                };
+                load: () => void;
+                adjustPositionOfElement: ({ right, left, top }: {
+                    right?: number | undefined;
+                    left?: number | undefined;
+                    top?: number | undefined;
+                }) => void;
+                createLoadingElement: (containerElement: HTMLElement, item: {
+                    id: string;
+                    href: string;
+                    path: string;
+                    renditionLayout: "reflowable" | "pre-paginated";
+                    progressionWeight: number;
+                    pageSpreadLeft: true | undefined;
+                    pageSpreadRight: true | undefined;
+                    mediaType?: string | undefined;
+                }, context: {
+                    load: (newManifest: import("@prose-reader/shared").Manifest, newLoadOptions: import("./types").LoadOptions) => void;
+                    isRTL: () => boolean;
+                    areAllItemsPrePaginated: () => boolean;
+                    destroy: () => void;
+                    getLoadOptions: () => import("./types").LoadOptions | undefined;
+                    getCalculatedInnerMargin: () => number;
+                    getVisibleAreaRect: () => {
+                        width: number;
+                        height: number;
+                        x: number;
+                        y: number;
+                    };
+                    shouldDisplaySpread: () => boolean;
+                    setHasVerticalWriting: () => void;
+                    setVisibleAreaRect: (x: number, y: number, width: number, height: number) => void;
+                    getManifest: () => import("@prose-reader/shared").Manifest | undefined;
+                    getReadingDirection: () => "ltr" | "rtl" | undefined;
+                    getPageSize: () => {
+                        width: number;
+                        height: number;
+                    };
+                    getSettings: () => import("./settings").PublicSettings & {
+                        computedPageTurnMode: "controlled" | "scrollable";
+                        computedPageTurnDirection: "vertical" | "horizontal";
+                        computedPageTurnAnimation: "none" | "fade" | "slide";
+                        computedPageTurnAnimationDuration: number;
+                        computedSnapAnimationDuration: number;
+                    };
+                    setSettings: (data: Partial<import("./settings").PublicSettings>) => void;
+                    $: {
+                        hasVerticalWriting$: import("rxjs").Observable<boolean>;
+                        destroy$: import("rxjs").Observable<void>;
+                        settings$: import("rxjs").Observable<import("./settings").PublicSettings & {
+                            computedPageTurnMode: "controlled" | "scrollable";
+                            computedPageTurnDirection: "vertical" | "horizontal";
+                            computedPageTurnAnimation: "none" | "fade" | "slide";
+                            computedPageTurnAnimationDuration: number;
+                            computedSnapAnimationDuration: number;
+                        }>;
+                        load$: import("rxjs").Observable<import("@prose-reader/shared").Manifest>;
+                    };
+                }) => HTMLDivElement;
+                getElementDimensions: () => {
+                    width: number;
+                    height: number;
+                };
+                getHtmlFromResource: (response: Response) => Promise<string>;
+                getResource: () => Promise<Response>;
+                translateFramePositionIntoPage: (position: {
+                    clientX: number;
+                    clientY: number;
+                }) => {
+                    clientX: number;
+                    clientY: number;
+                };
+                setLayoutDirty: () => void;
+                injectStyle: (cssText: string) => void;
+                loadContent: () => void;
+                unloadContent: () => void;
+                spineItemFrame: {
+                    getIsLoaded: () => boolean;
+                    getIsReady: () => boolean;
+                    getViewportDimensions: () => {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    getFrameElement: () => HTMLIFrameElement | undefined;
+                    getHtmlFromResource: (response: Response) => Promise<string>;
+                    load: () => void;
+                    unload: () => void;
+                    staticLayout: (size: {
+                        width: number;
+                        height: number;
+                    }) => void;
+                    getManipulableFrame: () => {
+                        frame: HTMLIFrameElement;
+                        removeStyle: (id: string) => void;
+                        addStyle: (id: string, style: string, prepend?: boolean) => void;
+                    } | undefined;
+                    getReadingDirection: () => "ltr" | "rtl" | undefined;
+                    isUsingVerticalWriting: () => boolean;
+                    getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined;
+                    destroy: () => void;
+                    $: {
+                        unload$: import("rxjs").Observable<void>;
+                        unloaded$: import("rxjs").Observable<void>;
+                        loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                        ready$: import("rxjs").Observable<FontFaceSet | undefined>;
+                        isReady$: import("rxjs").Observable<boolean>;
+                        contentLayoutChange$: import("rxjs").Observable<{
+                            isFirstLayout: boolean;
+                        } | {
+                            isFirstLayout: boolean;
+                        }>;
+                    };
+                };
+                element: HTMLElement;
+                loadingElement: HTMLDivElement;
+                isReflowable: boolean;
+                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+                getViewPortInformation: () => {
+                    computedScale: number;
+                    computedWidthScale: number;
+                    viewportDimensions: {
+                        width: number;
+                        height: number;
+                    };
+                } | {
+                    width?: number | undefined;
+                    height?: number | undefined;
+                    computedScale: number;
+                    computedWidthScale: number;
+                    viewportDimensions?: undefined;
+                };
+                isImageType: () => boolean | undefined;
+                isReady: () => boolean;
+                destroy: () => void;
+                isUsingVerticalWriting: () => boolean | undefined;
+                getReadingDirection: () => "ltr" | "rtl" | undefined;
+                manipulateSpineItem: (cb: (options: {
+                    container: HTMLElement;
+                    loadingElement: HTMLElement;
+                    item: {
+                        id: string;
+                        href: string;
+                        path: string;
+                        renditionLayout: "reflowable" | "pre-paginated";
+                        progressionWeight: number;
+                        pageSpreadLeft: true | undefined;
+                        pageSpreadRight: true | undefined;
+                        mediaType?: string | undefined;
+                    };
+                    overlayElement: HTMLDivElement;
+                } & ({
+                    frame: HTMLIFrameElement;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string, prepend?: boolean) => void;
+                } | {
+                    frame: undefined;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string) => void;
+                })) => boolean) => boolean;
+                executeOnLayoutBeforeMeasurmentHook: (options: {
+                    minimumWidth: number;
+                }) => void;
+                selectionTracker: {
+                    track: (frameToTrack: HTMLIFrameElement) => void;
+                    destroy: () => void;
+                    isSelecting: () => boolean;
+                    getSelection: () => Selection | undefined;
+                    $: import("rxjs").Observable<{
+                        event: "selectionchange";
+                        data: Selection | null;
+                    } | {
+                        event: "selectstart";
+                        data: Selection | null;
+                    } | {
+                        event: "selectend";
+                        data: Selection | null;
+                    }>;
+                };
+                fingerTracker: {
+                    track: (frame: HTMLIFrameElement) => void;
+                    getFingerPositionInIframe(): {
+                        x: number | undefined;
+                        y: number | undefined;
+                    } | undefined;
+                    destroy: () => void;
+                    $: import("rxjs").Observable<{
+                        event: "fingermove";
+                        data: {
+                            x: number;
+                            y: number;
+                        };
+                    } | {
+                        event: "fingerout";
+                        data: undefined;
+                    }>;
+                };
+                $: {
+                    contentLayoutChangeSubject$: import("rxjs").Observable<{
+                        isFirstLayout: boolean;
+                        isReady: boolean;
+                    }>;
+                    loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                };
+            }) | undefined);
+            getSpineItemFromIframe: (iframe: Element) => import("./spineItem/createSpineItem").SpineItem | undefined;
+            getSpineItemPageIndexFromNode: (node: Node, offset: number | undefined, spineItemOrIndex: number | import("./spineItem/createSpineItem").SpineItem) => number | undefined;
+            getSpineItemsFromReadingOrderPosition: (position: {
+                x: number;
+                y: number;
+            }) => {
+                left: number;
+                right: number;
+                begin: number;
+                beginPosition: {
+                    x: number;
+                    y: number;
+                };
+                end: number;
+                endPosition: {
+                    x: number;
+                    y: number;
+                };
+            } | undefined;
+        };
+        spineItemLocator: {
+            getSpineItemPositionFromNode: (node: Node, offset: number, spineItem: import("./spineItem/createSpineItem").SpineItem) => {
+                x: number;
+                y: number;
+            } | undefined;
+            getSpineItemPositionFromPageIndex: (pageIndex: number, spineItem: import("./spineItem/createSpineItem").SpineItem) => {
+                x: number;
+                y: number;
+            };
+            getSpineItemOffsetFromAnchor: (anchor: string, spineItem: import("./spineItem/createSpineItem").SpineItem) => number;
+            getSpineItemPageIndexFromPosition: (position: {
+                x: number;
+                y: number;
+            }, spineItem: import("./spineItem/createSpineItem").SpineItem) => number;
+            getSpineItemPageIndexFromNode: (node: Node, offset: number, spineItem: import("./spineItem/createSpineItem").SpineItem) => number | undefined;
+            getSpineItemClosestPositionFromUnsafePosition: (unsafePosition: {
+                x: number;
+                y: number;
+            }, spineItem: import("./spineItem/createSpineItem").SpineItem) => {
+                x: number;
+                y: number;
+            };
+            getFirstNodeOrRangeAtPage: (pageIndex: number, spineItem: import("./spineItem/createSpineItem").SpineItem) => {
+                node: Node;
+                offset: number;
+            } | undefined;
+        };
+        cfiLocator: {
+            getSpineItemFromCfi: (cfi: string) => ({
+                item: {
+                    id: string;
+                    href: string;
+                    path: string;
+                    renditionLayout: "reflowable" | "pre-paginated";
+                    progressionWeight: number;
+                    pageSpreadLeft: true | undefined;
+                    pageSpreadRight: true | undefined;
+                    mediaType?: string | undefined;
+                };
+            } & {
+                layout: (layoutInformation: {
+                    blankPagePosition: "after" | "before" | "none";
+                    minimumWidth: number;
+                    spreadPosition: "right" | "left" | "none";
+                }) => {
+                    width: number;
+                    height: number;
+                };
+                load: () => void;
+                adjustPositionOfElement: ({ right, left, top }: {
+                    right?: number | undefined;
+                    left?: number | undefined;
+                    top?: number | undefined;
+                }) => void;
+                createLoadingElement: (containerElement: HTMLElement, item: {
+                    id: string;
+                    href: string;
+                    path: string;
+                    renditionLayout: "reflowable" | "pre-paginated";
+                    progressionWeight: number;
+                    pageSpreadLeft: true | undefined;
+                    pageSpreadRight: true | undefined;
+                    mediaType?: string | undefined;
+                }, context: {
+                    load: (newManifest: import("@prose-reader/shared").Manifest, newLoadOptions: import("./types").LoadOptions) => void;
+                    isRTL: () => boolean;
+                    areAllItemsPrePaginated: () => boolean;
+                    destroy: () => void;
+                    getLoadOptions: () => import("./types").LoadOptions | undefined;
+                    getCalculatedInnerMargin: () => number;
+                    getVisibleAreaRect: () => {
+                        width: number;
+                        height: number;
+                        x: number;
+                        y: number;
+                    };
+                    shouldDisplaySpread: () => boolean;
+                    setHasVerticalWriting: () => void;
+                    setVisibleAreaRect: (x: number, y: number, width: number, height: number) => void;
+                    getManifest: () => import("@prose-reader/shared").Manifest | undefined;
+                    getReadingDirection: () => "ltr" | "rtl" | undefined;
+                    getPageSize: () => {
+                        width: number;
+                        height: number;
+                    };
+                    getSettings: () => import("./settings").PublicSettings & {
+                        computedPageTurnMode: "controlled" | "scrollable";
+                        computedPageTurnDirection: "vertical" | "horizontal";
+                        computedPageTurnAnimation: "none" | "fade" | "slide";
+                        computedPageTurnAnimationDuration: number;
+                        computedSnapAnimationDuration: number;
+                    };
+                    setSettings: (data: Partial<import("./settings").PublicSettings>) => void;
+                    $: {
+                        hasVerticalWriting$: import("rxjs").Observable<boolean>;
+                        destroy$: import("rxjs").Observable<void>;
+                        settings$: import("rxjs").Observable<import("./settings").PublicSettings & {
+                            computedPageTurnMode: "controlled" | "scrollable";
+                            computedPageTurnDirection: "vertical" | "horizontal";
+                            computedPageTurnAnimation: "none" | "fade" | "slide";
+                            computedPageTurnAnimationDuration: number;
+                            computedSnapAnimationDuration: number;
+                        }>;
+                        load$: import("rxjs").Observable<import("@prose-reader/shared").Manifest>;
+                    };
+                }) => HTMLDivElement;
+                getElementDimensions: () => {
+                    width: number;
+                    height: number;
+                };
+                getHtmlFromResource: (response: Response) => Promise<string>;
+                getResource: () => Promise<Response>;
+                translateFramePositionIntoPage: (position: {
+                    clientX: number;
+                    clientY: number;
+                }) => {
+                    clientX: number;
+                    clientY: number;
+                };
+                setLayoutDirty: () => void;
+                injectStyle: (cssText: string) => void;
+                loadContent: () => void;
+                unloadContent: () => void;
+                spineItemFrame: {
+                    getIsLoaded: () => boolean;
+                    getIsReady: () => boolean;
+                    getViewportDimensions: () => {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    getFrameElement: () => HTMLIFrameElement | undefined;
+                    getHtmlFromResource: (response: Response) => Promise<string>;
+                    load: () => void;
+                    unload: () => void;
+                    staticLayout: (size: {
+                        width: number;
+                        height: number;
+                    }) => void;
+                    getManipulableFrame: () => {
+                        frame: HTMLIFrameElement;
+                        removeStyle: (id: string) => void;
+                        addStyle: (id: string, style: string, prepend?: boolean) => void;
+                    } | undefined;
+                    getReadingDirection: () => "ltr" | "rtl" | undefined;
+                    isUsingVerticalWriting: () => boolean;
+                    getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined;
+                    destroy: () => void;
+                    $: {
+                        unload$: import("rxjs").Observable<void>;
+                        unloaded$: import("rxjs").Observable<void>;
+                        loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                        ready$: import("rxjs").Observable<FontFaceSet | undefined>;
+                        isReady$: import("rxjs").Observable<boolean>;
+                        contentLayoutChange$: import("rxjs").Observable<{
+                            isFirstLayout: boolean;
+                        } | {
+                            isFirstLayout: boolean;
+                        }>;
+                    };
+                };
+                element: HTMLElement;
+                loadingElement: HTMLDivElement;
+                isReflowable: boolean;
+                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+                getViewPortInformation: () => {
+                    computedScale: number;
+                    computedWidthScale: number;
+                    viewportDimensions: {
+                        width: number;
+                        height: number;
+                    };
+                } | {
+                    width?: number | undefined;
+                    height?: number | undefined;
+                    computedScale: number;
+                    computedWidthScale: number;
+                    viewportDimensions?: undefined;
+                };
+                isImageType: () => boolean | undefined;
+                isReady: () => boolean;
+                destroy: () => void;
+                isUsingVerticalWriting: () => boolean | undefined;
+                getReadingDirection: () => "ltr" | "rtl" | undefined;
+                manipulateSpineItem: (cb: (options: {
+                    container: HTMLElement;
+                    loadingElement: HTMLElement;
+                    item: {
+                        id: string;
+                        href: string;
+                        path: string;
+                        renditionLayout: "reflowable" | "pre-paginated";
+                        progressionWeight: number;
+                        pageSpreadLeft: true | undefined;
+                        pageSpreadRight: true | undefined;
+                        mediaType?: string | undefined;
+                    };
+                    overlayElement: HTMLDivElement;
+                } & ({
+                    frame: HTMLIFrameElement;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string, prepend?: boolean) => void;
+                } | {
+                    frame: undefined;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string) => void;
+                })) => boolean) => boolean;
+                executeOnLayoutBeforeMeasurmentHook: (options: {
+                    minimumWidth: number;
+                }) => void;
+                selectionTracker: {
+                    track: (frameToTrack: HTMLIFrameElement) => void;
+                    destroy: () => void;
+                    isSelecting: () => boolean;
+                    getSelection: () => Selection | undefined;
+                    $: import("rxjs").Observable<{
+                        event: "selectionchange";
+                        data: Selection | null;
+                    } | {
+                        event: "selectstart";
+                        data: Selection | null;
+                    } | {
+                        event: "selectend";
+                        data: Selection | null;
+                    }>;
+                };
+                fingerTracker: {
+                    track: (frame: HTMLIFrameElement) => void;
+                    getFingerPositionInIframe(): {
+                        x: number | undefined;
+                        y: number | undefined;
+                    } | undefined;
+                    destroy: () => void;
+                    $: import("rxjs").Observable<{
+                        event: "fingermove";
+                        data: {
+                            x: number;
+                            y: number;
+                        };
+                    } | {
+                        event: "fingerout";
+                        data: undefined;
+                    }>;
+                };
+                $: {
+                    contentLayoutChangeSubject$: import("rxjs").Observable<{
+                        isFirstLayout: boolean;
+                        isReady: boolean;
+                    }>;
+                    loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                };
+            }) | undefined;
+            getCfiMetaInformation: (cfi: string) => {
+                spineItemIndex: number | undefined;
+            } | undefined;
+            getCfi: ((pageIndex: number, spineItem: import("./spineItem/createSpineItem").SpineItem) => string) | ((pageIndex: number, spineItem: import("./spineItem/createSpineItem").SpineItem) => string);
+            getRootCfi: (spineItem: import("./spineItem/createSpineItem").SpineItem) => string;
+            resolveCfi: (cfiString: string) => {
+                node: Node | undefined;
+                offset: number | undefined;
+                spineItemIndex: number;
+            } | {
+                spineItemIndex: number;
+                node?: undefined;
+                offset?: undefined;
+            } | undefined;
+            generateFromRange: ({ startNode, start, end, endNode }: {
+                startNode: Node;
+                start: number;
+                endNode: Node;
+                end: number;
+            }, item: {
+                id: string;
+                href: string;
+                path: string;
+                renditionLayout: "reflowable" | "pre-paginated";
+                progressionWeight: number;
+                pageSpreadLeft: true | undefined;
+                pageSpreadRight: true | undefined;
+                mediaType?: string | undefined;
+            }) => {
+                start: string;
+                end: string;
+            };
+        };
+        normalizeEventForViewport: <E extends MouseEvent | TouchEvent | PointerEvent>(event: E) => E;
+        manipulateSpineItems: (cb: (payload: ({
+            container: HTMLElement;
+            loadingElement: HTMLElement;
+            item: {
+                id: string;
+                href: string;
+                path: string;
+                renditionLayout: "reflowable" | "pre-paginated";
+                progressionWeight: number;
+                pageSpreadLeft: true | undefined;
+                pageSpreadRight: true | undefined;
+                mediaType?: string | undefined;
+            };
+            overlayElement: HTMLDivElement;
+        } & ({
+            frame: HTMLIFrameElement;
+            removeStyle: (id: string) => void;
+            addStyle: (id: string, style: string, prepend?: boolean) => void;
+        } | {
+            frame: undefined;
+            removeStyle: (id: string) => void;
+            addStyle: (id: string, style: string) => void;
+        })) & {
+            index: number;
+        }) => boolean) => void;
+        layout: () => void;
+        destroy: () => void;
+        isSelecting: () => boolean | undefined;
+        getSelection: () => Selection | undefined;
+        $: {
+            $: import("rxjs").Observable<{
+                type: "onSelectionChange";
+                data: {
+                    toString: () => string;
+                    getAnchorCfi: () => string | undefined;
+                    getFocusCfi: () => string | undefined;
+                } | null;
+            }>;
+            viewportState$: import("rxjs").Observable<"free" | "busy">;
+            layout$: import("rxjs").Observable<boolean>;
+        };
+    };
+    manipulateSpineItems: (cb: (payload: ({
+        container: HTMLElement;
+        loadingElement: HTMLElement;
+        item: {
+            id: string;
+            href: string;
+            path: string;
+            renditionLayout: "reflowable" | "pre-paginated";
+            progressionWeight: number;
+            pageSpreadLeft: true | undefined;
+            pageSpreadRight: true | undefined;
+            mediaType?: string | undefined;
+        };
+        overlayElement: HTMLDivElement;
+    } & ({
+        frame: HTMLIFrameElement;
+        removeStyle: (id: string) => void;
+        addStyle: (id: string, style: string, prepend?: boolean) => void;
+    } | {
+        frame: undefined;
+        removeStyle: (id: string) => void;
+        addStyle: (id: string, style: string) => void;
+    })) & {
+        index: number;
+    }) => boolean) => void;
+    manipulateContainer: (cb: (container: HTMLElement) => boolean) => void;
+    moveTo: ((delta: {
+        x: number;
+        y: number;
+    } | undefined, { final, start }?: {
+        start?: boolean | undefined;
+        final?: boolean | undefined;
+    }) => void) | ((args_0: {
+        x: number;
+        y: number;
+    } | undefined, args_1?: {
+        start?: boolean | undefined;
+        final?: boolean | undefined;
+    } | undefined) => void);
+    turnLeft: ({ allowSpineItemChange }?: {
+        allowSpineItemChange?: boolean | undefined;
+    }) => void;
+    turnRight: ({ allowSpineItemChange }?: {
+        allowSpineItemChange?: boolean | undefined;
+    }) => void;
+    goToPageOfCurrentChapter: (pageIndex: number) => void;
+    goToPage: (pageIndex: number) => void;
+    goToUrl: (url: string | URL) => void;
+    goToCfi: (cfi: string, options?: {
+        animate: boolean;
+    }) => void;
+    goToSpineItem: (indexOrId: string | number, options?: {
+        animate: boolean;
+    }) => void;
+    getFocusedSpineItemIndex: () => number | undefined;
+    getSpineItem: (indexOrId: string | number) => import("./spineItem/createSpineItem").SpineItem | undefined;
+    getSpineItems: () => import("./spineItem/createSpineItem").SpineItem[];
+    getAbsolutePositionOf: ((spineItemOrIndex: number | import("./spineItem/createSpineItem").SpineItem) => {
+        leftStart: number;
+        leftEnd: number;
+        topStart: number;
+        topEnd: number;
+        width: number;
+        height: number;
+    }) | ((spineItemOrIndex: number | import("./spineItem/createSpineItem").SpineItem) => {
+        leftStart: number;
+        leftEnd: number;
+        topStart: number;
+        topEnd: number;
+        width: number;
+        height: number;
+    });
+    getSelection: () => Selection | undefined;
+    isSelecting: () => boolean | undefined;
+    normalizeEventForViewport: <E extends MouseEvent | TouchEvent | PointerEvent>(event: E) => E;
+    getCfiMetaInformation: (cfi: string) => {
+        spineItemIndex: number | undefined;
+    } | undefined;
+    resolveCfi: (cfiString: string) => {
+        node: Node | undefined;
+        offset: number | undefined;
+        spineItemIndex: number;
+    } | {
+        spineItemIndex: number;
+        node?: undefined;
+        offset?: undefined;
+    } | undefined;
+    generateCfi: ({ startNode, start, end, endNode }: {
+        startNode: Node;
+        start: number;
+        endNode: Node;
+        end: number;
+    }, item: {
+        id: string;
+        href: string;
+        path: string;
+        renditionLayout: "reflowable" | "pre-paginated";
+        progressionWeight: number;
+        pageSpreadLeft: true | undefined;
+        pageSpreadRight: true | undefined;
+        mediaType?: string | undefined;
+    }) => {
+        start: string;
+        end: string;
+    };
+    locator: {
+        getSpinePositionFromSpineItemPosition: (spineItemPosition: {
+            x: number;
+            y: number;
+            outsideOfBoundaries?: boolean | undefined;
+        }, spineItem: import("./spineItem/createSpineItem").SpineItem) => {
+            x: number;
+            y: number;
+        };
+        getSpinePositionFromSpineItem: (spineItem: import("./spineItem/createSpineItem").SpineItem) => {
+            x: number;
+            y: number;
+        };
+        getSpinePositionFromSpineItemAnchor: (anchor: string, spineItem: import("./spineItem/createSpineItem").SpineItem) => {
+            x: number;
+            y: number;
+        };
+        getSpineItemPositionFromSpinePosition: ((position: {
+            x: number;
+            y: number;
+        }, spineItem: import("./spineItem/createSpineItem").SpineItem) => {
+            x: number;
+            y: number;
+            outsideOfBoundaries?: boolean | undefined;
+        }) | ((position: {
+            x: number;
+            y: number;
+        }, spineItem: import("./spineItem/createSpineItem").SpineItem) => {
+            x: number;
+            y: number;
+            outsideOfBoundaries?: boolean | undefined;
+        });
+        getSpineItemFromPosition: ((position: {
+            x: number;
+            y: number;
+        }) => ({
+            item: {
+                id: string;
+                href: string;
+                path: string;
+                renditionLayout: "reflowable" | "pre-paginated";
+                progressionWeight: number;
+                pageSpreadLeft: true | undefined;
+                pageSpreadRight: true | undefined;
+                mediaType?: string | undefined;
+            };
+        } & {
+            layout: (layoutInformation: {
+                blankPagePosition: "after" | "before" | "none";
+                minimumWidth: number;
+                spreadPosition: "right" | "left" | "none";
+            }) => {
+                width: number;
+                height: number;
+            };
+            load: () => void;
+            adjustPositionOfElement: ({ right, left, top }: {
+                right?: number | undefined;
+                left?: number | undefined;
+                top?: number | undefined;
+            }) => void;
+            createLoadingElement: (containerElement: HTMLElement, item: {
+                id: string;
+                href: string;
+                path: string;
+                renditionLayout: "reflowable" | "pre-paginated";
+                progressionWeight: number;
+                pageSpreadLeft: true | undefined;
+                pageSpreadRight: true | undefined;
+                mediaType?: string | undefined;
+            }, context: {
+                load: (newManifest: import("@prose-reader/shared").Manifest, newLoadOptions: import("./types").LoadOptions) => void;
+                isRTL: () => boolean;
+                areAllItemsPrePaginated: () => boolean;
+                destroy: () => void;
+                getLoadOptions: () => import("./types").LoadOptions | undefined;
+                getCalculatedInnerMargin: () => number;
+                getVisibleAreaRect: () => {
+                    width: number;
+                    height: number;
+                    x: number;
+                    y: number;
+                };
+                shouldDisplaySpread: () => boolean;
+                setHasVerticalWriting: () => void;
+                setVisibleAreaRect: (x: number, y: number, width: number, height: number) => void;
+                getManifest: () => import("@prose-reader/shared").Manifest | undefined;
+                getReadingDirection: () => "ltr" | "rtl" | undefined;
+                getPageSize: () => {
+                    width: number;
+                    height: number;
+                };
+                getSettings: () => import("./settings").PublicSettings & {
+                    computedPageTurnMode: "controlled" | "scrollable";
+                    computedPageTurnDirection: "vertical" | "horizontal";
+                    computedPageTurnAnimation: "none" | "fade" | "slide";
+                    computedPageTurnAnimationDuration: number;
+                    computedSnapAnimationDuration: number;
+                };
+                setSettings: (data: Partial<import("./settings").PublicSettings>) => void;
+                $: {
+                    hasVerticalWriting$: import("rxjs").Observable<boolean>;
+                    destroy$: import("rxjs").Observable<void>;
+                    settings$: import("rxjs").Observable<import("./settings").PublicSettings & {
+                        computedPageTurnMode: "controlled" | "scrollable";
+                        computedPageTurnDirection: "vertical" | "horizontal";
+                        computedPageTurnAnimation: "none" | "fade" | "slide";
+                        computedPageTurnAnimationDuration: number;
+                        computedSnapAnimationDuration: number;
+                    }>;
+                    load$: import("rxjs").Observable<import("@prose-reader/shared").Manifest>;
+                };
+            }) => HTMLDivElement;
+            getElementDimensions: () => {
+                width: number;
+                height: number;
+            };
+            getHtmlFromResource: (response: Response) => Promise<string>;
+            getResource: () => Promise<Response>;
+            translateFramePositionIntoPage: (position: {
+                clientX: number;
+                clientY: number;
+            }) => {
+                clientX: number;
+                clientY: number;
+            };
+            setLayoutDirty: () => void;
+            injectStyle: (cssText: string) => void;
+            loadContent: () => void;
+            unloadContent: () => void;
+            spineItemFrame: {
+                getIsLoaded: () => boolean;
+                getIsReady: () => boolean;
+                getViewportDimensions: () => {
+                    width: number;
+                    height: number;
+                } | undefined;
+                getFrameElement: () => HTMLIFrameElement | undefined;
+                getHtmlFromResource: (response: Response) => Promise<string>;
+                load: () => void;
+                unload: () => void;
+                staticLayout: (size: {
+                    width: number;
+                    height: number;
+                }) => void;
+                getManipulableFrame: () => {
+                    frame: HTMLIFrameElement;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string, prepend?: boolean) => void;
+                } | undefined;
+                getReadingDirection: () => "ltr" | "rtl" | undefined;
+                isUsingVerticalWriting: () => boolean;
+                getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined;
+                destroy: () => void;
+                $: {
+                    unload$: import("rxjs").Observable<void>;
+                    unloaded$: import("rxjs").Observable<void>;
+                    loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                    ready$: import("rxjs").Observable<FontFaceSet | undefined>;
+                    isReady$: import("rxjs").Observable<boolean>;
+                    contentLayoutChange$: import("rxjs").Observable<{
+                        isFirstLayout: boolean;
+                    } | {
+                        isFirstLayout: boolean;
+                    }>;
+                };
+            };
+            element: HTMLElement;
+            loadingElement: HTMLDivElement;
+            isReflowable: boolean;
+            getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+            getViewPortInformation: () => {
+                computedScale: number;
+                computedWidthScale: number;
+                viewportDimensions: {
+                    width: number;
+                    height: number;
+                };
+            } | {
+                width?: number | undefined;
+                height?: number | undefined;
+                computedScale: number;
+                computedWidthScale: number;
+                viewportDimensions?: undefined;
+            };
+            isImageType: () => boolean | undefined;
+            isReady: () => boolean;
+            destroy: () => void;
+            isUsingVerticalWriting: () => boolean | undefined;
+            getReadingDirection: () => "ltr" | "rtl" | undefined;
+            manipulateSpineItem: (cb: (options: {
+                container: HTMLElement;
+                loadingElement: HTMLElement;
+                item: {
+                    id: string;
+                    href: string;
+                    path: string;
+                    renditionLayout: "reflowable" | "pre-paginated";
+                    progressionWeight: number;
+                    pageSpreadLeft: true | undefined;
+                    pageSpreadRight: true | undefined;
+                    mediaType?: string | undefined;
+                };
+                overlayElement: HTMLDivElement;
+            } & ({
+                frame: HTMLIFrameElement;
+                removeStyle: (id: string) => void;
+                addStyle: (id: string, style: string, prepend?: boolean) => void;
+            } | {
+                frame: undefined;
+                removeStyle: (id: string) => void;
+                addStyle: (id: string, style: string) => void;
+            })) => boolean) => boolean;
+            executeOnLayoutBeforeMeasurmentHook: (options: {
+                minimumWidth: number;
+            }) => void;
+            selectionTracker: {
+                track: (frameToTrack: HTMLIFrameElement) => void;
+                destroy: () => void;
+                isSelecting: () => boolean;
+                getSelection: () => Selection | undefined;
+                $: import("rxjs").Observable<{
+                    event: "selectionchange";
+                    data: Selection | null;
+                } | {
+                    event: "selectstart";
+                    data: Selection | null;
+                } | {
+                    event: "selectend";
+                    data: Selection | null;
+                }>;
+            };
+            fingerTracker: {
+                track: (frame: HTMLIFrameElement) => void;
+                getFingerPositionInIframe(): {
+                    x: number | undefined;
+                    y: number | undefined;
+                } | undefined;
+                destroy: () => void;
+                $: import("rxjs").Observable<{
+                    event: "fingermove";
+                    data: {
+                        x: number;
+                        y: number;
+                    };
+                } | {
+                    event: "fingerout";
+                    data: undefined;
+                }>;
+            };
+            $: {
+                contentLayoutChangeSubject$: import("rxjs").Observable<{
+                    isFirstLayout: boolean;
+                    isReady: boolean;
+                }>;
+                loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+            };
+        }) | undefined) | ((position: {
+            x: number;
+            y: number;
+        }) => ({
+            item: {
+                id: string;
+                href: string;
+                path: string;
+                renditionLayout: "reflowable" | "pre-paginated";
+                progressionWeight: number;
+                pageSpreadLeft: true | undefined;
+                pageSpreadRight: true | undefined;
+                mediaType?: string | undefined;
+            };
+        } & {
+            layout: (layoutInformation: {
+                blankPagePosition: "after" | "before" | "none";
+                minimumWidth: number;
+                spreadPosition: "right" | "left" | "none";
+            }) => {
+                width: number;
+                height: number;
+            };
+            load: () => void;
+            adjustPositionOfElement: ({ right, left, top }: {
+                right?: number | undefined;
+                left?: number | undefined;
+                top?: number | undefined;
+            }) => void;
+            createLoadingElement: (containerElement: HTMLElement, item: {
+                id: string;
+                href: string;
+                path: string;
+                renditionLayout: "reflowable" | "pre-paginated";
+                progressionWeight: number;
+                pageSpreadLeft: true | undefined;
+                pageSpreadRight: true | undefined;
+                mediaType?: string | undefined;
+            }, context: {
+                load: (newManifest: import("@prose-reader/shared").Manifest, newLoadOptions: import("./types").LoadOptions) => void;
+                isRTL: () => boolean;
+                areAllItemsPrePaginated: () => boolean;
+                destroy: () => void;
+                getLoadOptions: () => import("./types").LoadOptions | undefined;
+                getCalculatedInnerMargin: () => number;
+                getVisibleAreaRect: () => {
+                    width: number;
+                    height: number;
+                    x: number;
+                    y: number;
+                };
+                shouldDisplaySpread: () => boolean;
+                setHasVerticalWriting: () => void;
+                setVisibleAreaRect: (x: number, y: number, width: number, height: number) => void;
+                getManifest: () => import("@prose-reader/shared").Manifest | undefined;
+                getReadingDirection: () => "ltr" | "rtl" | undefined;
+                getPageSize: () => {
+                    width: number;
+                    height: number;
+                };
+                getSettings: () => import("./settings").PublicSettings & {
+                    computedPageTurnMode: "controlled" | "scrollable";
+                    computedPageTurnDirection: "vertical" | "horizontal";
+                    computedPageTurnAnimation: "none" | "fade" | "slide";
+                    computedPageTurnAnimationDuration: number;
+                    computedSnapAnimationDuration: number;
+                };
+                setSettings: (data: Partial<import("./settings").PublicSettings>) => void;
+                $: {
+                    hasVerticalWriting$: import("rxjs").Observable<boolean>;
+                    destroy$: import("rxjs").Observable<void>;
+                    settings$: import("rxjs").Observable<import("./settings").PublicSettings & {
+                        computedPageTurnMode: "controlled" | "scrollable";
+                        computedPageTurnDirection: "vertical" | "horizontal";
+                        computedPageTurnAnimation: "none" | "fade" | "slide";
+                        computedPageTurnAnimationDuration: number;
+                        computedSnapAnimationDuration: number;
+                    }>;
+                    load$: import("rxjs").Observable<import("@prose-reader/shared").Manifest>;
+                };
+            }) => HTMLDivElement;
+            getElementDimensions: () => {
+                width: number;
+                height: number;
+            };
+            getHtmlFromResource: (response: Response) => Promise<string>;
+            getResource: () => Promise<Response>;
+            translateFramePositionIntoPage: (position: {
+                clientX: number;
+                clientY: number;
+            }) => {
+                clientX: number;
+                clientY: number;
+            };
+            setLayoutDirty: () => void;
+            injectStyle: (cssText: string) => void;
+            loadContent: () => void;
+            unloadContent: () => void;
+            spineItemFrame: {
+                getIsLoaded: () => boolean;
+                getIsReady: () => boolean;
+                getViewportDimensions: () => {
+                    width: number;
+                    height: number;
+                } | undefined;
+                getFrameElement: () => HTMLIFrameElement | undefined;
+                getHtmlFromResource: (response: Response) => Promise<string>;
+                load: () => void;
+                unload: () => void;
+                staticLayout: (size: {
+                    width: number;
+                    height: number;
+                }) => void;
+                getManipulableFrame: () => {
+                    frame: HTMLIFrameElement;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string, prepend?: boolean) => void;
+                } | undefined;
+                getReadingDirection: () => "ltr" | "rtl" | undefined;
+                isUsingVerticalWriting: () => boolean;
+                getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined;
+                destroy: () => void;
+                $: {
+                    unload$: import("rxjs").Observable<void>;
+                    unloaded$: import("rxjs").Observable<void>;
+                    loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                    ready$: import("rxjs").Observable<FontFaceSet | undefined>;
+                    isReady$: import("rxjs").Observable<boolean>;
+                    contentLayoutChange$: import("rxjs").Observable<{
+                        isFirstLayout: boolean;
+                    } | {
+                        isFirstLayout: boolean;
+                    }>;
+                };
+            };
+            element: HTMLElement;
+            loadingElement: HTMLDivElement;
+            isReflowable: boolean;
+            getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+            getViewPortInformation: () => {
+                computedScale: number;
+                computedWidthScale: number;
+                viewportDimensions: {
+                    width: number;
+                    height: number;
+                };
+            } | {
+                width?: number | undefined;
+                height?: number | undefined;
+                computedScale: number;
+                computedWidthScale: number;
+                viewportDimensions?: undefined;
+            };
+            isImageType: () => boolean | undefined;
+            isReady: () => boolean;
+            destroy: () => void;
+            isUsingVerticalWriting: () => boolean | undefined;
+            getReadingDirection: () => "ltr" | "rtl" | undefined;
+            manipulateSpineItem: (cb: (options: {
+                container: HTMLElement;
+                loadingElement: HTMLElement;
+                item: {
+                    id: string;
+                    href: string;
+                    path: string;
+                    renditionLayout: "reflowable" | "pre-paginated";
+                    progressionWeight: number;
+                    pageSpreadLeft: true | undefined;
+                    pageSpreadRight: true | undefined;
+                    mediaType?: string | undefined;
+                };
+                overlayElement: HTMLDivElement;
+            } & ({
+                frame: HTMLIFrameElement;
+                removeStyle: (id: string) => void;
+                addStyle: (id: string, style: string, prepend?: boolean) => void;
+            } | {
+                frame: undefined;
+                removeStyle: (id: string) => void;
+                addStyle: (id: string, style: string) => void;
+            })) => boolean) => boolean;
+            executeOnLayoutBeforeMeasurmentHook: (options: {
+                minimumWidth: number;
+            }) => void;
+            selectionTracker: {
+                track: (frameToTrack: HTMLIFrameElement) => void;
+                destroy: () => void;
+                isSelecting: () => boolean;
+                getSelection: () => Selection | undefined;
+                $: import("rxjs").Observable<{
+                    event: "selectionchange";
+                    data: Selection | null;
+                } | {
+                    event: "selectstart";
+                    data: Selection | null;
+                } | {
+                    event: "selectend";
+                    data: Selection | null;
+                }>;
+            };
+            fingerTracker: {
+                track: (frame: HTMLIFrameElement) => void;
+                getFingerPositionInIframe(): {
+                    x: number | undefined;
+                    y: number | undefined;
+                } | undefined;
+                destroy: () => void;
+                $: import("rxjs").Observable<{
+                    event: "fingermove";
+                    data: {
+                        x: number;
+                        y: number;
+                    };
+                } | {
+                    event: "fingerout";
+                    data: undefined;
+                }>;
+            };
+            $: {
+                contentLayoutChangeSubject$: import("rxjs").Observable<{
+                    isFirstLayout: boolean;
+                    isReady: boolean;
+                }>;
+                loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+            };
+        }) | undefined);
+        getSpineItemFromIframe: (iframe: Element) => import("./spineItem/createSpineItem").SpineItem | undefined;
+        getSpineItemPageIndexFromNode: (node: Node, offset: number | undefined, spineItemOrIndex: number | import("./spineItem/createSpineItem").SpineItem) => number | undefined;
+        getSpineItemsFromReadingOrderPosition: (position: {
+            x: number;
+            y: number;
+        }) => {
+            left: number;
+            right: number;
+            begin: number;
+            beginPosition: {
+                x: number;
+                y: number;
+            };
+            end: number;
+            endPosition: {
+                x: number;
+                y: number;
+            };
+        } | undefined;
+    };
+    getCurrentNavigationPosition: () => import("./spine/navigationResolver").ViewportNavigationEntry;
+    getCurrentViewportPosition: (() => {
+        x: number;
+        y: number;
+    }) | (() => {
+        x: number;
+        y: number;
+    });
+    layout: () => void;
+    load: (manifest: import("@prose-reader/shared").Manifest, loadOptions?: import("./types").LoadOptions | undefined) => void;
+    destroy: () => void;
+    $: Omit<{
+        pagination$: import("rxjs").Observable<{
+            beginPageIndex: number | undefined;
+            beginNumberOfPages: number;
+            beginCfi: string | undefined;
+            beginSpineItemIndex: number | undefined;
+            endPageIndex: number | undefined;
+            endNumberOfPages: number;
+            endCfi: string | undefined;
+            endSpineItemIndex: number | undefined;
+        }>;
+        settings$: import("rxjs").Observable<import("./settings").PublicSettings & {
+            computedPageTurnMode: "controlled" | "scrollable";
+            computedPageTurnDirection: "vertical" | "horizontal";
+            computedPageTurnAnimation: "none" | "fade" | "slide";
+            computedPageTurnAnimationDuration: number;
+            computedSnapAnimationDuration: number;
+        }>;
+        state$: import("rxjs").Observable<{
+            supportedPageTurnAnimation: ("none" | "fade" | "slide")[];
+            supportedPageTurnMode: ("controlled" | "scrollable")[];
+            supportedPageTurnDirection: ("vertical" | "horizontal")[];
+            supportedComputedPageTurnDirection: ("vertical" | "horizontal")[];
+        }>;
+        ready$: import("rxjs").Observable<void>;
+        selection$: import("rxjs").Observable<{
+            toString: () => string;
+            getAnchorCfi: () => string | undefined;
+            getFocusCfi: () => string | undefined;
+        } | null>;
+        viewportState$: import("rxjs").Observable<"free" | "busy">;
+        layout$: import("rxjs").Observable<boolean>;
+        destroy$: import("rxjs").Observable<void>;
+    }, "settings$"> & {
+        settings$: import("rxjs").Observable<import("./settings").PublicSettings & {
+            computedPageTurnMode: "controlled" | "scrollable";
+            computedPageTurnDirection: "vertical" | "horizontal";
+            computedPageTurnAnimation: "none" | "fade" | "slide";
+            computedPageTurnAnimationDuration: number;
+            computedSnapAnimationDuration: number;
+        }>;
+    };
+} & Omit<{
+    setSettings: (settings: Partial<import("./settings").PublicSettings>) => void;
+} & {
+    progression: {
+        getPercentageEstimate: (context: {
+            load: (newManifest: import("@prose-reader/shared").Manifest, newLoadOptions: import("./types").LoadOptions) => void;
+            isRTL: () => boolean;
+            areAllItemsPrePaginated: () => boolean;
+            destroy: () => void;
+            getLoadOptions: () => import("./types").LoadOptions | undefined;
+            getCalculatedInnerMargin: () => number;
+            getVisibleAreaRect: () => {
+                width: number;
+                height: number;
+                x: number;
+                y: number;
+            };
+            shouldDisplaySpread: () => boolean;
+            setHasVerticalWriting: () => void;
+            setVisibleAreaRect: (x: number, y: number, width: number, height: number) => void;
+            getManifest: () => import("@prose-reader/shared").Manifest | undefined;
+            getReadingDirection: () => "ltr" | "rtl" | undefined;
+            getPageSize: () => {
+                width: number;
+                height: number;
+            };
+            getSettings: () => import("./settings").PublicSettings & {
+                computedPageTurnMode: "controlled" | "scrollable";
+                computedPageTurnDirection: "vertical" | "horizontal";
+                computedPageTurnAnimation: "none" | "fade" | "slide";
+                computedPageTurnAnimationDuration: number;
+                computedSnapAnimationDuration: number;
+            };
+            setSettings: (data: Partial<import("./settings").PublicSettings>) => void;
+            $: {
+                hasVerticalWriting$: import("rxjs").Observable<boolean>;
+                destroy$: import("rxjs").Observable<void>;
+                settings$: import("rxjs").Observable<import("./settings").PublicSettings & {
+                    computedPageTurnMode: "controlled" | "scrollable";
+                    computedPageTurnDirection: "vertical" | "horizontal";
+                    computedPageTurnAnimation: "none" | "fade" | "slide";
+                    computedPageTurnAnimationDuration: number;
+                    computedSnapAnimationDuration: number;
+                }>;
+                load$: import("rxjs").Observable<import("@prose-reader/shared").Manifest>;
+            };
+        }, currentSpineIndex: number, numberOfPages: number, pageIndex: number, currentPosition: {
+            x: number;
+            y: number;
+        }, currentItem: import("./spineItem/createSpineItem").SpineItem) => number;
+        getScrollPercentageWithinItem: (context: {
+            load: (newManifest: import("@prose-reader/shared").Manifest, newLoadOptions: import("./types").LoadOptions) => void;
+            isRTL: () => boolean;
+            areAllItemsPrePaginated: () => boolean;
+            destroy: () => void;
+            getLoadOptions: () => import("./types").LoadOptions | undefined;
+            getCalculatedInnerMargin: () => number;
+            getVisibleAreaRect: () => {
+                width: number;
+                height: number;
+                x: number;
+                y: number;
+            };
+            shouldDisplaySpread: () => boolean;
+            setHasVerticalWriting: () => void;
+            setVisibleAreaRect: (x: number, y: number, width: number, height: number) => void;
+            getManifest: () => import("@prose-reader/shared").Manifest | undefined;
+            getReadingDirection: () => "ltr" | "rtl" | undefined;
+            getPageSize: () => {
+                width: number;
+                height: number;
+            };
+            getSettings: () => import("./settings").PublicSettings & {
+                computedPageTurnMode: "controlled" | "scrollable";
+                computedPageTurnDirection: "vertical" | "horizontal";
+                computedPageTurnAnimation: "none" | "fade" | "slide";
+                computedPageTurnAnimationDuration: number;
+                computedSnapAnimationDuration: number;
+            };
+            setSettings: (data: Partial<import("./settings").PublicSettings>) => void;
+            $: {
+                hasVerticalWriting$: import("rxjs").Observable<boolean>;
+                destroy$: import("rxjs").Observable<void>;
+                settings$: import("rxjs").Observable<import("./settings").PublicSettings & {
+                    computedPageTurnMode: "controlled" | "scrollable";
+                    computedPageTurnDirection: "vertical" | "horizontal";
+                    computedPageTurnAnimation: "none" | "fade" | "slide";
+                    computedPageTurnAnimationDuration: number;
+                    computedSnapAnimationDuration: number;
+                }>;
+                load$: import("rxjs").Observable<import("@prose-reader/shared").Manifest>;
+            };
+        }, currentPosition: {
+            x: number;
+            y: number;
+        }, currentItem: import("./spineItem/createSpineItem").SpineItem) => number;
+    };
+}, "setSettings" | "context" | "registerHook" | "spine" | "manipulateSpineItems" | "manipulateContainer" | "moveTo" | "turnLeft" | "turnRight" | "goToPageOfCurrentChapter" | "goToPage" | "goToUrl" | "goToCfi" | "goToSpineItem" | "getFocusedSpineItemIndex" | "getSpineItem" | "getSpineItems" | "getAbsolutePositionOf" | "getSelection" | "isSelecting" | "normalizeEventForViewport" | "getCfiMetaInformation" | "resolveCfi" | "generateCfi" | "locator" | "getCurrentNavigationPosition" | "getCurrentViewportPosition" | "layout" | "load" | "destroy" | "$"> & {
+    __API?: {
+        progression: {
+            getPercentageEstimate: (context: {
+                load: (newManifest: import("@prose-reader/shared").Manifest, newLoadOptions: import("./types").LoadOptions) => void;
+                isRTL: () => boolean;
+                areAllItemsPrePaginated: () => boolean;
+                destroy: () => void;
+                getLoadOptions: () => import("./types").LoadOptions | undefined;
+                getCalculatedInnerMargin: () => number;
+                getVisibleAreaRect: () => {
+                    width: number;
+                    height: number;
+                    x: number;
+                    y: number;
+                };
+                shouldDisplaySpread: () => boolean;
+                setHasVerticalWriting: () => void;
+                setVisibleAreaRect: (x: number, y: number, width: number, height: number) => void;
+                getManifest: () => import("@prose-reader/shared").Manifest | undefined;
+                getReadingDirection: () => "ltr" | "rtl" | undefined;
+                getPageSize: () => {
+                    width: number;
+                    height: number;
+                };
+                getSettings: () => import("./settings").PublicSettings & {
+                    computedPageTurnMode: "controlled" | "scrollable";
+                    computedPageTurnDirection: "vertical" | "horizontal";
+                    computedPageTurnAnimation: "none" | "fade" | "slide";
+                    computedPageTurnAnimationDuration: number;
+                    computedSnapAnimationDuration: number;
+                };
+                setSettings: (data: Partial<import("./settings").PublicSettings>) => void;
+                $: {
+                    hasVerticalWriting$: import("rxjs").Observable<boolean>;
+                    destroy$: import("rxjs").Observable<void>;
+                    settings$: import("rxjs").Observable<import("./settings").PublicSettings & {
+                        computedPageTurnMode: "controlled" | "scrollable";
+                        computedPageTurnDirection: "vertical" | "horizontal";
+                        computedPageTurnAnimation: "none" | "fade" | "slide";
+                        computedPageTurnAnimationDuration: number;
+                        computedSnapAnimationDuration: number;
+                    }>;
+                    load$: import("rxjs").Observable<import("@prose-reader/shared").Manifest>;
+                };
+            }, currentSpineIndex: number, numberOfPages: number, pageIndex: number, currentPosition: {
+                x: number;
+                y: number;
+            }, currentItem: import("./spineItem/createSpineItem").SpineItem) => number;
+            getScrollPercentageWithinItem: (context: {
+                load: (newManifest: import("@prose-reader/shared").Manifest, newLoadOptions: import("./types").LoadOptions) => void;
+                isRTL: () => boolean;
+                areAllItemsPrePaginated: () => boolean;
+                destroy: () => void;
+                getLoadOptions: () => import("./types").LoadOptions | undefined;
+                getCalculatedInnerMargin: () => number;
+                getVisibleAreaRect: () => {
+                    width: number;
+                    height: number;
+                    x: number;
+                    y: number;
+                };
+                shouldDisplaySpread: () => boolean;
+                setHasVerticalWriting: () => void;
+                setVisibleAreaRect: (x: number, y: number, width: number, height: number) => void;
+                getManifest: () => import("@prose-reader/shared").Manifest | undefined;
+                getReadingDirection: () => "ltr" | "rtl" | undefined;
+                getPageSize: () => {
+                    width: number;
+                    height: number;
+                };
+                getSettings: () => import("./settings").PublicSettings & {
+                    computedPageTurnMode: "controlled" | "scrollable";
+                    computedPageTurnDirection: "vertical" | "horizontal";
+                    computedPageTurnAnimation: "none" | "fade" | "slide";
+                    computedPageTurnAnimationDuration: number;
+                    computedSnapAnimationDuration: number;
+                };
+                setSettings: (data: Partial<import("./settings").PublicSettings>) => void;
+                $: {
+                    hasVerticalWriting$: import("rxjs").Observable<boolean>;
+                    destroy$: import("rxjs").Observable<void>;
+                    settings$: import("rxjs").Observable<import("./settings").PublicSettings & {
+                        computedPageTurnMode: "controlled" | "scrollable";
+                        computedPageTurnDirection: "vertical" | "horizontal";
+                        computedPageTurnAnimation: "none" | "fade" | "slide";
+                        computedPageTurnAnimationDuration: number;
+                        computedSnapAnimationDuration: number;
+                    }>;
+                    load$: import("rxjs").Observable<import("@prose-reader/shared").Manifest>;
+                };
+            }, currentPosition: {
+                x: number;
+                y: number;
+            }, currentItem: import("./spineItem/createSpineItem").SpineItem) => number;
+        };
+    } | undefined;
+    __OutputSettings?: {} | undefined;
+}>, Enhancer<{}, {}, {}, {}, (createReader: (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi) => (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi, ReaderPublicApi>, Enhancer<{
+    theme?: "bright" | "sepia" | "night" | undefined;
+}, {
+    setTheme: (theme: "bright" | "sepia" | "night" | undefined) => void;
+    getTheme: () => "bright" | "sepia" | "night" | undefined;
+}, {}, {}, (createReader: (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi) => (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi, ReaderPublicApi>, Enhancer<{}, {
+    goToLeftSpineItem: () => void;
+    goToRightSpineItem: () => void;
+}, {}, {}, (createReader: (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi) => (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi, ReaderPublicApi>, Enhancer<{}, {}, {}, {}, (createReader: (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi) => (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi, ReaderPublicApi>, Enhancer<{}, {}, {}, {}, (createReader: (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi) => (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi, ReaderPublicApi>, Enhancer<{}, {
+    zoom: {
+        enter: (imgElement: HTMLImageElement) => void;
+        exit: () => void;
+        move: (position: {
+            x: number;
+            y: number;
+        } | undefined, details: {
+            isFirst: boolean;
+            isLast: boolean;
+        }) => void;
+        isEnabled: () => boolean;
+        scale: (scale: number) => void;
+    };
+}, {}, {}, (createReader: (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi) => (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi, ReaderPublicApi>, Enhancer<{
+    pageHorizontalMargin?: number | undefined;
+    pageVerticalMargin?: number | undefined;
+} & {
+    layoutAutoResize?: false | "container" | undefined;
+}, {}, {
+    pageHorizontalMargin?: number | undefined;
+    pageVerticalMargin?: number | undefined;
+}, Required<{
+    pageHorizontalMargin?: number | undefined;
+    pageVerticalMargin?: number | undefined;
+}>, (createReader: (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi) => (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi, ReaderPublicApi>, Enhancer<{}, {
+    utils: {
+        isOrIsWithinValidLink: (target: EventTarget | null) => boolean;
+    };
+}, {}, {}, (createReader: (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi) => (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi, ReaderPublicApi>, Enhancer<{}, {}, {}, {}, (createReader: (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi) => (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi, ReaderPublicApi>, Enhancer<{}, {}, {}, {}, (createReader: (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi) => (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi, ReaderPublicApi>, Enhancer<{}, {
+    $: {
+        links$: import("rxjs").Observable<{
+            event: "linkClicked";
+            data: HTMLAnchorElement;
+        }>;
+    };
+}, {}, {}, (createReader: (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi) => (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi, ReaderPublicApi>, Enhancer<{
+    fontScale?: number | undefined;
+    lineHeight?: number | "publisher" | undefined;
+    fontWeight?: 200 | "publisher" | 100 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | undefined;
+    fontJustification?: "right" | "left" | "publisher" | "center" | "justify" | undefined;
+}, {}, {
+    fontScale?: number | undefined;
+    lineHeight?: number | "publisher" | undefined;
+    fontWeight?: 200 | "publisher" | 100 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | undefined;
+    fontJustification?: "right" | "left" | "publisher" | "center" | "justify" | undefined;
+}, Required<{
+    fontScale?: number | undefined;
+    lineHeight?: number | "publisher" | undefined;
+    fontWeight?: 200 | "publisher" | 100 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | undefined;
+    fontJustification?: "right" | "left" | "publisher" | "center" | "justify" | undefined;
+}>, (createReader: (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi) => (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi, ReaderPublicApi>, Enhancer<{}, {}, {}, {}, (createReader: (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi) => (options: {
+    hooks?: import("./types/Hook").Hook[] | undefined;
+    containerElement: HTMLElement;
+} & Pick<Partial<import("./settings").PublicSettings>, "forceSinglePageMode" | "pageTurnAnimation" | "pageTurnDirection" | "pageTurnMode">) => ReaderPublicApi, ReaderPublicApi>>;
+declare type WithoutPrivateApi<E> = Omit<E, RemovedKeysOnly | `__debug` | `__API` | `__OutputSettings`>;
+declare type EnhancerOptions<E extends (...args: any) => any> = Parameters<ReturnType<E>>[0];
+declare type EnhancerExposedApi<E extends (...args: any) => any> = ReturnType<ReturnType<E>>;
+export declare type CoreEnhancer = typeof internalEnhancer;
+export declare type CoreEnhancerDependsOn = (createReader: Parameters<CoreEnhancer>[0]) => (options: EnhancerOptions<CoreEnhancer>) => EnhancerExposedApi<CoreEnhancer>;
+export declare type ExternalEnhancer<Options = {}, Api = {}, Settings = {}, OutputSettings = Settings, DependsOn extends (createReader: any) => (options: any) => any = CoreEnhancerDependsOn> = Enhancer<Options, Api, Settings, OutputSettings, DependsOn>;
+export declare function createReaderWithEnhancer(options: EnhancerOptions<CoreEnhancer>): WithoutPrivateApi<EnhancerExposedApi<CoreEnhancer>>;
+export declare function createReaderWithEnhancer<UserEnhancer extends ComposableEnhancer>(options: EnhancerOptions<UserEnhancer> & EnhancerOptions<CoreEnhancer>, enhancer: UserEnhancer): WithoutPrivateApi<EnhancerExposedApi<ComposeEnhancer<typeof internalEnhancer, UserEnhancer>>>;
+export declare type Reader<E extends ComposableEnhancer | void = void> = E extends ComposableEnhancer ? WithoutPrivateApi<EnhancerExposedApi<ComposeEnhancer<CoreEnhancer, E>>> : WithoutPrivateApi<EnhancerExposedApi<CoreEnhancer>>;
+export {};