pptx-react-viewer 1.11.0 → 1.12.0

package/dist/hooks-unstable.d.ts

@@ -0,0 +1,2294 @@
+import { l, P, r, R, a2, A, ap, J, aq, t, u, s, y, z, x, D, v, w, K, bk, B, $, a0, k, ca, I, S, m, d, e, N, o } from './presentation-CLc4eS3z.js';
+import { d as CanvasSize, E as EditorHistorySnapshot, q as PresentationAnimationRuntime, H as ElementAnimationState, V as ViewerMode, D as DragState, r as ResizeState, S as ShapeAdjustmentDragState, M as MarqueeSelectionState, B as SupportedShapeType, l as ElementClipboardPayload, G as ToolbarSection, A as AccessibilityIssue, n as ElementContextMenuState, T as TableCellEditorState, j as DrawingTool, m as ElementContextMenuAction, I as PrintSettings, J as CompareResult, x as SlideSectionGroup, a as PowerPointViewerHandle, C as CollaborationConfig, K as DeviceOrientation, L as TouchGestureCallbacks } from './types-ui-DlsqFx7_.js';
+export { N as MOBILE_BREAKPOINT, O as TABLET_BREAKPOINT } from './types-ui-DlsqFx7_.js';
+import React__default, { Dispatch, SetStateAction, RefObject, MutableRefObject, ForwardedRef } from 'react';
+import { P as PptxHandler, M as MergeShapeOperation, k as PptxSaveFormat, a as CollaborationContextValue } from './usePresenterWindow-BKx5DLJy.js';
+export { C as ConnectionStatus, T as ThemeSwitchingResult, l as UseCollaborativeHistoryInput, b as UseCollaborativeHistoryResult, c as UseCollaborativeStateInput, m as UsePresenceTrackingInput, d as UsePresenceTrackingResult, n as UsePresenterWindowInput, o as UsePresenterWindowResult, e as UseThemeSwitchingInput, p as UseYjsProviderInput, q as UseYjsProviderResult, U as UserPresence, u as useCollaborativeHistory, f as useCollaborativeState, g as usePresenceTracking, r as usePresenterWindow, h as useThemeSwitching, j as useYjsProvider } from './usePresenterWindow-BKx5DLJy.js';
+import { Doc } from 'yjs';
+import './theme/index.js';
+import 'y-protocols/awareness';
+
+interface EditorHistoryInput {
+    slides: l[];
+    canvasSize: CanvasSize;
+    activeSlideIndex: number;
+    templateElementsBySlideId: Record<string, P[]>;
+    selectedElementId: string | null;
+    selectedElementIds: string[];
+    editTemplateMode: boolean;
+    headerFooter: r;
+    loading: boolean;
+    error: string | null;
+    hasActivePointerInteraction: () => boolean;
+    pointerCommitNonce: number;
+    setSlides: (slides: l[]) => void;
+    setCanvasSize: (size: CanvasSize) => void;
+    setActiveSlideIndex: (index: number) => void;
+    setTemplateElementsBySlideId: (map: Record<string, P[]>) => void;
+    setSelectedElementId: (id: string | null) => void;
+    setSelectedElementIds: (ids: string[]) => void;
+    setEditTemplateMode: (mode: boolean) => void;
+    setHeaderFooter: (hf: r) => void;
+}
+interface EditorHistoryResult {
+    canUndo: boolean;
+    canRedo: boolean;
+    undoLabel: string | undefined;
+    redoLabel: string | undefined;
+    handleUndo: () => void;
+    handleRedo: () => void;
+    resetHistory: () => void;
+    markDirty: () => void;
+    buildHistorySnapshot: (actionLabel?: string) => EditorHistorySnapshot;
+}
+declare function useEditorHistory(input: EditorHistoryInput): EditorHistoryResult;
+
+/** Axis-aligned bounding box used by zoom / viewport helpers. */
+interface SelectionBounds {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+interface UseZoomViewportInput {
+    canvasSize: CanvasSize;
+    selectedElements: P[];
+}
+interface UseZoomViewportResult {
+    editWrapperRef: React.RefObject<HTMLDivElement | null>;
+    canvasStageRef: React.RefObject<HTMLDivElement | null>;
+    canvasViewportRef: React.RefObject<HTMLDivElement | null>;
+    renderScaleRef: React.MutableRefObject<number>;
+    scale: number;
+    setScale: (scale: number) => void;
+    editorDimensions: CanvasSize | null;
+    setEditorDimensions: (dims: CanvasSize | null) => void;
+    fitScale: number;
+    editorScale: number;
+    handleZoomIn: () => void;
+    handleZoomOut: () => void;
+    handleResetZoom: () => void;
+    handleZoomToFit: () => void;
+    handleZoomToSelection: () => void;
+    handleWheel: (e: WheelEvent) => void;
+    centerBoundsInViewport: (bounds: SelectionBounds, nextScale: number) => void;
+    getCanvasPointFromClient: (clientX: number, clientY: number) => {
+        x: number;
+        y: number;
+    } | null;
+}
+declare function useZoomViewport({ canvasSize, selectedElements, }: UseZoomViewportInput): UseZoomViewportResult;
+
+/**
+ * State describing the transition overlay that plays while advancing into a
+ * slide that carries a `p:transition`. The outgoing slide is snapshotted into
+ * an animated overlay layer while the incoming slide renders underneath on the
+ * main stage; the overlay tears down once `durationMs` elapses.
+ */
+interface PresentationTransitionOverlayState {
+    /** Index of the leaving slide, rendered (animated) in the overlay layer. */
+    outgoingSlideIndex: number;
+    /** Index of the arriving slide, already live on the main stage. */
+    incomingSlideIndex: number;
+    /** The incoming slide's transition definition (drives the CSS animation). */
+    transition: R;
+    /** Resolved transition duration (ms). */
+    durationMs: number;
+}
+interface UsePresentationModeInput {
+    mode: ViewerMode;
+    slides: l[];
+    visibleSlideIndexes: number[];
+    activeSlideIndex: number;
+    containerRef: React.RefObject<HTMLElement | null>;
+    /** Raw PPTX bytes: forwarded to audience window for content sharing. */
+    content?: ArrayBuffer | Uint8Array | null;
+    onSetMode: (mode: ViewerMode) => void;
+    onSetActiveSlideIndex: (index: number) => void;
+    onPlayActionSound?: (soundPath: string) => void;
+    /** Called when L key is pressed during presentation. */
+    onToggleLaser?: () => void;
+    /** Called when P key is pressed during presentation. */
+    onTogglePen?: () => void;
+    /** Called when E key is pressed during presentation. */
+    onToggleEraser?: () => void;
+    /** Called when Ctrl+M is pressed during presentation. */
+    onToggleToolbar?: () => void;
+    /** Called to persist rehearsal timings into slide transitions. */
+    onSaveRehearsalTimings?: (timings: Record<number, number>) => void;
+    /** Whether to loop continuously (kiosk or explicit loop setting). */
+    loopContinuously?: boolean;
+    /** Whether to play animations during the slide show (false = skip all animations). */
+    showWithAnimation?: boolean;
+    /** Whether to use rehearsed auto-advance timings (false = manual advance only). */
+    useTimings?: boolean;
+}
+interface UsePresentationModeResult {
+    presentationSlideIndex: number;
+    setPresentationSlideIndex: (index: number) => void;
+    presentationSlideVisible: boolean;
+    /** Active slide-transition overlay, or `null` when no transition is playing. */
+    transitionOverlay: PresentationTransitionOverlayState | null;
+    /** Tear down the transition overlay once its animation completes. */
+    handleTransitionOverlayComplete: () => void;
+    presentationAnimations: PresentationAnimationRuntime[];
+    presentationElementStates: Map<string, ElementAnimationState>;
+    presentationKeyframesCss: string;
+    clearPresentationTimers: () => void;
+    runPresentationEntranceAnimations: (slideIndex: number) => void;
+    movePresentationSlide: (direction: 1 | -1) => void;
+    navigateToSlide: (slideIndex: number) => void;
+    handlePresentationAction: (action: a2) => void;
+    /**
+     * Handle a shape click in presentation mode. If the shape is an interactive
+     * trigger, play its animation sequence. Returns `true` if handled.
+     */
+    handleInteractiveShapeClick: (shapeId: string) => boolean;
+    /** Set of shape IDs that are interactive sequence triggers on the current slide. */
+    interactiveTriggerShapeIds: ReadonlySet<string>;
+    /** Set of shape IDs that are hover animation triggers on the current slide. */
+    hoverTriggerShapeIds: ReadonlySet<string>;
+    /** Handle hover start on a shape. If the shape has a hover sequence, play it. Returns `true` if handled. */
+    handleHoverStart: (shapeId: string) => boolean;
+    /** Handle hover end on a shape. Resets the hover sequence for replay. */
+    handleHoverEnd: (shapeId: string) => void;
+    /** Must be called from a user-gesture handler (click) to satisfy browser fullscreen policy. */
+    enterPresentMode: () => void;
+    /** Whether presenter view (split-screen with notes) is active instead of fullscreen. */
+    presenterMode: boolean;
+    /** Enter presenter view mode (no fullscreen, shows notes panel). */
+    enterPresenterView: () => void;
+    /** Toggle between fullscreen and presenter view during presentation. */
+    togglePresenterView: () => void;
+    /** Timestamp (ms) when the presentation started: used for elapsed timer. */
+    presentationStartTime: number | null;
+    /** Whether the current presentation session is in rehearse-timings mode. */
+    rehearsing: boolean;
+    /** Enter rehearse-timings mode (fullscreen presentation + timing HUD). */
+    enterRehearsalMode: () => void;
+    /** Recorded timings in ms, keyed by slide index. Populated during rehearsal. */
+    recordedTimings: Record<number, number>;
+    /** Timestamp when the current slide started (ms since epoch). */
+    slideStartTime: number | null;
+    /** Whether the rehearsal summary dialog should be shown. */
+    showRehearsalSummary: boolean;
+    /** Dismiss the rehearsal summary (discard timings). */
+    dismissRehearsalSummary: () => void;
+    /** Save recorded timings into each slide's transition.advanceAfterMs. */
+    saveRehearsalTimings: () => void;
+    /** Whether rehearsal timer is paused. */
+    rehearsalPaused: boolean;
+    /** Toggle the rehearsal timer pause state. */
+    toggleRehearsalPause: () => void;
+    /** Handle a zoom element click in presentation mode. */
+    handleZoomClick: (targetSlideIndex: number, returnSlideIndex: number) => void;
+    /** Ref holding the slide index to return to after zoom navigation. */
+    zoomReturnSlideIndex: React.RefObject<number | null>;
+    /** Navigate back to the zoom summary slide. Returns true if navigation occurred. */
+    returnToZoomSlide: () => boolean;
+    /** Clear the stored zoom return index. */
+    clearZoomReturn: () => void;
+    /** Open the audience display in a separate browser window. Returns `true` if successful. */
+    openAudienceWindow: () => boolean;
+    /** Close the audience display window. */
+    closeAudienceWindow: () => void;
+    /** Whether the audience window is currently open. */
+    isAudienceWindowOpen: () => boolean;
+    /** Send a slide index to the audience window explicitly. */
+    syncSlideToAudience: (slideIndex: number) => void;
+}
+
+declare function usePresentationMode(input: UsePresentationModeInput): UsePresentationModeResult;
+
+/**
+ * Types for presentation annotation state.
+ */
+type PresentationTool = 'none' | 'laser' | 'pen' | 'highlighter' | 'eraser';
+interface AnnotationStroke {
+    id: string;
+    points: Array<{
+        x: number;
+        y: number;
+    }>;
+    color: string;
+    width: number;
+    opacity: number;
+}
+interface LaserPosition {
+    x: number;
+    y: number;
+}
+/** Annotations grouped by slide index. */
+type SlideAnnotationMap = Map<number, AnnotationStroke[]>;
+interface UsePresentationAnnotationsInput {
+    isActive: boolean;
+    /** Current slide index: used to track which slide annotations belong to. */
+    activeSlideIndex: number;
+}
+interface UsePresentationAnnotationsResult {
+    presentationTool: PresentationTool;
+    setPresentationTool: (tool: PresentationTool) => void;
+    penColor: string;
+    setPenColor: (color: string) => void;
+    highlighterColor: string;
+    setHighlighterColor: (color: string) => void;
+    annotationStrokes: AnnotationStroke[];
+    currentStroke: AnnotationStroke | null;
+    laserPosition: LaserPosition | null;
+    toolbarVisible: boolean;
+    setToolbarVisible: (visible: boolean) => void;
+    handlePointerDown: (x: number, y: number) => void;
+    handlePointerMove: (x: number, y: number) => void;
+    handlePointerUp: () => void;
+    handleLaserMove: (x: number, y: number) => void;
+    handleLaserLeave: () => void;
+    clearAnnotations: () => void;
+    eraseAtPoint: (x: number, y: number) => void;
+    /** All annotations across all slides (for persistence on exit). */
+    allSlideAnnotations: SlideAnnotationMap;
+    /** Whether any annotations exist across all slides. */
+    hasAnyAnnotations: boolean;
+    /** Clear all annotations across all slides. */
+    clearAllAnnotations: () => void;
+}
+
+declare function usePresentationAnnotations(input: UsePresentationAnnotationsInput): UsePresentationAnnotationsResult;
+
+interface FindResult {
+    slideIndex: number;
+    elementId: string;
+    segmentIndex: number;
+    startOffset: number;
+    length: number;
+}
+interface UseFindReplaceInput {
+    slides: l[];
+    mode: string;
+    onSetActiveSlideIndex: (index: number) => void;
+    onSetSelectedElementId: (id: string | null) => void;
+    onUpdateSlides: (updater: (slides: l[]) => l[]) => void;
+    onMarkDirty: () => void;
+}
+interface UseFindReplaceResult {
+    findReplaceOpen: boolean;
+    setFindReplaceOpen: (open: boolean) => void;
+    findQuery: string;
+    setFindQuery: (query: string) => void;
+    replaceQuery: string;
+    setReplaceQuery: (query: string) => void;
+    findMatchCase: boolean;
+    setFindMatchCase: (matchCase: boolean) => void;
+    findResults: FindResult[];
+    findResultIndex: number;
+    performFind: () => void;
+    navigateFindResult: (direction: 1 | -1) => void;
+    handleReplace: () => void;
+    handleReplaceAll: () => void;
+}
+declare function useFindReplace({ slides, mode, onSetActiveSlideIndex, onSetSelectedElementId, onUpdateSlides, onMarkDirty, }: UseFindReplaceInput): UseFindReplaceResult;
+
+interface SheetDismissDragHandlers {
+    onPointerDown: (e: React__default.PointerEvent) => void;
+    onPointerMove: (e: React__default.PointerEvent) => void;
+    onPointerUp: (e: React__default.PointerEvent) => void;
+    onPointerCancel: (e: React__default.PointerEvent) => void;
+}
+interface SheetDismissDrag {
+    /** Current downward drag offset in px (0 when not dragging). */
+    dragY: number;
+    /** True while a pointer drag is in progress. */
+    dragging: boolean;
+    /** Spread onto the drag handle / header to make a bottom sheet swipe-dismissable. */
+    handlers: SheetDismissDragHandlers;
+}
+/**
+ * Shared drag-to-dismiss logic for mobile bottom sheets. Dragging the grab
+ * region down past `threshold` px invokes `onClose`; anything less snaps back.
+ *
+ * Centralising this keeps every sheet (menu, slides, inspector/format,
+ * comments) consistent: previously only the `MobileSheet`-based sheets could
+ * be swiped closed while the inspector's handle was purely decorative.
+ */
+declare function useSheetDismissDrag(onClose: () => void, threshold?: number): SheetDismissDrag;
+
+interface ModalDismissDragHandlers {
+    onPointerDown: (e: React__default.PointerEvent) => void;
+    onPointerMove: (e: React__default.PointerEvent) => void;
+    onPointerUp: (e: React__default.PointerEvent) => void;
+    onPointerCancel: (e: React__default.PointerEvent) => void;
+}
+interface ModalDismissDrag {
+    /** Spread onto the panel element to follow the drag and snap back. */
+    panelStyle: React__default.CSSProperties | undefined;
+    /** Spread onto the header / title bar to make the dialog swipe-dismissable. */
+    handlers: ModalDismissDragHandlers;
+}
+/**
+ * Swipe-down-to-dismiss for centered modal dialogs. Mirrors the bottom-sheet
+ * gesture but tuned for dialogs:
+ *  - touch/pen only — a desktop mouse never starts a drag, so click/select on
+ *    the header is unaffected;
+ *  - drags that begin on an interactive control (the × close button, inputs,
+ *    links) are ignored so those keep working;
+ *  - dragging the header down past `threshold` px invokes `onClose`.
+ */
+declare function useModalDismissDrag(onClose: () => void, threshold?: number): ModalDismissDrag;
+
+interface UseCommentsInput {
+    slides: l[];
+    activeSlideIndex: number;
+    canEdit: boolean;
+    userName?: string;
+    selectedElementId?: string | null;
+    onUpdateSlides: (updater: (slides: l[]) => l[]) => void;
+    onMarkDirty: () => void;
+}
+interface UseCommentsResult {
+    commentDraftBySlideId: Record<string, string>;
+    editingCommentIdBySlideId: Record<string, string | null>;
+    commentEditDraftByCommentId: Record<string, string>;
+    replyingToCommentId: string | null;
+    replyDraftByCommentId: Record<string, string>;
+    handleCommentDraftChange: (slideId: string, draft: string) => void;
+    handleAddSlideComment: (slideIndex: number) => void;
+    handleDeleteSlideComment: (slideIndex: number, commentId: string) => void;
+    handleStartCommentEdit: (slideId: string, commentId: string) => void;
+    handleCancelCommentEdit: (slideId: string) => void;
+    handleSaveCommentEdit: (slideIndex: number, commentId: string) => void;
+    handleSetCommentEditDraft: (commentId: string, draft: string) => void;
+    handleToggleCommentResolved: (slideIndex: number, commentId: string) => void;
+    handleStartReply: (slideIndex: number, commentId: string) => void;
+    handleCancelReply: () => void;
+    handleReplyDraftChange: (commentId: string, draft: string) => void;
+    handleSubmitReply: (slideIndex: number, commentId: string) => void;
+}
+
+declare function useComments({ slides, canEdit, userName, selectedElementId, onUpdateSlides, onMarkDirty, }: UseCommentsInput): UseCommentsResult;
+
+/**
+ * Input parameters for the {@link useViewerCoreState} hook.
+ *
+ * @property content - Raw binary content of the PPTX file to load. `null`/`undefined` when no file is loaded yet.
+ * @property canEdit - Whether the viewer allows editing operations (false for read-only mode).
+ */
+interface UseViewerCoreStateInput {
+    content: ArrayBuffer | Uint8Array | null | undefined;
+    canEdit: boolean;
+}
+/**
+ * The full output shape of {@link useViewerCoreState}.
+ *
+ * This interface exposes every ref, state value, setter, and derived field
+ * that comprises the core viewer state. It is merged with {@link ViewerUIState}
+ * inside {@link useViewerState} to produce the unified {@link ViewerState}.
+ */
+interface ViewerCoreState {
+    /** Ref to the outermost container `<div>` wrapping the viewer. */
+    containerRef: React__default.RefObject<HTMLDivElement | null>;
+    /** Hidden `<input type="file">` used to trigger image file selection. */
+    imageInputRef: React__default.RefObject<HTMLInputElement | null>;
+    /** Hidden `<input type="file">` used to trigger audio/video file selection. */
+    mediaInputRef: React__default.RefObject<HTMLInputElement | null>;
+    /** Mutable ref mirroring `activeSlideIndex` for use in event handlers that must not re-subscribe on index change. */
+    activeSlideIndexRef: React__default.MutableRefObject<number>;
+    /** Mutable ref mirroring `inlineEditingElementId`: always current without waiting for a re-render. */
+    inlineEditingElementIdRef: React__default.MutableRefObject<string | null>;
+    /** Mutable ref mirroring `inlineEditingText`: always current without waiting for a re-render. */
+    inlineEditingTextRef: React__default.MutableRefObject<string>;
+    /** Tracks the in-progress drag operation (move) for element(s). */
+    dragStateRef: React__default.MutableRefObject<DragState | null>;
+    /** Tracks the in-progress resize operation for an element. */
+    resizeStateRef: React__default.MutableRefObject<ResizeState | null>;
+    /** Tracks the in-progress shape adjustment handle drag. */
+    shapeAdjustmentDragStateRef: React__default.MutableRefObject<ShapeAdjustmentDragState | null>;
+    /** Tracks the in-progress marquee (lasso) selection rectangle. */
+    marqueeStateRef: React__default.MutableRefObject<MarqueeSelectionState | null>;
+    /** Whether the user is currently performing a freeform drawing stroke. */
+    isDrawingRef: React__default.MutableRefObject<boolean>;
+    /** Current viewer mode (edit, view, present, master, etc.). */
+    mode: ViewerMode;
+    setMode: React__default.Dispatch<React__default.SetStateAction<ViewerMode>>;
+    /** Whether the presentation content is currently being loaded/parsed. */
+    loading: boolean;
+    setLoading: React__default.Dispatch<React__default.SetStateAction<boolean>>;
+    /** Non-null when an error occurred during loading or processing. */
+    error: string | null;
+    setError: React__default.Dispatch<React__default.SetStateAction<string | null>>;
+    /** The ordered array of all slides in the presentation. */
+    slides: l[];
+    setSlides: React__default.Dispatch<React__default.SetStateAction<l[]>>;
+    /** Layout/master placeholder elements keyed by slide id, used for template rendering. */
+    templateElementsBySlideId: Record<string, P[]>;
+    setTemplateElementsBySlideId: React__default.Dispatch<React__default.SetStateAction<Record<string, P[]>>>;
+    /** Width and height of the slide canvas in CSS pixels. */
+    canvasSize: CanvasSize;
+    setCanvasSize: React__default.Dispatch<React__default.SetStateAction<CanvasSize>>;
+    /** Zero-based index of the currently active (visible) slide. */
+    activeSlideIndex: number;
+    setActiveSlideIndex: React__default.Dispatch<React__default.SetStateAction<number>>;
+    /** ID of the single primarily-selected element (null when nothing is selected). */
+    selectedElementId: string | null;
+    setSelectedElementId: React__default.Dispatch<React__default.SetStateAction<string | null>>;
+    /** IDs for multi-selection (non-empty when multiple elements are selected). */
+    selectedElementIds: string[];
+    setSelectedElementIds: React__default.Dispatch<React__default.SetStateAction<string[]>>;
+    /** Whether unsaved changes exist in the presentation. */
+    isDirty: boolean;
+    setIsDirty: React__default.Dispatch<React__default.SetStateAction<boolean>>;
+    /** ID of the element whose text is currently being edited inline on the canvas. */
+    inlineEditingElementId: string | null;
+    setInlineEditingElementId: React__default.Dispatch<React__default.SetStateAction<string | null>>;
+    /** The current inline-editing text content (mirrored from the editor). */
+    inlineEditingText: string;
+    setInlineEditingText: React__default.Dispatch<React__default.SetStateAction<string>>;
+    /** Whether the user is editing template/layout elements rather than slide elements. */
+    editTemplateMode: boolean;
+    setEditTemplateMode: React__default.Dispatch<React__default.SetStateAction<boolean>>;
+    /** The shape type to use when the user draws the next new shape. */
+    newShapeType: SupportedShapeType;
+    setNewShapeType: React__default.Dispatch<React__default.SetStateAction<SupportedShapeType>>;
+    /** In-memory clipboard payload for internal copy/paste of elements. */
+    clipboardPayload: ElementClipboardPayload | null;
+    setClipboardPayload: React__default.Dispatch<React__default.SetStateAction<ElementClipboardPayload | null>>;
+    /** Monotonically-increasing nonce bumped after each pointer commit to trigger re-renders. */
+    pointerCommitNonce: number;
+    setPointerCommitNonce: React__default.Dispatch<React__default.SetStateAction<number>>;
+    /** Header/footer configuration for the presentation. */
+    headerFooter: r;
+    setHeaderFooter: React__default.Dispatch<React__default.SetStateAction<r>>;
+    /** Available slide layout options (path + display name). */
+    layoutOptions: Array<{
+        path: string;
+        name: string;
+    }>;
+    setLayoutOptions: React__default.Dispatch<React__default.SetStateAction<Array<{
+        path: string;
+        name: string;
+    }>>>;
+    /** All slide masters parsed from the presentation. */
+    slideMasters: A[];
+    setSlideMasters: React__default.Dispatch<React__default.SetStateAction<A[]>>;
+    /** The currently active theme applied to the presentation. */
+    theme: ap | undefined;
+    setTheme: React__default.Dispatch<React__default.SetStateAction<ap | undefined>>;
+    /** Parsed table style definitions from `ppt/tableStyles.xml`. */
+    tableStyleMap: J | undefined;
+    setTableStyleMap: React__default.Dispatch<React__default.SetStateAction<J | undefined>>;
+    /** Available theme presets the user can switch between. */
+    themeOptions: aq[];
+    setThemeOptions: React__default.Dispatch<React__default.SetStateAction<aq[]>>;
+    /** Custom slide shows defined in the presentation. */
+    customShows: t[];
+    setCustomShows: React__default.Dispatch<React__default.SetStateAction<t[]>>;
+    /** ID of the currently active custom show, or null for normal show. */
+    activeCustomShowId: string | null;
+    setActiveCustomShowId: React__default.Dispatch<React__default.SetStateAction<string | null>>;
+    /** Slide sections for organizational grouping. */
+    sections: u[];
+    setSections: React__default.Dispatch<React__default.SetStateAction<u[]>>;
+    /** Presentation-level properties (loop, show type, subtitles, etc.). */
+    presentationProperties: s;
+    setPresentationProperties: React__default.Dispatch<React__default.SetStateAction<s>>;
+    /** Notes master slide definition (background, elements, styles). */
+    notesMaster: y | undefined;
+    setNotesMaster: React__default.Dispatch<React__default.SetStateAction<y | undefined>>;
+    /** Handout master definition for print handout layouts. */
+    handoutMaster: z | undefined;
+    setHandoutMaster: React__default.Dispatch<React__default.SetStateAction<z | undefined>>;
+    /** Canvas dimensions for the notes page view (may differ from slide canvas). */
+    notesCanvasSize: CanvasSize | undefined;
+    setNotesCanvasSize: React__default.Dispatch<React__default.SetStateAction<CanvasSize | undefined>>;
+    /** User-defined custom document properties. */
+    customProperties: x[];
+    setCustomProperties: React__default.Dispatch<React__default.SetStateAction<x[]>>;
+    /** Tag collections associated with slides or elements. */
+    tagCollections: D[];
+    setTagCollections: React__default.Dispatch<React__default.SetStateAction<D[]>>;
+    /** OPC core properties (title, author, created date, etc.). */
+    coreProperties: v | undefined;
+    setCoreProperties: React__default.Dispatch<React__default.SetStateAction<v | undefined>>;
+    /** Application-level properties (company, version, etc.). */
+    appProperties: w | undefined;
+    setAppProperties: React__default.Dispatch<React__default.SetStateAction<w | undefined>>;
+    /** Fonts embedded within the PPTX file. */
+    embeddedFonts: K[];
+    setEmbeddedFonts: React__default.Dispatch<React__default.SetStateAction<K[]>>;
+    /** Whether the loaded presentation contains VBA macros. */
+    hasMacros: boolean;
+    setHasMacros: React__default.Dispatch<React__default.SetStateAction<boolean>>;
+    /** Whether the loaded presentation contains digital signatures. */
+    hasDigitalSignatures: boolean;
+    setHasDigitalSignatures: React__default.Dispatch<React__default.SetStateAction<boolean>>;
+    /** Number of digital signatures detected. */
+    digitalSignatureCount: number;
+    setDigitalSignatureCount: React__default.Dispatch<React__default.SetStateAction<number>>;
+    /** Zero-based index of the selected slide master in master view. */
+    activeMasterIndex: number;
+    setActiveMasterIndex: React__default.Dispatch<React__default.SetStateAction<number>>;
+    /** Index of the selected layout within the active master, or null when viewing the master itself. */
+    activeLayoutIndex: number | null;
+    setActiveLayoutIndex: React__default.Dispatch<React__default.SetStateAction<number | null>>;
+    /** The mode the viewer was in before entering master view (to restore on close). */
+    preMasterMode: ViewerMode;
+    setPreMasterMode: React__default.Dispatch<React__default.SetStateAction<ViewerMode>>;
+    /** Active tab within the master view: slides (default), notes, or handout. */
+    masterViewTab: bk;
+    setMasterViewTab: React__default.Dispatch<React__default.SetStateAction<bk>>;
+    /** Handout slides-per-page setting (1, 2, 3, 4, 6, or 9). */
+    handoutSlidesPerPage: number;
+    setHandoutSlidesPerPage: React__default.Dispatch<React__default.SetStateAction<number>>;
+    /** The slide object at `activeSlideIndex`, or undefined if out of bounds. */
+    activeSlide: l | undefined;
+    /** Template (layout/master placeholder) elements for the active slide. */
+    templateElements: P[];
+    /** Fast id-to-element lookup map covering both slide and template elements. */
+    elementLookup: Map<string, P>;
+    /** The single primarily-selected element, resolved from `selectedElementId`. */
+    selectedElement: P | null;
+    /** Union of `selectedElementIds` and `selectedElementId`: the canonical list of selected ids. */
+    effectiveSelectedIds: string[];
+    /** Set form of `effectiveSelectedIds` for O(1) membership checks. */
+    selectedElementIdSet: Set<string>;
+    /** Resolved element objects for all selected ids. */
+    selectedElements: P[];
+    /** The currently active master in master view. */
+    activeMaster: A | undefined;
+    /** The currently active layout in master view. */
+    activeLayout: B | undefined;
+    /** Elements for the currently active master or layout in master view. */
+    masterViewElements: P[];
+    /** Elements for the notes master (when notes tab is active). */
+    notesMasterElements: P[];
+    /** Elements for the handout master (when handout tab is active). */
+    handoutMasterElements: P[];
+}
+
+/**
+ * Initializes and returns the core viewer state (refs, useState values,
+ * and derived element/master state).
+ *
+ * @param _input - Content and edit-mode flag (used by upstream wiring; the
+ *   hook itself does not consume them directly; they flow through
+ *   useContentLifecycle).
+ * @returns A {@link ViewerCoreState} object containing every ref, state
+ *   value, setter, and derived field.
+ */
+declare function useViewerCoreState(_input: UseViewerCoreStateInput): ViewerCoreState;
+
+interface ViewerUIState {
+    isCompactToolbarOpen: boolean;
+    setIsCompactToolbarOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    toolbarSection: ToolbarSection;
+    setToolbarSection: React.Dispatch<React.SetStateAction<ToolbarSection>>;
+    isSlidesPaneOpen: boolean;
+    setIsSlidesPaneOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    isInspectorPaneOpen: boolean;
+    setIsInspectorPaneOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    isSlideNotesCollapsed: boolean;
+    setIsSlideNotesCollapsed: React.Dispatch<React.SetStateAction<boolean>>;
+    isOverflowMenuOpen: boolean;
+    setIsOverflowMenuOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    isSidebarCollapsed: boolean;
+    setIsSidebarCollapsed: React.Dispatch<React.SetStateAction<boolean>>;
+    sidebarPanelMode: string;
+    setSidebarPanelMode: React.Dispatch<React.SetStateAction<string>>;
+    showSlideSorter: boolean;
+    setShowSlideSorter: React.Dispatch<React.SetStateAction<boolean>>;
+    isShortcutHelpOpen: boolean;
+    setIsShortcutHelpOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    isAccessibilityPanelOpen: boolean;
+    setIsAccessibilityPanelOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    accessibilityIssues: AccessibilityIssue[];
+    setAccessibilityIssues: React.Dispatch<React.SetStateAction<AccessibilityIssue[]>>;
+    contextMenuState: ElementContextMenuState | null;
+    setContextMenuState: React.Dispatch<React.SetStateAction<ElementContextMenuState | null>>;
+    tableEditorState: TableCellEditorState | null;
+    setTableEditorState: React.Dispatch<React.SetStateAction<TableCellEditorState | null>>;
+    spellCheckEnabled: boolean;
+    setSpellCheckEnabled: React.Dispatch<React.SetStateAction<boolean>>;
+    showGrid: boolean;
+    setShowGrid: React.Dispatch<React.SetStateAction<boolean>>;
+    showRulers: boolean;
+    setShowRulers: React.Dispatch<React.SetStateAction<boolean>>;
+    snapToGrid: boolean;
+    setSnapToGrid: React.Dispatch<React.SetStateAction<boolean>>;
+    snapToShape: boolean;
+    setSnapToShape: React.Dispatch<React.SetStateAction<boolean>>;
+    guides: Array<{
+        id: string;
+        axis: 'h' | 'v';
+        position: number;
+    }>;
+    setGuides: React.Dispatch<React.SetStateAction<Array<{
+        id: string;
+        axis: 'h' | 'v';
+        position: number;
+    }>>>;
+    marqueeSelectionState: MarqueeSelectionState | null;
+    setMarqueeSelectionState: React.Dispatch<React.SetStateAction<MarqueeSelectionState | null>>;
+    snapLines: Array<{
+        axis: string;
+        position: number;
+    }>;
+    setSnapLines: React.Dispatch<React.SetStateAction<Array<{
+        axis: string;
+        position: number;
+    }>>>;
+    mediaDataUrls: Map<string, string>;
+    setMediaDataUrls: React.Dispatch<React.SetStateAction<Map<string, string>>>;
+    activeTool: DrawingTool;
+    setActiveTool: React.Dispatch<React.SetStateAction<DrawingTool>>;
+    drawingColor: string;
+    setDrawingColor: React.Dispatch<React.SetStateAction<string>>;
+    drawingWidth: number;
+    setDrawingWidth: React.Dispatch<React.SetStateAction<number>>;
+    isThemeEditorOpen: boolean;
+    setIsThemeEditorOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    isThemeGalleryOpen: boolean;
+    setIsThemeGalleryOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    formatPainterActive: boolean;
+    setFormatPainterActive: React.Dispatch<React.SetStateAction<boolean>>;
+    isSelectionPaneOpen: boolean;
+    setIsSelectionPaneOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    eyedropperActive: boolean;
+    setEyedropperActive: React.Dispatch<React.SetStateAction<boolean>>;
+}
+declare function useViewerUIState(): ViewerUIState;
+
+/**
+ * Input parameters for the {@link useViewerState} hook.
+ *
+ * @property content - Raw PPTX binary data, or null/undefined when no file is loaded.
+ * @property canEdit - Whether the viewer should enable editing capabilities.
+ */
+interface UseViewerStateInput {
+    content: ArrayBuffer | Uint8Array | null | undefined;
+    canEdit: boolean;
+}
+/**
+ * The unified viewer state: intersection of core state (slides, elements,
+ * refs, presentation metadata) and UI state (panel toggles, tools, grid/snap).
+ */
+type ViewerState = ViewerCoreState & ViewerUIState;
+/**
+ * Composes core and UI state into a single unified state object.
+ *
+ * This hook is the entry point consumed by the main PowerPointViewer component.
+ * It merges the results of two sub-hooks into one spread so downstream hooks
+ * can accept a single `ViewerState` parameter.
+ *
+ * @param input - The binary content and edit-mode flag.
+ * @returns The merged {@link ViewerState} containing every ref, state value, and setter.
+ */
+declare function useViewerState(input: UseViewerStateInput): ViewerState;
+
+interface UseLoadContentInput {
+    content: ArrayBuffer | Uint8Array | null | undefined;
+    clearSelection: () => void;
+    history: EditorHistoryResult;
+    setSlides: React.Dispatch<React.SetStateAction<l[]>>;
+    setTemplateElementsBySlideId: React.Dispatch<React.SetStateAction<Record<string, P[]>>>;
+    mediaDataUrls: Map<string, string>;
+    setCanvasSize: React.Dispatch<React.SetStateAction<CanvasSize>>;
+    setHeaderFooter: React.Dispatch<React.SetStateAction<r>>;
+    setLayoutOptions: React.Dispatch<React.SetStateAction<Array<{
+        path: string;
+        name: string;
+    }>>>;
+    setSlideMasters: React.Dispatch<React.SetStateAction<A[]>>;
+    setTheme: React.Dispatch<React.SetStateAction<ap | undefined>>;
+    setTableStyleMap: React.Dispatch<React.SetStateAction<J | undefined>>;
+    setThemeOptions: React.Dispatch<React.SetStateAction<aq[]>>;
+    setCustomShows: React.Dispatch<React.SetStateAction<t[]>>;
+    setSections: React.Dispatch<React.SetStateAction<u[]>>;
+    setPresentationProperties: React.Dispatch<React.SetStateAction<s>>;
+    setNotesMaster: React.Dispatch<React.SetStateAction<y | undefined>>;
+    setHandoutMaster: React.Dispatch<React.SetStateAction<z | undefined>>;
+    setNotesCanvasSize: React.Dispatch<React.SetStateAction<CanvasSize | undefined>>;
+    setCustomProperties: React.Dispatch<React.SetStateAction<x[]>>;
+    setTagCollections: React.Dispatch<React.SetStateAction<D[]>>;
+    setCoreProperties: React.Dispatch<React.SetStateAction<v | undefined>>;
+    setAppProperties: React.Dispatch<React.SetStateAction<w | undefined>>;
+    setEmbeddedFonts: React.Dispatch<React.SetStateAction<K[]>>;
+    setActiveSlideIndex: React.Dispatch<React.SetStateAction<number>>;
+    setHasMacros: React.Dispatch<React.SetStateAction<boolean>>;
+    setHasDigitalSignatures: React.Dispatch<React.SetStateAction<boolean>>;
+    setDigitalSignatureCount: React.Dispatch<React.SetStateAction<number>>;
+    setGuides: React.Dispatch<React.SetStateAction<Array<{
+        id: string;
+        axis: 'h' | 'v';
+        position: number;
+    }>>>;
+    setLoading: React.Dispatch<React.SetStateAction<boolean>>;
+    setError: React.Dispatch<React.SetStateAction<string | null>>;
+    setIsDirty: React.Dispatch<React.SetStateAction<boolean>>;
+    setIsEncrypted: React.Dispatch<React.SetStateAction<boolean>>;
+}
+interface UseLoadContentResult {
+    handlerRef: React.MutableRefObject<PptxHandler | null>;
+}
+declare function useLoadContent({ content, clearSelection, history, setSlides, setTemplateElementsBySlideId, mediaDataUrls, setCanvasSize, setHeaderFooter, setLayoutOptions, setSlideMasters, setTheme, setTableStyleMap, setThemeOptions, setCustomShows, setSections, setPresentationProperties, setNotesMaster, setHandoutMaster, setNotesCanvasSize, setCustomProperties, setTagCollections, setCoreProperties, setAppProperties, setEmbeddedFonts, setActiveSlideIndex, setHasMacros, setHasDigitalSignatures, setDigitalSignatureCount, setGuides, setLoading, setError, setIsDirty, setIsEncrypted, }: UseLoadContentInput): UseLoadContentResult;
+
+type AutosaveStatus = {
+    state: 'idle';
+} | {
+    state: 'disabled';
+    reason: string;
+} | {
+    state: 'saving';
+} | {
+    state: 'saved';
+    timestamp: number;
+} | {
+    state: 'error';
+    message: string;
+};
+interface UseAutosaveInput {
+    /** Whether the document has unsaved changes. */
+    isDirty: boolean;
+    /** File path or name of the currently-open PPTX. Required for autosave to work. */
+    filePath: string | undefined;
+    /** Serialise current editor state to a Uint8Array. */
+    serializeSlides: () => Promise<Uint8Array | null>;
+    /** Autosave interval in seconds (default 120). */
+    intervalSeconds?: number;
+    /** Whether autosave is enabled. */
+    enabled?: boolean;
+}
+interface UseAutosaveResult {
+    /** Current autosave status for display in the StatusBar. */
+    autosaveStatus: AutosaveStatus;
+    /** Manually trigger an autosave right now. */
+    triggerAutosave: () => Promise<void>;
+}
+declare function useAutosave(input: UseAutosaveInput): UseAutosaveResult;
+
+interface UseElementOperationsInput {
+    slides: l[];
+    activeSlide: l | undefined;
+    activeSlideIndex: number;
+    selectedElement: P | null;
+    selectedElementId: string | null;
+    /** When true, element operations target the template store, not slide.elements. */
+    editTemplateMode: boolean;
+    /** Template (master/layout) elements for the active slide. */
+    templateElements: P[];
+    history: EditorHistoryResult;
+    setSlides: React.Dispatch<React.SetStateAction<l[]>>;
+    setTemplateElementsBySlideId: React.Dispatch<React.SetStateAction<Record<string, P[]>>>;
+    setSelectedElementId: React.Dispatch<React.SetStateAction<string | null>>;
+    setSelectedElementIds: React.Dispatch<React.SetStateAction<string[]>>;
+    setInlineEditingElementId: React.Dispatch<React.SetStateAction<string | null>>;
+    setContextMenuState: React.Dispatch<React.SetStateAction<ElementContextMenuState | null>>;
+}
+interface ElementOperations {
+    applySelection: (primaryId: string | null, ids?: string[]) => void;
+    clearSelection: () => void;
+    updateElementById: (elementId: string, updates: Partial<P>) => void;
+    updateSelectedElement: (updates: Partial<P>) => void;
+    updateSelectedShapeStyle: (updates: Partial<$>) => void;
+    updateSelectedTextStyle: (updates: Partial<a0>) => void;
+    updateSlides: (updater: (s: l[]) => l[]) => void;
+    /**
+     * The element list currently being edited: the template store for the active
+     * slide while edit-template mode is on, otherwise the active slide's elements.
+     */
+    activeElements: P[];
+    /**
+     * Replace the active element list (template store or slide.elements depending
+     * on edit-template mode). Does not mark the document dirty; callers do.
+     */
+    updateActiveElements: (updater: (els: P[]) => P[]) => void;
+    serializeSlides: () => Promise<Uint8Array | null>;
+}
+declare function useElementOperations(input: UseElementOperationsInput): ElementOperations;
+
+interface UseSectionOperationsInput {
+    sections: u[];
+    setSections: React.Dispatch<React.SetStateAction<u[]>>;
+    slides: l[];
+    setSlides: React.Dispatch<React.SetStateAction<l[]>>;
+    markDirty: () => void;
+}
+interface SectionOperations {
+    addSection: (name: string, afterSlideIndex: number) => void;
+    renameSection: (sectionId: string, newName: string) => void;
+    deleteSection: (sectionId: string) => void;
+    moveSectionUp: (sectionId: string) => void;
+    moveSectionDown: (sectionId: string) => void;
+    moveSlidesToSection: (slideIndexes: number[], targetSectionId: string) => void;
+}
+declare function useSectionOperations(input: UseSectionOperationsInput): SectionOperations;
+
+/**
+ * Shared types for the usePointerHandlers hook and its extracted helpers.
+ */
+
+interface UsePointerHandlersInput {
+    editorScale: number;
+    canvasStageRef: React.RefObject<HTMLDivElement | null>;
+    canvasSize: CanvasSize;
+    activeSlide: l | undefined;
+    activeSlideIndex: number;
+    gridSpacingPx: number;
+    dragStateRef: React.MutableRefObject<DragState | null>;
+    resizeStateRef: React.MutableRefObject<ResizeState | null>;
+    shapeAdjustmentDragStateRef: React.MutableRefObject<ShapeAdjustmentDragState | null>;
+    marqueeStateRef: React.MutableRefObject<MarqueeSelectionState | null>;
+    /** When true, pointer commits target the per-slide template store. */
+    editTemplateMode: boolean;
+    snapToGrid: boolean;
+    snapToShape: boolean;
+    guides: Array<{
+        id: string;
+        axis: 'h' | 'v';
+        position: number;
+    }>;
+    /** Template (master/layout) elements for the active slide (drag/marquee source while editing templates). */
+    templateElements: P[];
+    elementLookup: Map<string, P>;
+    setMarqueeSelectionState: React.Dispatch<React.SetStateAction<MarqueeSelectionState | null>>;
+    setSnapLines: React.Dispatch<React.SetStateAction<Array<{
+        axis: string;
+        position: number;
+    }>>>;
+    setTemplateElementsBySlideId: React.Dispatch<React.SetStateAction<Record<string, P[]>>>;
+    setPointerCommitNonce: React.Dispatch<React.SetStateAction<number>>;
+    effectiveSelectedIds: string[];
+    applySelection: (primaryId: string | null, ids?: string[]) => void;
+    clearSelection: () => void;
+    updateSlides: (updater: (s: l[]) => l[]) => void;
+    updateElementById: (id: string, updates: Partial<P>) => void;
+    markDirty: () => void;
+}
+
+declare function usePointerHandlers(input: UsePointerHandlersInput): void;
+
+/**
+ * Shared type for canvas interaction handler signatures.
+ */
+interface CanvasInteractionHandlers {
+    handleElementClick: (elementId: string, e: React.MouseEvent) => void;
+    handleElementDoubleClick: (elementId: string, e: React.MouseEvent) => void;
+    handleElementMouseDown: (elementId: string, e: React.MouseEvent) => void;
+    handleElementContextMenu: (elementId: string, e: React.MouseEvent) => void;
+    handleCanvasMouseDown: (e: React.MouseEvent) => void;
+    handleResizePointerDown: (elementId: string, e: React.MouseEvent, handle: string) => void;
+    handleAdjustmentPointerDown: (elementId: string, e: React.MouseEvent) => void;
+    /** Commit a new rotation (degrees) for an element from the on-canvas rotate handle. */
+    handleRotate: (elementId: string, rotationDeg: number) => void;
+    /** Commit an inline (on-canvas) SmartArt node edit through the element-update path. */
+    handleUpdateSmartArtElement: (elementId: string, updates: Partial<P>) => void;
+    /** Apply a text-style toggle (Ctrl/Cmd+B/I/U) to the element being inline-edited. */
+    handleFormatText: (updates: Partial<a0>) => void;
+    handleInlineEditCommit: () => void;
+}
+
+interface UseCanvasInteractionsInput {
+    mode: ViewerMode;
+    canEdit: boolean;
+    canvasSize: CanvasSize;
+    activeSlideIndex: number;
+    selectedElementId: string | null;
+    selectedElementIds: string[];
+    selectedElementIdSet: Set<string>;
+    inlineEditingElementId: string | null;
+    effectiveSelectedIds: string[];
+    elementLookup: Map<string, P>;
+    activeTool: string;
+    editTemplateMode: boolean;
+    editorScale: number;
+    canvasStageRef: React.RefObject<HTMLDivElement | null>;
+    dragStateRef: React.MutableRefObject<DragState | null>;
+    resizeStateRef: React.MutableRefObject<ResizeState | null>;
+    shapeAdjustmentDragStateRef: React.MutableRefObject<ShapeAdjustmentDragState | null>;
+    marqueeStateRef: React.MutableRefObject<MarqueeSelectionState | null>;
+    setInlineEditingElementId: React.Dispatch<React.SetStateAction<string | null>>;
+    setInlineEditingText: React.Dispatch<React.SetStateAction<string>>;
+    setContextMenuState: React.Dispatch<React.SetStateAction<ElementContextMenuState | null>>;
+    setMarqueeSelectionState: React.Dispatch<React.SetStateAction<MarqueeSelectionState | null>>;
+    setSnapLines: React.Dispatch<React.SetStateAction<Array<{
+        axis: string;
+        position: number;
+    }>>>;
+    inlineEditingText: string;
+    ops: ElementOperations;
+    history: EditorHistoryResult;
+    presentationHandleAction: (action: Record<string, unknown>) => void;
+    setEditingEquationOmml: (omml: Record<string, unknown> | null) => void;
+    setIsEquationDialogOpen: (open: boolean) => void;
+    /** Bumped after a committed on-canvas edit so the history hook snapshots it. */
+    setPointerCommitNonce?: React.Dispatch<React.SetStateAction<number>>;
+}
+declare function useCanvasInteractions(input: UseCanvasInteractionsInput): CanvasInteractionHandlers;
+
+/** The type of hyperlink target. */
+type HyperlinkTargetType = 'url' | 'email' | 'slide' | 'file' | 'action';
+/** Supported action verbs for action hyperlinks. */
+type HyperlinkActionVerb = 'nextSlide' | 'prevSlide' | 'firstSlide' | 'lastSlide' | 'endShow';
+/** Data model for the hyperlink editor dialog. */
+interface HyperlinkEditData {
+    targetType: HyperlinkTargetType;
+    url: string;
+    tooltip: string;
+    emailAddress: string;
+    emailSubject: string;
+    slideNumber: number;
+    filePath: string;
+    actionVerb: HyperlinkActionVerb;
+}
+
+/**
+ * useInsertElements: Handlers for inserting new elements (text, shape,
+ * table, SmartArt, equation, field, action button, ink, freeform)
+ * and image/media file picking.
+ */
+
+interface UseInsertElementsInput {
+    activeSlide: l | undefined;
+    activeSlideIndex: number;
+    canvasSize: CanvasSize;
+    newShapeType: SupportedShapeType;
+    selectedElements: P[];
+    ops: ElementOperations;
+    history: EditorHistoryResult;
+}
+interface InsertElementHandlers {
+    handleAddTextBox: () => void;
+    handleAddShape: () => void;
+    handleAddTable: () => void;
+    handleAddChart: (chartType: k) => void;
+    handleInsertSmartArt: (layout: ca, defaultItems: string[]) => void;
+    handleInsertEquation: (omml: Record<string, unknown>) => void;
+    handleUpdateEquation: (omml: Record<string, unknown>) => void;
+    handleHyperlinkConfirm: (data: HyperlinkEditData) => void;
+    handleInsertField: (fieldType: string, value?: string) => void;
+    handleAddActionButton: (shapeType: string) => void;
+    handleAddInkElement: (ink: I) => void;
+    handleAddFreeformShape: (shape: S) => void;
+    handleEraseInkElement: (elementId: string) => void;
+    handleImageFileChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    handleMediaFileChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+}
+declare function useInsertElements(input: UseInsertElementsInput): InsertElementHandlers;
+
+/**
+ * Shared types for the useElementManipulation hook and its sub-hooks.
+ */
+
+interface UseElementManipulationInput {
+    activeSlide: l | undefined;
+    activeSlideIndex: number;
+    selectedElement: P | null;
+    effectiveSelectedIds: string[];
+    selectedElements: P[];
+    selectedElementIdSet: Set<string>;
+    elementLookup: Map<string, P>;
+    editTemplateMode: boolean;
+    clipboardPayload: {
+        element: P;
+        isTemplate: boolean;
+    } | null;
+    setClipboardPayload: React.Dispatch<React.SetStateAction<{
+        element: P;
+        isTemplate: boolean;
+    } | null>>;
+    setSelectedElementIds: React.Dispatch<React.SetStateAction<string[]>>;
+    setIsInspectorPaneOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    setSidebarPanelMode: React.Dispatch<React.SetStateAction<string>>;
+    ops: ElementOperations;
+    history: EditorHistoryResult;
+    onOpenHyperlinkDialog: () => void;
+}
+interface ElementManipulationHandlers {
+    handleCopy: () => void;
+    handleCut: () => void;
+    handlePaste: () => void;
+    handleDuplicate: () => void;
+    handleGroupElements: () => void;
+    handleUngroupElement: () => void;
+    handleDelete: () => void;
+    handleFlip: (direction: 'horizontal' | 'vertical') => void;
+    handleAlignElements: (align: string) => void;
+    handleDistributeElements: (axis: string) => void;
+    canDistribute: boolean;
+    handleMoveLayer: (direction: string) => void;
+    handleMoveLayerToEdge: (direction: string) => void;
+    handleMergeShapes: (operation: MergeShapeOperation) => void;
+    canMergeShapes: boolean;
+    handleContextMenuAction: (action: ElementContextMenuAction) => void;
+}
+interface ClipboardHandlers {
+    handleCopy: () => void;
+    handleCut: () => void;
+    handlePaste: () => void;
+    handleDuplicate: () => void;
+    handleDelete: () => void;
+}
+interface GroupAlignLayerHandlers {
+    handleGroupElements: () => void;
+    handleUngroupElement: () => void;
+    handleFlip: (direction: 'horizontal' | 'vertical') => void;
+    handleAlignElements: (align: string) => void;
+    handleDistributeElements: (axis: string) => void;
+    canDistribute: boolean;
+    handleMoveLayer: (direction: string) => void;
+    handleMoveLayerToEdge: (direction: string) => void;
+    handleMergeShapes: (operation: MergeShapeOperation) => void;
+    canMergeShapes: boolean;
+}
+
+declare function useElementManipulation(input: UseElementManipulationInput): ElementManipulationHandlers;
+
+/**
+ * useSlideManagement: Slide CRUD operations: add, move, delete,
+ * duplicate, toggle-hide, insert-from-layout, and context menu.
+ */
+
+interface UseSlideManagementInput {
+    slides: l[];
+    activeSlide: l | undefined;
+    activeSlideIndex: number;
+    setActiveSlideIndex: React__default.Dispatch<React__default.SetStateAction<number>>;
+    ops: ElementOperations;
+    history: EditorHistoryResult;
+    /** Ref to the loaded PPTX handler; `current` is null before initial load. */
+    handlerRef?: React__default.RefObject<PptxHandler | null> | React__default.MutableRefObject<PptxHandler | null>;
+}
+interface SlideManagementHandlers {
+    handleAddSlide: () => void;
+    handleMoveSlide: (fromIndex: number, toIndex: number) => void;
+    handleSlideContextMenu: (e: React__default.MouseEvent, index: number) => void;
+    handleDeleteSlides: (indexes: number[]) => void;
+    handleDuplicateSlides: (indexes: number[]) => void;
+    handleToggleHideSlides: (indexes: number[]) => void;
+    handleInsertSlideFromLayout: (layoutPath: string, layoutName?: string) => void;
+}
+declare function useSlideManagement(input: UseSlideManagementInput): SlideManagementHandlers;
+
+interface UseTableOperationsInput {
+    selectedElement: P | null;
+    tableEditorState: TableCellEditorState | null;
+    elementLookup: Map<string, P>;
+    setTableEditorState: Dispatch<SetStateAction<TableCellEditorState | null>>;
+    ops: ElementOperations;
+    history: EditorHistoryResult;
+}
+interface TableStructHandlers {
+    handleCommitCellEdit: (elementId: string, rowIndex: number, colIndex: number, text: string) => void;
+    handleUpdateCellTextStyle: (styleUpdates: Record<string, unknown>) => void;
+    handleResizeTableColumns: (elementId: string, newWidths: number[]) => void;
+    handleResizeTableRow: (elementId: string, rowIndex: number, newHeight: number) => void;
+    handleInsertTableRow: (position: 'above' | 'below') => void;
+    handleDeleteTableRow: () => void;
+    handleInsertTableColumn: (position: 'left' | 'right') => void;
+    handleDeleteTableColumn: () => void;
+}
+interface TableMergeHandlers {
+    handleMergeCellRight: () => void;
+    handleMergeCellDown: () => void;
+    handleMergeSelectedCells: () => void;
+    handleSplitCell: () => void;
+}
+type TableOperationHandlers = TableStructHandlers & TableMergeHandlers;
+
+/**
+ * useTableOperations: Cell editing, column / row resize, insert / delete
+ * rows/columns, cell merge / split for table elements.
+ */
+
+declare function useTableOperations(input: UseTableOperationsInput): TableOperationHandlers;
+
+interface UseExportHandlersInput {
+    slides: l[];
+    /** Separated master/layout (template) elements, merged back at save time. */
+    templateElementsBySlideId: Record<string, P[]>;
+    activeSlide: l | undefined;
+    activeSlideIndex: number;
+    filePath: string | undefined;
+    canvasStageRef: RefObject<HTMLDivElement | null>;
+    setActiveSlideIndex: Dispatch<SetStateAction<number>>;
+    handlerRef: RefObject<PptxHandler | null>;
+    serializeSlides: () => Promise<Uint8Array | null>;
+    /** State from the viewer needed for save-as */
+    headerFooter: Record<string, unknown>;
+    presentationProperties: Record<string, unknown>;
+    customShows: Array<{
+        id: string;
+        name: string;
+        slideRIds: string[];
+    }>;
+    sections: Array<{
+        id: string;
+        name: string;
+        color?: string;
+        collapsed?: boolean;
+    }>;
+    coreProperties: Record<string, unknown> | null;
+    appProperties: Record<string, unknown> | null;
+    customProperties: Array<Record<string, unknown>>;
+    notesMaster: Record<string, unknown> | undefined;
+    handoutMaster: Record<string, unknown> | undefined;
+    guides: Array<{
+        id: string;
+        axis: 'h' | 'v';
+        position: number;
+    }>;
+    activeSlideIndexForGuides: number;
+    password?: string;
+}
+interface ExportHandlersResult {
+    handleExportPng: () => Promise<void>;
+    handleExportPdf: () => Promise<void>;
+    handleExportNotesPdf: () => Promise<void>;
+    handleCopySlideAsImage: () => Promise<void>;
+    handleExportVideo: () => Promise<void>;
+    handleExportGif: () => Promise<void>;
+    handlePackageForSharing: () => Promise<void>;
+    handleSaveAsFormat: (format: PptxSaveFormat) => Promise<void>;
+    handleSaveAsPptx: () => void;
+    handleSaveAsPpsx: () => void;
+    handleSaveAsPptm: () => void;
+    handleCancelExport: () => void;
+    exportModalOpen: boolean;
+    exportModalTitle: string;
+    exportProgress: number;
+    exportStatusMessage: string;
+}
+/** Controls for the shared export-progress modal, passed to sub-hooks. */
+interface ExportModalControls {
+    setExportModalOpen: (open: boolean) => void;
+    setExportModalTitle: (title: string) => void;
+    setExportProgress: (progress: number) => void;
+    setExportStatusMessage: (message: string) => void;
+    exportAbortRef: MutableRefObject<AbortController | null>;
+}
+
+declare function useExportHandlers(input: UseExportHandlersInput): ExportHandlersResult;
+
+interface UsePrintHandlersInput {
+    slides: l[];
+    activeSlideIndex: number;
+    canvasStageRef: RefObject<HTMLDivElement | null>;
+    setActiveSlideIndex: React.Dispatch<React.SetStateAction<number>>;
+    /** Parsed PPTX data (needed for SVG print path). Optional for backward compat. */
+    pptxData?: m;
+}
+interface PrintHandlersResult {
+    handlePrint: () => void;
+    handlePrintWithSettings: (settings: PrintSettings) => Promise<void>;
+    handlePrintSvg: (settings: PrintSettings) => Promise<void>;
+    isPrintDialogOpen: boolean;
+    setIsPrintDialogOpen: React.Dispatch<React.SetStateAction<boolean>>;
+}
+declare function usePrintHandlers(input: UsePrintHandlersInput): PrintHandlersResult;
+
+interface UseThemeHandlersInput {
+    handlerRef: RefObject<PptxHandler | null>;
+    serializeSlides: () => Promise<Uint8Array | null>;
+    setContent: React.Dispatch<React.SetStateAction<ArrayBuffer | Uint8Array | null>>;
+    onContentChange: ((data: Uint8Array) => void) | undefined;
+    setTheme: React.Dispatch<React.SetStateAction<Record<string, unknown> | null>>;
+    setSlideMasters: React.Dispatch<React.SetStateAction<Array<Record<string, unknown>>>>;
+    slideMasters: Array<Record<string, unknown>>;
+    history: EditorHistoryResult;
+}
+interface ThemeHandlersResult {
+    handleApplyTheme: (themePath: string, applyToAllMasters: boolean) => Promise<void>;
+    handleUpdateThemeColorScheme: (colorScheme: d) => Promise<void>;
+    handleUpdateThemeFontScheme: (fontScheme: e) => Promise<void>;
+    handleUpdateThemeName: (name: string) => Promise<void>;
+    handleApplyThemeToPresentation: () => Promise<void>;
+    handleApplyThemeData: (colorScheme: d, fontScheme: e, themeName?: string) => Promise<void>;
+    handleSetTemplateBackground: (path: string, backgroundColor: string | undefined) => void;
+    handleGetTemplateBackgroundColor: (path: string) => string | undefined;
+    /** Return theme parts discovered in the loaded PPTX archive. */
+    handleGetAvailableThemes: () => Promise<aq[]>;
+    /**
+     * Switch the presentation to an existing theme by its archive path,
+     * update all slide masters, and refresh the serialised content.
+     */
+    handleSwitchTheme: (themePath: string) => Promise<void>;
+}
+declare function useThemeHandlers(input: UseThemeHandlersInput): ThemeHandlersResult;
+
+interface UsePropertyHandlersInput {
+    slides: l[];
+    activeSlideIndex: number;
+    canvasSize: CanvasSize;
+    setContent: React.Dispatch<React.SetStateAction<ArrayBuffer | Uint8Array | null>>;
+    setPresentationProperties: React.Dispatch<React.SetStateAction<s>>;
+    setCoreProperties: React.Dispatch<React.SetStateAction<v | null>>;
+    setAppProperties: React.Dispatch<React.SetStateAction<w | null>>;
+    setCustomProperties: React.Dispatch<React.SetStateAction<x[]>>;
+    setSlides: React.Dispatch<React.SetStateAction<l[]>>;
+    setIsDirty: React.Dispatch<React.SetStateAction<boolean>>;
+    ops: ElementOperations;
+    history: EditorHistoryResult;
+}
+interface PropertyHandlersResult {
+    handleUpdateNotes: (text: string, segments?: N[]) => void;
+    handleUpdateSlide: (updates: Partial<l>) => void;
+    handleUpdatePresentationProperties: (updates: Partial<s>) => void;
+    handleUpdateCoreProperties: (updates: Partial<v>) => void;
+    handleUpdateAppProperties: (updates: Partial<w>) => void;
+    handleUpdateCustomProperties: (next: x[]) => void;
+    handleRestoreVersion: (versionData: Uint8Array) => void;
+    handleCompare: () => Promise<void>;
+    handleAcceptSlide: (di: number) => void;
+    handleRejectSlide: (di: number) => void;
+    handleAcceptAllSlides: () => void;
+    isVersionHistoryOpen: boolean;
+    setIsVersionHistoryOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    isComparePanelOpen: boolean;
+    setIsComparePanelOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    compareResult: CompareResult | null;
+    usedFontFamilies: string[];
+}
+declare function usePropertyHandlers(input: UsePropertyHandlersInput): PropertyHandlersResult;
+
+/**
+ * Types for the {@link useViewerDialogs} hook.
+ *
+ * Describes the input dependencies and the output shape for all dialog-related
+ * state and handlers in the viewer (SmartArt, equation editor, master view,
+ * custom shows, password protection, accessibility checks, etc.).
+ *
+ * @module viewer-dialog-types
+ */
+
+/**
+ * Input dependencies required by the {@link useViewerDialogs} hook.
+ *
+ * Collects references to core state, setters, and the editor history
+ * so the hook can manage dialog visibility, master view transitions,
+ * guide creation, custom show CRUD, and accessibility checking.
+ */
+interface UseViewerDialogsInput {
+    /** Current viewer mode (edit, view, present, master). */
+    mode: ViewerMode;
+    /** All slides in the presentation. */
+    slides: l[];
+    /** The currently active slide, or undefined. */
+    activeSlide: l | undefined;
+    /** Zero-based index of the active slide. */
+    activeSlideIndex: number;
+    /** Slide canvas dimensions (used for guide positioning). */
+    canvasSize: CanvasSize;
+    /** Ref to the container element (used for viewport width detection). */
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    /** Custom shows defined in the presentation. */
+    customShows: Array<{
+        id: string;
+        name: string;
+        slideRIds: string[];
+    }>;
+    /** ID of the currently active custom show. */
+    activeCustomShowId: string | null;
+    /** Setter for custom shows. */
+    setCustomShows: React.Dispatch<React.SetStateAction<Array<{
+        id: string;
+        name: string;
+        slideRIds: string[];
+    }>>>;
+    /** Setter for the active custom show id. */
+    setActiveCustomShowId: React.Dispatch<React.SetStateAction<string | null>>;
+    /** Setter for the slide guides array. */
+    setGuides: React.Dispatch<React.SetStateAction<Array<{
+        id: string;
+        axis: 'h' | 'v';
+        position: number;
+    }>>>;
+    /** Setter for presentation-level properties. */
+    setPresentationProperties: React.Dispatch<React.SetStateAction<s>>;
+    /** Setter for accessibility issue results. */
+    setAccessibilityIssues: React.Dispatch<React.SetStateAction<Array<{
+        slideIndex: number;
+        elementId: string;
+        severity: 'error' | 'warning' | 'info';
+        message: string;
+    }>>>;
+    /** Setter to open/close the accessibility panel. */
+    setIsAccessibilityPanelOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    /** Setter for the viewer mode. */
+    setMode: React.Dispatch<React.SetStateAction<ViewerMode>>;
+    /** Setter for the pre-master-view mode (used to restore on close). */
+    setPreMasterMode: React.Dispatch<React.SetStateAction<ViewerMode>>;
+    /** Setter for the active master index. */
+    setActiveMasterIndex: React.Dispatch<React.SetStateAction<number>>;
+    /** Setter for the active layout index within a master. */
+    setActiveLayoutIndex: React.Dispatch<React.SetStateAction<number | null>>;
+    /** Setter for the primary selected element id. */
+    setSelectedElementId: React.Dispatch<React.SetStateAction<string | null>>;
+    /** Setter for the multi-selection element ids. */
+    setSelectedElementIds: React.Dispatch<React.SetStateAction<string[]>>;
+    /** The mode the viewer was in before entering master view. */
+    preMasterMode: ViewerMode;
+    /** Whether the presentation contains digital signatures (triggers strip warning on edit). */
+    hasDigitalSignatures: boolean;
+    /** Whether there are unsaved modifications. */
+    isDirty: boolean;
+    /** Editor history instance (used for markDirty on settings changes). */
+    history: EditorHistoryResult;
+}
+/**
+ * Output shape of the {@link useViewerDialogs} hook.
+ *
+ * Provides boolean state + setters for every dialog/modal, plus handler
+ * callbacks for master view navigation, guide creation, custom show management,
+ * slide-show settings, password, and accessibility.
+ */
+interface ViewerDialogsResult {
+    /** Whether the Insert SmartArt dialog is visible. */
+    isSmartArtDialogOpen: boolean;
+    setIsSmartArtDialogOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    /** Whether the equation (MathML/OMML) editor dialog is visible. */
+    isEquationDialogOpen: boolean;
+    setIsEquationDialogOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    /** Whether the hyperlink editor dialog is visible. */
+    isHyperlinkDialogOpen: boolean;
+    setIsHyperlinkDialogOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    /** Whether the set/remove password dialog is visible. */
+    isPasswordDialogOpen: boolean;
+    setIsPasswordDialogOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    /** Whether the document properties dialog is visible. */
+    isDocPropsDialogOpen: boolean;
+    setIsDocPropsDialogOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    /** Whether the font embedding panel is visible. */
+    isFontEmbeddingOpen: boolean;
+    setIsFontEmbeddingOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    /** Whether the digital signatures detail dialog is visible. */
+    isDigitalSigDialogOpen: boolean;
+    setIsDigitalSigDialogOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    /** Whether the "signatures will be stripped" warning dialog is visible. */
+    isSignatureStrippedDialogOpen: boolean;
+    setIsSignatureStrippedDialogOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    /** Whether the "Set Up Slide Show" configuration dialog is visible. */
+    isSetUpSlideShowOpen: boolean;
+    setIsSetUpSlideShowOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    /** Whether the broadcast (share screen) dialog is visible. */
+    isBroadcastDialogOpen: boolean;
+    setIsBroadcastDialogOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    /** Whether the presentation is currently password-protected. */
+    isPasswordProtected: boolean;
+    /** The active password, or null when the presentation is not protected. */
+    presentationPassword: string | null;
+    /** OMML data for the equation currently being edited, or null. */
+    editingEquationOmml: Record<string, unknown> | null;
+    setEditingEquationOmml: React.Dispatch<React.SetStateAction<Record<string, unknown> | null>>;
+    /** Whether font embedding is enabled for save. */
+    embedFontsEnabled: boolean;
+    setEmbedFontsEnabled: React.Dispatch<React.SetStateAction<boolean>>;
+    /** True when the container is narrower than 768px (triggers compact layout). */
+    isNarrowViewport: boolean;
+    /** Switches the viewer to master view mode, preserving the previous mode for restoration. */
+    handleEnterMasterView: () => void;
+    /** Exits master view and restores the previous mode. */
+    handleCloseMasterView: () => void;
+    /**
+     * Selects a slide master by index and clears layout/element selection.
+     * @param index - Zero-based index into the `slideMasters` array.
+     */
+    handleSelectMaster: (index: number) => void;
+    /**
+     * Selects a specific layout within a master.
+     * @param masterIndex - Zero-based master index.
+     * @param layoutIndex - Zero-based layout index within that master.
+     */
+    handleSelectLayout: (masterIndex: number, layoutIndex: number) => void;
+    /**
+     * Adds a horizontal or vertical guide at the canvas center.
+     * @param axis - "h" for horizontal, "v" for vertical.
+     */
+    handleAddGuide: (axis: 'h' | 'v') => void;
+    /** Creates a new empty custom show and makes it active. */
+    handleCreateCustomShow: () => void;
+    /** Prompts to rename the currently active custom show. */
+    handleRenameActiveCustomShow: () => void;
+    /** Deletes the currently active custom show. */
+    handleDeleteActiveCustomShow: () => void;
+    /** Adds or removes the current slide from the active custom show. */
+    handleToggleCurrentSlideInActiveShow: () => void;
+    /** Whether the current slide is included in the active custom show. */
+    isCurrentSlideInActiveShow: boolean;
+    /**
+     * Persists updated presentation properties (loop, range, show type, etc.).
+     * @param props - The new presentation properties to save.
+     */
+    handleSaveSlideShowSettings: (props: s) => void;
+    /** Toggles the subtitle overlay during presentation mode. */
+    handleToggleSubtitles: () => void;
+    /**
+     * Sets a password on the presentation.
+     * @param password - The password string to apply.
+     */
+    handleSetPassword: (password: string) => void;
+    /** Removes password protection from the presentation. */
+    handleRemovePassword: () => void;
+    /** Runs an accessibility check across all slides and opens the results panel. */
+    handleRunAccessibilityCheck: () => void;
+}
+
+declare function useViewerDialogs(input: UseViewerDialogsInput): ViewerDialogsResult;
+
+interface UseDerivedSlideStateInput {
+    slides: l[];
+    sections: Array<{
+        id: string;
+        name: string;
+        collapsed?: boolean;
+        color?: string;
+    }>;
+    customShows: Array<{
+        id: string;
+        name: string;
+        slideRIds: string[];
+    }>;
+    activeCustomShowId: string | null;
+    mode: ViewerMode;
+    activeLayout: B | undefined;
+    activeMaster: A | undefined;
+    presentationGridSpacing: {
+        cx: number;
+    } | undefined;
+}
+interface DerivedSlideState {
+    gridSpacingPx: number;
+    visibleSlideIndexes: number[];
+    slideSectionGroups: SlideSectionGroup[];
+    masterPseudoSlide: l | undefined;
+}
+declare function useDerivedSlideState(input: UseDerivedSlideStateInput): DerivedSlideState;
+
+interface UseAnnotationHandlersInput {
+    mode: ViewerMode;
+    presentation: UsePresentationModeResult;
+    annotations: UsePresentationAnnotationsResult;
+    history: EditorHistoryResult;
+    setMode: React.Dispatch<React.SetStateAction<ViewerMode>>;
+    setSlides: React.Dispatch<React.SetStateAction<l[]>>;
+}
+interface AnnotationHandlersResult {
+    showKeepAnnotationsDialog: boolean;
+    handleSetMode: (nextMode: ViewerMode) => void;
+    handleKeepAnnotations: () => void;
+    handleDiscardAnnotations: () => void;
+    handleEnterPresenterView: () => void;
+    handleEnterRehearsalMode: () => void;
+}
+declare function useAnnotationHandlers(input: UseAnnotationHandlersInput): AnnotationHandlersResult;
+
+interface UseSerializeInput {
+    slides: l[];
+    /** Separated master/layout (template) elements, merged back at save time. */
+    templateElementsBySlideId: Record<string, P[]>;
+    activeSlideIndex: number;
+    guides: Array<{
+        id: string;
+        axis: 'h' | 'v';
+        position: number;
+    }>;
+    headerFooter: r;
+    presentationProperties: s;
+    customShows: Array<{
+        id: string;
+        name: string;
+        slideRIds: string[];
+    }>;
+    sections: u[];
+    coreProperties: v | undefined;
+    appProperties: w | undefined;
+    customProperties: x[];
+    notesMaster: y | undefined;
+    handoutMaster: z | undefined;
+    handlerRef: React__default.RefObject<PptxHandler | null>;
+    inlineEditingElementIdRef: React__default.MutableRefObject<string | null>;
+    inlineEditingTextRef: React__default.MutableRefObject<string>;
+    password?: string;
+}
+declare function useSerialize(input: UseSerializeInput): () => Promise<Uint8Array | null>;
+
+interface UseRecoveryDetectionInput {
+    filePath: string | undefined;
+    loading: boolean;
+    error: string | null;
+    slideCount: number;
+    openVersionHistory: () => void;
+}
+declare function useRecoveryDetection(input: UseRecoveryDetectionInput): void;
+
+interface UsePresentationSetupInput {
+    mode: ViewerMode;
+    slides: l[];
+    visibleSlideIndexes: number[];
+    activeSlideIndex: number;
+    containerRef: React.RefObject<HTMLElement | null>;
+    /** Raw PPTX bytes: forwarded to audience window for content sharing. */
+    content?: ArrayBuffer | Uint8Array | null;
+    mediaDataUrls: Map<string, string>;
+    presentationProperties: {
+        loopContinuously?: boolean;
+        showType?: string;
+        showWithAnimation?: boolean;
+        advanceMode?: 'manual' | 'useTimings';
+    };
+    setMode: React.Dispatch<React.SetStateAction<ViewerMode>>;
+    setActiveSlideIndex: React.Dispatch<React.SetStateAction<number>>;
+    setSlides: React.Dispatch<React.SetStateAction<l[]>>;
+    history: EditorHistoryResult;
+}
+interface PresentationSetupResult {
+    presentation: UsePresentationModeResult;
+    annotations: UsePresentationAnnotationsResult;
+    actionSoundHandlerRef: React.MutableRefObject<PptxHandler | null>;
+}
+declare function usePresentationSetup(input: UsePresentationSetupInput): PresentationSetupResult;
+
+interface UseEditorOperationsInput {
+    state: ViewerState;
+    history: EditorHistoryResult;
+    zoom: {
+        editorScale: number;
+        canvasStageRef: React__default.RefObject<HTMLDivElement | null>;
+    };
+    mode: ViewerMode;
+    canEdit: boolean;
+    slides: l[];
+    activeSlide: l | undefined;
+    activeSlideIndex: number;
+    selectedElement: P | null;
+    selectedElementId: string | null;
+    selectedElementIds: string[];
+    canvasSize: CanvasSize;
+    dialogs: ViewerDialogsResult;
+    presentation: UsePresentationModeResult;
+    /** Display name for comment authoring. */
+    userName?: string;
+    /** Ref to the loaded PPTX handler; populated by the content-lifecycle hook. */
+    handlerRef?: React__default.RefObject<PptxHandler | null> | React__default.MutableRefObject<PptxHandler | null>;
+}
+interface EditorOperationsResult {
+    ops: ElementOperations;
+    sectionOps: SectionOperations;
+    findReplace: ReturnType<typeof useFindReplace>;
+    comments: ReturnType<typeof useComments>;
+    canvasHandlers: CanvasInteractionHandlers;
+    insertHandlers: InsertElementHandlers;
+    manipulation: ElementManipulationHandlers;
+    slideOps: SlideManagementHandlers;
+    tableOps: TableOperationHandlers;
+}
+declare function useEditorOperations(input: UseEditorOperationsInput): EditorOperationsResult;
+
+interface UseIOHandlersInput {
+    state: ViewerState;
+    slides: l[];
+    activeSlideIndex: number;
+    canvasSize: CanvasSize;
+    filePath: string | undefined;
+    history: EditorHistoryResult;
+    ops: ElementOperations;
+    zoom: {
+        canvasStageRef: React__default.RefObject<HTMLDivElement | null>;
+    };
+    handlerRef: React__default.RefObject<PptxHandler | null>;
+    serializeSlides: () => Promise<Uint8Array | null>;
+    setContent: React__default.Dispatch<React__default.SetStateAction<ArrayBuffer | Uint8Array | null>>;
+    onContentChange: ((content: Uint8Array) => void) | undefined;
+    password?: string;
+}
+interface IOHandlersResult {
+    exportHandlers: ExportHandlersResult;
+    printHandlers: PrintHandlersResult;
+    themeHandlers: ThemeHandlersResult;
+    propertyHandlers: PropertyHandlersResult;
+}
+declare function useIOHandlers(input: UseIOHandlersInput): IOHandlersResult;
+
+interface UseContentLifecycleInput {
+    content: ArrayBuffer | Uint8Array | null;
+    filePath: string | undefined;
+    /** AutoSave toggle state; when false the recovery autosave timer is off. */
+    autosaveEnabled?: boolean;
+    slides: l[];
+    state: ViewerState;
+    history: EditorHistoryResult;
+    ops: ElementOperations;
+    actionSoundHandlerRef: React__default.MutableRefObject<PptxHandler | null>;
+    setIsEncryptedDialogOpen: React__default.Dispatch<React__default.SetStateAction<boolean>>;
+    password?: string;
+}
+interface ContentLifecycleResult {
+    handlerRef: React__default.RefObject<PptxHandler | null>;
+    serializeSlides: () => Promise<Uint8Array | null>;
+    autosaveStatus: AutosaveStatus;
+}
+declare function useContentLifecycle(input: UseContentLifecycleInput): ContentLifecycleResult;
+
+/**
+ * useKeyboardShortcutWiring: Wires the composed editor results into the
+ * generic `useKeyboardShortcuts` hook.  Keeps the orchestrator lean.
+ */
+
+interface UseKeyboardShortcutWiringInput {
+    state: ViewerState;
+    mode: ViewerMode;
+    canEdit: boolean;
+    slides: l[];
+    activeSlide: l | undefined;
+    ops: ElementOperations;
+    manipulation: ElementManipulationHandlers;
+    history: EditorHistoryResult;
+}
+declare function useKeyboardShortcutWiring(input: UseKeyboardShortcutWiringInput): void;
+
+interface UseViewerIntegrationInput {
+    state: ViewerState;
+    zoom: UseZoomViewportResult;
+    history: EditorHistoryResult;
+    presentation: PresentationSetupResult['presentation'];
+    annotations: PresentationSetupResult['annotations'];
+    actionSoundHandlerRef: PresentationSetupResult['actionSoundHandlerRef'];
+    editorOps: EditorOperationsResult;
+    dialogs: ViewerDialogsResult;
+    gridSpacingPx: number;
+    content: ArrayBuffer | Uint8Array | null;
+    filePath: string | undefined;
+    /** AutoSave toggle state from the title bar. */
+    autosaveEnabled: boolean;
+    canEdit: boolean;
+    mode: ViewerState['mode'];
+    slides: l[];
+    activeSlide: l | undefined;
+    activeSlideIndex: number;
+    canvasSize: ViewerState['canvasSize'];
+    loading: boolean;
+    error: string | null;
+    ref: ForwardedRef<PowerPointViewerHandle>;
+    setContent: Dispatch<SetStateAction<ArrayBuffer | Uint8Array | null>>;
+    onContentChange: ((content: Uint8Array) => void) | undefined;
+    onDirtyChange: ((dirty: boolean) => void) | undefined;
+    onActiveSlideChange: ((index: number) => void) | undefined;
+    onModeChange: ((mode: ViewerMode) => void) | undefined;
+    onZoomChange: ((zoom: number) => void) | undefined;
+    onSelectionChange: ((ids: string[]) => void) | undefined;
+    onSlideCountChange: ((count: number) => void) | undefined;
+}
+interface ViewerIntegrationResult {
+    exportHandlers: IOHandlersResult['exportHandlers'];
+    printHandlers: IOHandlersResult['printHandlers'];
+    themeHandlers: IOHandlersResult['themeHandlers'];
+    propertyHandlers: IOHandlersResult['propertyHandlers'];
+    showKeepAnnotationsDialog: AnnotationHandlersResult['showKeepAnnotationsDialog'];
+    handleSetMode: AnnotationHandlersResult['handleSetMode'];
+    handleKeepAnnotations: AnnotationHandlersResult['handleKeepAnnotations'];
+    handleDiscardAnnotations: AnnotationHandlersResult['handleDiscardAnnotations'];
+    handleEnterPresenterView: AnnotationHandlersResult['handleEnterPresenterView'];
+    handleEnterRehearsalMode: AnnotationHandlersResult['handleEnterRehearsalMode'];
+    autosaveStatus: AutosaveStatus;
+    isEncryptedDialogOpen: boolean;
+    setIsEncryptedDialogOpen: Dispatch<SetStateAction<boolean>>;
+}
+declare function useViewerIntegration(input: UseViewerIntegrationInput): ViewerIntegrationResult;
+
+interface UseReducedMotionResult {
+    /** Whether the OS reports prefers-reduced-motion: reduce. */
+    osReducedMotion: boolean;
+    /** Whether the user has manually toggled reduced motion on. */
+    manualReducedMotion: boolean;
+    /** Effective value: true when either OS or manual toggle is active. */
+    reducedMotion: boolean;
+    /** Toggle the manual override on/off. */
+    toggleReducedMotion: () => void;
+    /** Set the manual override to a specific value. */
+    setManualReducedMotion: (value: boolean) => void;
+}
+/**
+ * Detects the OS `prefers-reduced-motion` media query and provides a
+ * manual toggle for users who want to disable animations in the viewer
+ * without changing their OS settings.
+ *
+ * @returns {@link UseReducedMotionResult}
+ */
+declare function useReducedMotion(): UseReducedMotionResult;
+
+/**
+ * useYjsDocumentSync -- Syncs PptxSlide[] state with a Yjs Y.Doc using the
+ * granular `pptx:slides` Y.Array structure (one Y.Map per slide, per-element
+ * Y.Maps, and Y.Text for textSegments). This matches the schema defined by
+ * PptxCodec in packages/tools so all bindings and the codec are interoperable.
+ *
+ * Write-back (Area 3): when the collaboration role is `'owner'`, the hook
+ * debounces Y.Doc changes and calls `config.onWriteBack` with the serialized
+ * PPTX bytes so the host can persist a durable snapshot.
+ */
+
+interface UseYjsDocumentSyncInput {
+    /** The Yjs document (from useYjsProvider). null when not collaborating. */
+    doc: Doc | null;
+    /** Current slides state. */
+    slides: l[];
+    /** Separated master/layout (template) elements, merged back on write-back. */
+    templateElementsBySlideId: Record<string, P[]>;
+    /** React state setter for slides. */
+    setSlides: React.Dispatch<React.SetStateAction<l[]>>;
+    /** Whether collaboration is active (status === 'connected'). */
+    isConnected: boolean;
+    /**
+     * Whether the provider completed its initial document sync. Local -> doc
+     * writes are gated on this so a late joiner never seeds its bootstrap deck
+     * into a room whose real content has not arrived yet. Defaults to true for
+     * callers that manage sync readiness themselves.
+     */
+    isSynced?: boolean;
+    /** Collaboration config (for role and write-back). */
+    config?: Pick<CollaborationConfig, 'role' | 'onWriteBack' | 'writeBackDebounceMs'>;
+    /**
+     * Return the source PPTX bytes for write-back serialization. Only called
+     * when role === 'owner' and onWriteBack is set.
+     */
+    getSourceBytes?: () => Uint8Array | null;
+}
+declare function useYjsDocumentSync({ doc, slides, templateElementsBySlideId, setSlides, isConnected, isSynced, config, getSourceBytes, }: UseYjsDocumentSyncInput): void;
+
+interface UseBroadcastFollowerInput {
+    /** The collaboration context (null when collaboration is disabled). */
+    collab: CollaborationContextValue | null;
+    /** Current local active slide index. */
+    activeSlideIndex: number;
+    /** Setter for the active slide index. */
+    setActiveSlideIndex: (index: number) => void;
+    /** Total number of slides (for bounds checking). */
+    slideCount: number;
+    /**
+     * When true, auto-follow stands down (e.g. the local user is manually
+     * following a specific peer via the follow bar). Defaults to false.
+     */
+    paused?: boolean;
+}
+declare function useBroadcastFollower({ collab, activeSlideIndex, setActiveSlideIndex, slideCount, paused, }: UseBroadcastFollowerInput): void;
+
+interface UseFollowModeInput {
+    /** The collaboration context (null when collaboration is disabled). */
+    collab: CollaborationContextValue | null;
+    /** Current local active slide index. */
+    activeSlideIndex: number;
+    /** Setter for the active slide index. */
+    setActiveSlideIndex: (index: number) => void;
+    /** Total number of slides (for bounds checking). */
+    slideCount: number;
+}
+interface UseFollowModeResult {
+    /** The clientId currently being followed, or null. */
+    followedClientId: number | null;
+    /** Follow the given peer, or `null` to stop following. */
+    followUser: (clientId: number | null) => void;
+}
+declare function useFollowMode({ collab, activeSlideIndex, setActiveSlideIndex, slideCount, }: UseFollowModeInput): UseFollowModeResult;
+
+/**
+ * Input for {@link useLayoutSwitching}.
+ */
+interface UseLayoutSwitchingInput {
+    /** Current PPTX handler instance (may be null before load). */
+    handler: PptxHandler | null;
+    /** Current slides array. */
+    slides: l[];
+    /** Index of the currently active slide. */
+    activeSlideIndex: number;
+    /** Element operations for updating the slides array. */
+    ops: ElementOperations;
+    /** Editor history for marking dirty state. */
+    history: EditorHistoryResult;
+}
+/**
+ * Result returned by {@link useLayoutSwitching}.
+ */
+interface LayoutSwitchingResult {
+    /** Available layouts for the active slide (populated after calling `loadAvailableLayouts`). */
+    availableLayouts: o[];
+    /** Whether a layout operation is in progress. */
+    isLoading: boolean;
+    /** Load the available layouts for the current slide. */
+    loadAvailableLayouts: () => Promise<void>;
+    /** Apply a layout to the active slide by its archive path. */
+    applyLayout: (layoutPath: string) => Promise<void>;
+    /** The current slide's layout path (if known). */
+    currentLayoutPath: string | undefined;
+}
+/**
+ * Hook that provides layout switching capabilities for the editor.
+ *
+ * @example
+ * ```tsx
+ * const { availableLayouts, applyLayout, loadAvailableLayouts } =
+ *   useLayoutSwitching({ handler, slides, activeSlideIndex, ops, history });
+ *
+ * // Load layouts when the user opens a layout picker
+ * await loadAvailableLayouts();
+ *
+ * // Switch to a different layout
+ * await applyLayout("ppt/slideLayouts/slideLayout3.xml");
+ * ```
+ */
+declare function useLayoutSwitching(input: UseLayoutSwitchingInput): LayoutSwitchingResult;
+
+interface VirtualizedSlidesOptions {
+    /** Total number of slide items. */
+    totalItems: number;
+    /** Estimated height of each slide item in pixels. */
+    itemHeight: number;
+    /** Number of extra items to render above/below the viewport. */
+    overscan?: number;
+}
+interface VirtualizedRange {
+    /** The first index to render (inclusive). */
+    startIndex: number;
+    /** The last index to render (inclusive). */
+    endIndex: number;
+    /** Total height of the virtual container (for scrollbar sizing). */
+    totalHeight: number;
+    /** Offset (top padding) to position the rendered window correctly. */
+    offsetY: number;
+    /** The visible range without overscan (for analytics/testing). */
+    visibleRange: {
+        start: number;
+        end: number;
+    };
+}
+interface VirtualizedSlidesResult extends VirtualizedRange {
+    /** Ref to attach to the scroll container element. */
+    scrollContainerRef: React.RefObject<HTMLDivElement | null>;
+    /** Call this to scroll a specific index into view. */
+    scrollToIndex: (index: number, behavior?: ScrollBehavior) => void;
+}
+/**
+ * Compute the rendered index range given scroll state and item dimensions.
+ *
+ * This is a pure function with no React or DOM dependencies so it can
+ * be unit-tested without `renderHook` or a DOM environment.
+ */
+declare function computeVirtualRange(totalItems: number, itemHeight: number, scrollTop: number, viewportHeight: number, overscan?: number): VirtualizedRange;
+declare function useVirtualizedSlides({ totalItems, itemHeight, overscan, }: VirtualizedSlidesOptions): VirtualizedSlidesResult;
+
+/** Minimum touch target size (px) per WCAG accessibility guidelines. */
+declare const MIN_TOUCH_TARGET = 44;
+interface UseIsMobileResult {
+    /** True when container/viewport width is below 768px. */
+    isMobile: boolean;
+    /** True when container/viewport width is 768..1023px. */
+    isTablet: boolean;
+    /** True when container/viewport width is >= 1024px. */
+    isDesktop: boolean;
+    /** True on devices with touch capability. */
+    isTouchDevice: boolean;
+    /** Current device orientation (portrait or landscape). */
+    orientation: DeviceOrientation;
+    /** True when the virtual keyboard is likely visible (viewport height shrank significantly). */
+    isVirtualKeyboardOpen: boolean;
+    /** The measured container width in pixels. */
+    containerWidth: number;
+}
+interface UseIsMobileInput {
+    /** Optional ref to the container element for container-based breakpoints. */
+    containerRef?: React.RefObject<HTMLElement | null>;
+}
+declare function useIsMobile(input?: UseIsMobileInput): UseIsMobileResult;
+
+interface UseTouchGesturesInput {
+    /** The element to attach touch listeners to. */
+    targetRef: React.RefObject<HTMLElement | null>;
+    /** Current zoom scale: used as the baseline for pinch gestures. */
+    currentScale: number;
+    /** Callbacks for gesture events. */
+    callbacks: TouchGestureCallbacks;
+    /** Set to false to disable all gesture handling. Default: true. */
+    enabled?: boolean;
+}
+declare function useTouchGestures(input: UseTouchGesturesInput): void;
+
+interface UseKeyboardInsetsResult {
+    /** CSS pixels the on-screen keyboard currently covers (0 when closed). */
+    keyboardInset: number;
+    /** True when the inset is large enough to count as an open keyboard. */
+    isKeyboardOpen: boolean;
+}
+declare function useKeyboardInsets(enabled?: boolean): UseKeyboardInsetsResult;
+
+/**
+ * useClipboardHandlers: Copy, cut, paste, duplicate, and delete handlers
+ * extracted from useElementManipulation.
+ */
+
+interface ClipboardInput {
+    activeSlide: l | undefined;
+    activeSlideIndex: number;
+    selectedElement: P | null;
+    effectiveSelectedIds: string[];
+    editTemplateMode: boolean;
+    clipboardPayload: {
+        element: P;
+        isTemplate: boolean;
+    } | null;
+    setClipboardPayload: React.Dispatch<React.SetStateAction<{
+        element: P;
+        isTemplate: boolean;
+    } | null>>;
+    ops: ElementOperations;
+    history: EditorHistoryResult;
+}
+declare function useClipboardHandlers(input: ClipboardInput): ClipboardHandlers;
+
+interface UseDerivedElementStateInput {
+    slides: l[];
+    activeSlideIndex: number;
+    templateElementsBySlideId: Record<string, P[]>;
+    selectedElementId: string | null;
+    selectedElementIds: string[];
+    slideMasters: A[];
+    activeMasterIndex: number;
+    activeLayoutIndex: number | null;
+    notesMaster: y | undefined;
+    handoutMaster: z | undefined;
+}
+interface DerivedElementState {
+    activeSlide: l | undefined;
+    templateElements: P[];
+    elementLookup: Map<string, P>;
+    selectedElement: P | null;
+    effectiveSelectedIds: string[];
+    selectedElementIdSet: Set<string>;
+    selectedElements: P[];
+    activeMaster: A | undefined;
+    activeLayout: B | undefined;
+    masterViewElements: P[];
+    notesMasterElements: P[];
+    handoutMasterElements: P[];
+}
+declare function useDerivedElementState(input: UseDerivedElementStateInput): DerivedElementState;
+
+interface UseDialogCustomShowsInput {
+    activeSlide: l | undefined;
+    customShows: Array<{
+        id: string;
+        name: string;
+        slideRIds: string[];
+    }>;
+    activeCustomShowId: string | null;
+    setCustomShows: React.Dispatch<React.SetStateAction<Array<{
+        id: string;
+        name: string;
+        slideRIds: string[];
+    }>>>;
+    setActiveCustomShowId: React.Dispatch<React.SetStateAction<string | null>>;
+    history: EditorHistoryResult;
+}
+interface UseDialogCustomShowsResult {
+    handleCreateCustomShow: () => void;
+    handleRenameActiveCustomShow: () => void;
+    handleDeleteActiveCustomShow: () => void;
+    handleToggleCurrentSlideInActiveShow: () => void;
+    isCurrentSlideInActiveShow: boolean;
+}
+declare function useDialogCustomShows(input: UseDialogCustomShowsInput): UseDialogCustomShowsResult;
+
+interface UseExportSaveAsInput {
+    slides: l[];
+    /** Separated master/layout (template) elements, merged back at save time. */
+    templateElementsBySlideId: Record<string, P[]>;
+    filePath: string | undefined;
+    handlerRef: RefObject<PptxHandler | null>;
+    serializeSlides: () => Promise<Uint8Array | null>;
+    headerFooter: Record<string, unknown>;
+    presentationProperties: Record<string, unknown>;
+    customShows: Array<{
+        id: string;
+        name: string;
+        slideRIds: string[];
+    }>;
+    sections: Array<{
+        id: string;
+        name: string;
+        color?: string;
+        collapsed?: boolean;
+    }>;
+    coreProperties: Record<string, unknown> | null;
+    appProperties: Record<string, unknown> | null;
+    customProperties: Array<Record<string, unknown>>;
+    notesMaster: Record<string, unknown> | undefined;
+    handoutMaster: Record<string, unknown> | undefined;
+    guides: Array<{
+        id: string;
+        axis: 'h' | 'v';
+        position: number;
+    }>;
+    activeSlideIndexForGuides: number;
+    modalControls: ExportModalControls;
+    password?: string;
+}
+interface ExportSaveAsResult {
+    handlePackageForSharing: () => Promise<void>;
+    handleSaveAsFormat: (format: PptxSaveFormat) => Promise<void>;
+    handleSaveAsPptx: () => void;
+    handleSaveAsPpsx: () => void;
+    handleSaveAsPptm: () => void;
+}
+declare function useExportSaveAs(input: UseExportSaveAsInput): ExportSaveAsResult;
+
+interface UseFontInjectionInput {
+    embeddedFonts: K[];
+    slides: l[];
+}
+declare function useFontInjection({ embeddedFonts, slides }: UseFontInjectionInput): void;
+
+/**
+ * useGroupAlignLayerHandlers: Group/ungroup, flip, alignment,
+ * layer-order, and merge shapes handlers extracted from useElementManipulation.
+ */
+
+interface GroupAlignLayerInput {
+    activeSlide: l | undefined;
+    activeSlideIndex: number;
+    selectedElement: P | null;
+    effectiveSelectedIds: string[];
+    selectedElements: P[];
+    elementLookup: Map<string, P>;
+    setSelectedElementIds: React.Dispatch<React.SetStateAction<string[]>>;
+    ops: ElementOperations;
+    history: EditorHistoryResult;
+}
+declare function useGroupAlignLayerHandlers(input: GroupAlignLayerInput): GroupAlignLayerHandlers;
+
+interface UseKeyboardShortcutsInput {
+    /** Container element ref: used to scope the listener. */
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    mode: ViewerMode;
+    canEdit: boolean;
+    /** Whether any element is currently being inline-edited (text box). */
+    inlineEditingElementId: string | null;
+    /** Whether a table cell is being edited. */
+    tableEditorState: TableCellEditorState | null;
+    /** Current drawing tool: shortcuts are suppressed when drawing. */
+    activeTool: DrawingTool;
+    /** Whether at least one element is selected. */
+    hasSelection: boolean;
+    /** The IDs of the currently selected elements (effective). */
+    effectiveSelectedIds: string[];
+    onDelete: () => void;
+    onCopy: () => void;
+    onCut: () => void;
+    onPaste: () => void;
+    onDuplicate: () => void;
+    onUndo: () => void;
+    onRedo: () => void;
+    onSelectAll: () => void;
+    onEscape: () => void;
+    /** Move selected elements by (dx, dy). */
+    onNudge: (dx: number, dy: number) => void;
+    /** Navigate to previous visible slide (edit mode, no selection). */
+    onPrevSlide?: () => void;
+    /** Navigate to next visible slide (edit mode, no selection). */
+    onNextSlide?: () => void;
+}
+declare function useKeyboardShortcuts(input: UseKeyboardShortcutsInput): void;
+
+/** Input for the merge shapes handler. */
+interface MergeShapesHandlerInput {
+    activeSlide: l | undefined;
+    activeSlideIndex: number;
+    selectedElements: P[];
+    effectiveSelectedIds: string[];
+    setSelectedElementIds: React.Dispatch<React.SetStateAction<string[]>>;
+    ops: ElementOperations;
+    history: EditorHistoryResult;
+}
+/** Handlers returned by the merge shapes hook. */
+interface MergeShapesHandlers {
+    handleMergeShapes: (operation: MergeShapeOperation) => void;
+    canMergeShapes: boolean;
+}
+declare function useMergeShapesHandler(input: MergeShapesHandlerInput): MergeShapesHandlers;
+
+interface ResizablePanelSizes {
+    leftWidth: number;
+    rightWidth: number;
+    bottomHeight: number;
+}
+interface UseResizablePanelsResult extends ResizablePanelSizes {
+    onResizeLeft: (delta: number) => void;
+    onResizeRight: (delta: number) => void;
+    onResizeBottom: (delta: number) => void;
+}
+declare function useResizablePanels(): UseResizablePanelsResult;
+
+interface UseSwipeNavigationInput {
+    /** Whether swipe navigation is active. */
+    enabled: boolean;
+    /** Advance to the next slide (swipe left). */
+    onNext: () => void;
+    /** Go to the previous slide (swipe right). */
+    onPrev: () => void;
+}
+interface UseSwipeNavigationResult {
+    onTouchStart: (e: React__default.TouchEvent) => void;
+    onTouchEnd: (e: React__default.TouchEvent) => void;
+}
+declare function useSwipeNavigation(input: UseSwipeNavigationInput): UseSwipeNavigationResult;
+
+interface UseAnimationPlaybackInput {
+    slides: l[];
+    onPlayActionSound?: (soundPath: string) => void;
+    /** When false, all animations are skipped (elements shown immediately). */
+    showWithAnimation?: boolean;
+}
+interface UseAnimationPlaybackResult {
+    presentationAnimations: PresentationAnimationRuntime[];
+    presentationElementStates: Map<string, ElementAnimationState>;
+    presentationKeyframesCss: string;
+    interactiveTriggerShapeIds: ReadonlySet<string>;
+    hoverTriggerShapeIds: ReadonlySet<string>;
+    clearPresentationTimers: () => void;
+    playNextAnimationGroup: () => boolean;
+    handleInteractiveShapeClick: (shapeId: string) => boolean;
+    handleHoverStart: (shapeId: string) => boolean;
+    handleHoverEnd: (shapeId: string) => void;
+    runPresentationEntranceAnimations: (slideIndex: number) => void;
+    /** Exposed so the orchestrator can schedule additional timers (e.g. auto-advance). */
+    presentationTimersRef: React.RefObject<number[]>;
+}
+declare function useAnimationPlayback(input: UseAnimationPlaybackInput): UseAnimationPlaybackResult;
+
+interface UseRehearsalTimingsInput {
+    containerRef: React.RefObject<HTMLElement | null>;
+    onSetMode: (mode: ViewerMode) => void;
+    onSaveRehearsalTimings?: (timings: Record<number, number>) => void;
+    setPresentationStartTime: (time: number | null) => void;
+    setPresenterMode: (mode: boolean) => void;
+}
+interface UseRehearsalTimingsResult {
+    rehearsing: boolean;
+    setRehearsing: React.Dispatch<React.SetStateAction<boolean>>;
+    recordedTimings: Record<number, number>;
+    slideStartTime: number | null;
+    showRehearsalSummary: boolean;
+    setShowRehearsalSummary: React.Dispatch<React.SetStateAction<boolean>>;
+    rehearsalPaused: boolean;
+    recordCurrentSlideTime: (slideIndex: number) => void;
+    dismissRehearsalSummary: () => void;
+    saveRehearsalTimings: () => void;
+    enterRehearsalMode: () => void;
+    toggleRehearsalPause: () => void;
+}
+declare function useRehearsalTimings(input: UseRehearsalTimingsInput): UseRehearsalTimingsResult;
+
+interface UsePresentationKeyboardInput {
+    mode: ViewerMode;
+    movePresentationSlide: (direction: 1 | -1) => void;
+    onSetMode: (mode: ViewerMode) => void;
+    onToggleLaser?: () => void;
+    onTogglePen?: () => void;
+    onToggleEraser?: () => void;
+    onToggleToolbar?: () => void;
+    /** Toggle between presenter view (split-screen with notes) and fullscreen. */
+    onTogglePresenterView?: () => void;
+    rehearsing: boolean;
+    recordCurrentSlideTime: (slideIndex: number) => void;
+    presentationSlideIndex: number;
+    setShowRehearsalSummary: (value: boolean) => void;
+}
+/**
+ * Registers keyboard shortcuts for presentation mode: arrow/space
+ * for slide navigation, Escape to exit, and annotation tool toggles.
+ */
+declare function usePresentationKeyboard(input: UsePresentationKeyboardInput): void;
+
+interface UseSlideNavigationInput {
+    slides: l[];
+    visibleSlideIndexes: number[];
+    presentationSlideIndex: number;
+    setPresentationSlideIndex: (index: number) => void;
+    setPresentationSlideVisible: (visible: boolean) => void;
+    setTransitionOverlay: (state: PresentationTransitionOverlayState | null) => void;
+    onSetMode: (mode: ViewerMode) => void;
+    onSetActiveSlideIndex: (index: number) => void;
+    onPlayActionSound?: (soundPath: string) => void;
+    loopContinuously?: boolean;
+    /** Whether to use rehearsed auto-advance timings. When false, slides advance only on click. */
+    useTimings?: boolean;
+    playNextAnimationGroup: () => boolean;
+    clearPresentationTimers: () => void;
+    runPresentationEntranceAnimations: (slideIndex: number) => void;
+    presentationTimersRef: {
+        current: number[];
+    };
+    rehearsing: boolean;
+    recordCurrentSlideTime: (slideIndex: number) => void;
+    setShowRehearsalSummary: (value: boolean) => void;
+}
+interface UseSlideNavigationResult {
+    movePresentationSlide: (direction: 1 | -1) => void;
+    navigateToSlide: (slideIndex: number) => void;
+    handlePresentationAction: (action: a2) => void;
+    scheduleAutoAdvanceForSlide: (slideIndex: number) => void;
+}
+declare function useSlideNavigation(input: UseSlideNavigationInput): UseSlideNavigationResult;
+
+/**
+ * Input for the useZoomNavigation sub-hook.
+ */
+interface UseZoomNavigationInput {
+    /** Navigate to a specific slide index. */
+    navigateToSlide: (slideIndex: number) => void;
+}
+/**
+ * Return type for the useZoomNavigation sub-hook.
+ */
+interface UseZoomNavigationResult {
+    /**
+     * Handle a zoom element click. Navigates to the target slide and
+     * stores the return slide index so we can go back later.
+     */
+    handleZoomClick: (targetSlideIndex: number, returnSlideIndex: number) => void;
+    /**
+     * The slide index to return to after a zoom navigation, or `null` if
+     * there is no pending return.
+     */
+    zoomReturnSlideIndex: React.RefObject<number | null>;
+    /**
+     * Navigate back to the zoom summary slide (if a return index is set).
+     * Returns `true` if navigation occurred, `false` otherwise.
+     */
+    returnToZoomSlide: () => boolean;
+    /**
+     * Clear the stored return index (e.g. when the user manually navigates
+     * away from the zoomed section).
+     */
+    clearZoomReturn: () => void;
+}
+/**
+ * Sub-hook that manages zoom element navigation in presentation mode.
+ *
+ * When a zoom element is clicked, this hook:
+ * 1. Navigates to the target slide
+ * 2. Stores the "return" slide index
+ *
+ * The caller can later use `returnToZoomSlide()` to navigate back to
+ * the summary zoom slide.
+ */
+declare function useZoomNavigation(input: UseZoomNavigationInput): UseZoomNavigationResult;
+
+interface UseAudienceModeInput {
+    mode: ViewerMode;
+    onSetMode: (mode: ViewerMode) => void;
+    onSetActiveSlideIndex: (index: number) => void;
+    containerRef: React.RefObject<HTMLElement | null>;
+}
+/**
+ * When the page was opened with the `#pptx-audience` hash, this hook:
+ * 1. Auto-enters fullscreen presentation mode after content loads
+ * 2. Listens on BroadcastChannel for slide-change messages from the presenter
+ * 3. Exits presentation mode when the presenter sends an exit signal
+ */
+declare function useAudienceMode(input: UseAudienceModeInput): void;
+
+export { type AnnotationHandlersResult, type AnnotationStroke, type AutosaveStatus, type CanvasInteractionHandlers, CollaborationConfig, CollaborationContextValue, type ContentLifecycleResult, type DerivedElementState, type DerivedSlideState, DeviceOrientation, type EditorHistoryInput, type EditorHistoryResult, type EditorOperationsResult, type ElementManipulationHandlers, type ElementOperations, type ExportHandlersResult, type ExportSaveAsResult, type IOHandlersResult, type InsertElementHandlers, type LayoutSwitchingResult, MIN_TOUCH_TARGET, type MergeShapesHandlerInput, type MergeShapesHandlers, type ModalDismissDrag, type ModalDismissDragHandlers, type PresentationSetupResult, type PresentationTool, type PrintHandlersResult, type PropertyHandlersResult, type SectionOperations, type SheetDismissDrag, type SheetDismissDragHandlers, type SlideManagementHandlers, type TableOperationHandlers, type ThemeHandlersResult, TouchGestureCallbacks, type UseAnimationPlaybackInput, type UseAnimationPlaybackResult, type UseAnnotationHandlersInput, type UseAutosaveInput, type UseAutosaveResult, type UseBroadcastFollowerInput, type UseCanvasInteractionsInput, type UseContentLifecycleInput, type UseDerivedElementStateInput, type UseDerivedSlideStateInput, type UseDialogCustomShowsInput, type UseDialogCustomShowsResult, type UseEditorOperationsInput, type UseElementManipulationInput, type UseElementOperationsInput, type UseExportHandlersInput, type UseExportSaveAsInput, type UseFollowModeInput, type UseFollowModeResult, type UseFontInjectionInput, type UseIOHandlersInput, type UseInsertElementsInput, type UseIsMobileInput, type UseIsMobileResult, type UseKeyboardInsetsResult, type UseKeyboardShortcutWiringInput, type UseKeyboardShortcutsInput, type UseLayoutSwitchingInput, type UseLoadContentInput, type UseLoadContentResult, type UsePointerHandlersInput, type UsePresentationAnnotationsResult, type UsePresentationSetupInput, type UsePrintHandlersInput, type UsePropertyHandlersInput, type UseRecoveryDetectionInput, type UseReducedMotionResult, type UseRehearsalTimingsInput, type UseRehearsalTimingsResult, type UseResizablePanelsResult, type UseSectionOperationsInput, type UseSerializeInput, type UseSlideManagementInput, type UseSlideNavigationInput, type UseSlideNavigationResult, type UseSwipeNavigationInput, type UseSwipeNavigationResult, type UseTableOperationsInput, type UseThemeHandlersInput, type UseTouchGesturesInput, type UseViewerCoreStateInput, type UseViewerDialogsInput, type UseViewerIntegrationInput, type UseViewerStateInput, type UseYjsDocumentSyncInput, type UseZoomNavigationInput, type UseZoomNavigationResult, type ViewerCoreState, type ViewerDialogsResult, type ViewerIntegrationResult, type ViewerState, type ViewerUIState, type VirtualizedRange, type VirtualizedSlidesOptions, type VirtualizedSlidesResult, computeVirtualRange, useAnimationPlayback, useAnnotationHandlers, useAudienceMode, useAutosave, useBroadcastFollower, useCanvasInteractions, useClipboardHandlers, useComments, useContentLifecycle, useDerivedElementState, useDerivedSlideState, useDialogCustomShows, useEditorHistory, useEditorOperations, useElementManipulation, useElementOperations, useExportHandlers, useExportSaveAs, useFindReplace, useFollowMode, useFontInjection, useGroupAlignLayerHandlers, useIOHandlers, useInsertElements, useIsMobile, useKeyboardInsets, useKeyboardShortcutWiring, useKeyboardShortcuts, useLayoutSwitching, useLoadContent, useMergeShapesHandler, useModalDismissDrag, usePointerHandlers, usePresentationAnnotations, usePresentationKeyboard, usePresentationMode, usePresentationSetup, usePrintHandlers, usePropertyHandlers, useRecoveryDetection, useReducedMotion, useRehearsalTimings, useResizablePanels, useSectionOperations, useSerialize, useSheetDismissDrag, useSlideManagement, useSlideNavigation, useSwipeNavigation, useTableOperations, useThemeHandlers, useTouchGestures, useViewerCoreState, useViewerDialogs, useViewerIntegration, useViewerState, useViewerUIState, useVirtualizedSlides, useYjsDocumentSync, useZoomNavigation, useZoomViewport };