pptx-react-viewer 4.74.0 → 4.75.0

package/dist/no-i18next.d.ts

@@ -0,0 +1,1299 @@
+import * as ooxml_ui_pptx from 'ooxml-ui/pptx';
+import { CollaborationRole, CollaborationConfig, ViewportFitOptions, ViewerFontSource, CanvasSize, DocumentStorage, CloudFileProvider, ViewerAutosaveStatus, AutosaveRecord, ConnectionStatus, ViewerTheme, ThemeCatalogEntry, AccountAuthConfig, CollaborationInput, GoogleFontsOption, ListConversionScope, ToolbarActionId, RibbonAddInTab, ViewerCustomization, PptxLoadLimits, PowerPointViewerAPI, ViewerCustomizationApi, CollaborationLivePatcher, InlineListReadResult, EditorImagePasteOptions, ViewerMode, RulerUnit, ElementAnimationState, ShapeAdjustmentHandleDescriptor, InlineTextEditSnapshot, ZoomNavigationTarget, FieldSubstitutionContext, EditPointsCommandId, EditPointsElementPatch, FreeformToolKind, ElementClipboardPayload, AnimationApplyGroup, InsertChartKind, ChangeCaseMode, SlideTemplateId, ReviewCommentsHost, SlidesPaneLayoutGalleryRequest, CollaborationShellState, PptxAutosaveStatus } from 'ooxml-ui/pptx';
+export { AVATAR_COLOR_SWATCHES, AccountAuthConfig, BACKSTAGE_CARD_IDS, BACKSTAGE_PAGE_IDS, BackstageCustomization, CANVAS_CONTEXT_MENU_COMMAND_IDS, CollaborationConfig, CollaborationShellState, ContextMenuCustomization, DEFAULT_VIEWER_PROFILE, EDITOR_SHORTCUT_ACTION_IDS, ELEMENT_CONTEXT_MENU_COMMAND_IDS, ElementUpdate, ElementUpdateOptions, ExternalCollaborationAwareness, ExternalCollaborationSession, ExternalCollaborationSnapshot, HostCanvasMenuContext, HostElementMenuContext, HostMenuCommand, KeyboardCustomization, ListConversionScope, LocalStorageUsageSummary, OPTIONS_PAGE_IDS, OPTIONS_SECTION_IDS, OPTIONS_SETTING_IDS, OptionsCustomization, OptionsPageId, OptionsSectionId, OptionsSettingId, OptionsSettingValues, PPTX_OPEN_ACCEPT, PRESENTATION_OPEN_EXTENSIONS, PowerPointViewerAPI, RIBBON_TAB_IDS, ResolvedCustomization, RibbonCustomization, SLIDE_TEMPLATES, SavedPresentationFormat, ShortcutChord, SlideTemplateId, SlideTemplateSpec, SlidesPaneLayoutGalleryRequest, StoredViewerPrefs, THEME_CATALOG, TOOLBAR_BUTTON_IDS, ThemeCatalogEntry, ToolbarActionId, ToolbarButtonId, ToolbarTabId, VIEWER_DIALOG_IDS, VIEWER_EXPORT_FORMAT_IDS, VIEWER_FEATURE_IDS, VIEWER_PANEL_IDS, VIEWER_PREFS_STORAGE_KEY, ViewerCustomization, ViewerCustomizationApi, ViewerDialogId, ViewerExportFormatId, ViewerFeatureId, ViewerMode, ViewerPanelId, ViewerProfile, ViewerTheme, ViewerThemeColors, ViewportFitOptions, ViewportFitPadding, buildSlideTemplateContent, buildSlideTemplateSlide, clearAllLocalViewerData, clearStoredViewerPrefs, createImageElementFromFile, defaultCssVars, defaultRadius, defaultThemeColors, describeCollaborationShellState, getLocalStorageUsageSummary, isLegacyBinaryPresentation, isSupportedPresentationFile, presentationBaseName, readStoredViewerPrefs, resolveProfileInitial, resolveThemeCatalogEntry, saveViewerProfile, savedPresentationFileName, themeToCssVars, vermilionDarkColors, vermilionDarkTheme, vermilionLightColors, vermilionLightTheme, vermilionRadius, writeStoredViewerPrefs } from 'ooxml-ui/pptx';
+import * as React$1 from 'react';
+import React$1__default, { ReactNode, ReactElement } from 'react';
+import { PptxCoreProperties, PptxAnimationPreset, PptxNativeAnimation, PptxSlide, PptxElement, TextStyle, InkPptxElement, ShapePptxElement, PptxAction, PptxComment, PptxElementAnimation, ConnectorPptxElement, ParsedTableStyleMap, PptxTheme, ShapeStyle, PptxLayoutOption, PptxLayoutPreview, PptxCustomShow, PptxSlideTransition, PptxPresentationProperties } from 'ooxml-core/pptx';
+import { CollaborationWriteBackState, CollaborationState } from 'ooxml-core/collab';
+export { CollaborationState } from 'ooxml-core/collab';
+import { PptxAiConfig } from 'ooxml-ui/pptx/ai';
+export { PptxAiBridge, PptxAiConfig, PptxAiConnection, PptxAiContextStrategy, PptxAiToolName, PptxAiWritePolicy } from 'ooxml-ui/pptx/ai';
+import { PptxAiAssistant } from 'ooxml-ui/pptx/ai/host';
+export { PptxAiAssistant } from 'ooxml-ui/pptx/ai/host';
+import { LocaleCatalogEntry } from 'ooxml-ui/pptx/i18n';
+export { LOCALE_CATALOG, LocaleCatalogEntry } from 'ooxml-ui/pptx/i18n';
+import { Doc } from 'yjs';
+import { Options } from 'html2canvas-pro';
+
+/** What the viewer passes `translate`: exactly the params of the call. */
+interface PptxTranslateParams {
+  readonly defaultValue?: string;
+  readonly count?: number;
+  readonly [name: string]: unknown;
+}
+/**
+ * A host translator for {@link PptxI18nProvider}: the text for a viewer key (`pptx.*`) in the
+ * host's active language. Return the key itself, an empty string, `null` or `undefined` for "no
+ * translation": the viewer then shows its built-in English text.
+ */
+type PptxTranslate = (key: string, params?: PptxTranslateParams) => string | null | undefined;
+/**
+ * Union of all shape preset types that the viewer can insert or render.
+ * Maps to OOXML `a:prstGeom` preset values (e.g. "rect", "ellipse").
+ * Includes basic shapes, arrows, connectors, and freeform paths.
+ */
+type SupportedShapeType = 'rect' | 'roundRect' | 'ellipse' | 'triangle' | 'rtTriangle' | 'diamond' | 'cylinder' | 'parallelogram' | 'trapezoid' | 'pentagon' | 'hexagon' | 'octagon' | 'chevron' | 'star5' | 'star6' | 'star8' | 'plus' | 'heart' | 'cloud' | 'sun' | 'moon' | 'pie' | 'plaque' | 'teardrop' | 'line' | 'rtArrow' | 'leftArrow' | 'upArrow' | 'downArrow' | 'connector' | 'freeform';
+/** The pixel dimensions of the slide canvas (presentation slide size). */
+interface CanvasSize$1 {
+  /** Width of the canvas in CSS pixels. */
+  width: number;
+  /** Height of the canvas in CSS pixels. */
+  height: number;
+}
+interface ViewerThemeProviderProps {
+  theme?: ViewerTheme;
+  children: React.ReactNode;
+}
+/**
+ * Provides a `ViewerTheme` to all descendant viewer components.
+ *
+ * Typically you do **not** need to use this directly; passing a `theme`
+ * prop to `<PowerPointViewer>` is sufficient. This provider is exposed
+ * for advanced use-cases where you want to wrap multiple viewers or
+ * share a theme across a wider subtree.
+ */
+declare function ViewerThemeProvider({ theme, children }: ViewerThemeProviderProps): React$1.JSX.Element;
+/**
+ * Returns the active `ViewerTheme` (if any) from the nearest
+ * `ViewerThemeProvider`.
+ */
+declare function useViewerTheme(): ViewerTheme | undefined;
+/** Connection lifecycle states for the Yjs WebSocket provider. */
+type ConnectionStatus$1 = 'disconnected' | 'connecting' | 'connected' | 'error';
+/**
+ * Presence data broadcast to other participants.
+ * Cursor position is relative to the slide canvas (0..canvasWidth, 0..canvasHeight).
+ */
+interface UserPresence {
+  /** Unique client ID (assigned by Yjs awareness). */
+  clientId: number;
+  /** Sanitised display name. */
+  userName: string;
+  /** Optional avatar URL (validated). */
+  userAvatar?: string;
+  /** Hex colour for the user's cursor ring. */
+  userColor: string;
+  /** Slide index the user is currently viewing. */
+  activeSlideIndex: number;
+  /** Cursor X on the canvas (clamped to slide bounds). */
+  cursorX: number;
+  /** Cursor Y on the canvas (clamped to slide bounds). */
+  cursorY: number;
+  /** ISO timestamp of last update (for stale-presence cleanup). */
+  lastUpdated: string;
+  /** Optional currently selected element ID. */
+  selectedElementId?: string;
+  /** Role in the session (owner, viewer, or collaborator). */
+  role?: CollaborationRole;
+}
+/** Value exposed by `CollaborationContext`. */
+interface CollaborationContextValue {
+  /** Current WebSocket connection status. */
+  status: ConnectionStatus$1;
+  /** Presence data for all remote users (excludes the local user). */
+  remoteUsers: UserPresence[];
+  /** Broadcast the local user's presence state. */
+  broadcastPresence: (update: Partial<Omit<UserPresence, 'clientId'>>) => void;
+  /** Total number of connected users (including local). */
+  connectedCount: number;
+  /** The collaboration config that was provided. */
+  config: CollaborationConfig;
+  /** The Yjs document (for document sync). */
+  doc: Doc | null;
+  /**
+   * Whether the provider completed its initial document sync (or the
+   * first-write grace period elapsed). Local doc writes are gated on this.
+   */
+  synced: boolean;
+  /** Manually retry the WebSocket connection after a timeout or error. */
+  retry: () => void;
+  /** The local awareness client id, once the session has one. */
+  clientId?: number | null;
+  /** The owner's write-back status, as the document sync last reported it. */
+  writeBack?: CollaborationWriteBackState | undefined;
+  /** Called by the document sync with the write-back status (undefined clears it). */
+  reportWriteBack?: (state: CollaborationWriteBackState | undefined) => void;
+}
+/** What `onLoad` reports: the same detail the Svelte and vanilla bindings send. */
+interface ViewerLoadDetail {
+  slideCount: number;
+  canvasSize: CanvasSize;
+}
+/**
+ * Base handle interface for file viewer components.
+ * Defined locally to avoid dependency on external file-viewer plugin packages.
+ * Provides a standard `getContent` method used by the host application to
+ * retrieve the current file content (e.g. for saving).
+ */
+interface FileViewerHandle {
+  /** Get the current content of the file (for saving) */
+  getContent: () => Promise<string | Uint8Array>;
+}
+/**
+ * State of an active marquee (rubber-band) selection rectangle.
+ * Created when the user clicks and drags on the canvas background,
+ * and used to compute which elements fall within the selection area.
+ */
+interface MarqueeSelectionState {
+  startX: number;
+  startY: number;
+  currentX: number;
+  currentY: number;
+  additive: boolean;
+  baseSelectionIds?: string[];
+}
+/** Tracks which table cell is selected and/or actively being edited. */
+interface TableCellEditorState {
+  rowIndex: number;
+  columnIndex: number;
+  /** When true the cell has an active text input. */
+  isEditing?: boolean;
+  /** Optional multi-cell selection (Shift+Click range). Each entry is {row, col}. */
+  selectedCells?: Array<{
+    row: number;
+    col: number;
+  }>;
+}
+/**
+ * Groups slides into named sections for the slides pane sidebar.
+ * Corresponds to OOXML `p15:section` elements in `presentation.xml`.
+ */
+interface SlideSectionGroup {
+  id: string;
+  label: string;
+  slideIndexes: number[];
+  /** Section highlight color from p15:sectionPr. */
+  color?: string;
+  /** Whether the section should start collapsed (from p15:sectionPr). */
+  defaultCollapsed?: boolean;
+}
+/** Identifies one of the ribbon-style toolbar tabs (home, insert, text, etc.). */
+type ToolbarSection = 'file' | 'home' | 'insert' | 'text' | 'arrange' | 'draw' | 'design' | 'transitions' | 'animations' | 'slideShow' | 'record' | 'review' | 'view' | 'help';
+/** The active drawing/inking tool selected in the Draw toolbar tab. */
+type DrawingTool = 'select' | 'pen' | 'highlighter' | 'eraser' | 'freeform';
+interface PowerPointViewerProps extends ViewportFitOptions {
+  /** PowerPoint content as Uint8Array */
+  content: Uint8Array;
+  /** Licensed fonts supplied by the host application. No fonts are bundled. */
+  fonts?: ViewerFontSource[];
+  /** Original file path, used for autosave recovery */
+  filePath?: string;
+  /**
+   * Display name of the open document, shown in the PowerPoint-style title
+   * bar (e.g. "quarterly-review.pptx"). Falls back to a generic label.
+   */
+  fileName?: string;
+  /** Callback when content has unsaved changes */
+  onDirtyChange?: (isDirty: boolean) => void;
+  onContentChange?: (content: Uint8Array) => void;
+  /** Callback when active slide changes */
+  onActiveSlideChange?: (slideIndex: number) => void;
+  /** Fired before following a link; return false to cancel its default action. */
+  onHyperlinkClick?: ooxml_ui_pptx.HyperlinkClickHandler;
+  /** Callback when the viewer mode changes (e.g. edit to present). */
+  onModeChange?: (mode: ooxml_ui_pptx.ViewerMode) => void;
+  /** Callback when the zoom level changes. */
+  onZoomChange?: (zoom: number) => void;
+  /** Callback when element selection changes. */
+  onSelectionChange?: (elementIds: string[]) => void;
+  /** Callback when the total slide count changes (slide added/deleted). */
+  onSlideCountChange?: (count: number) => void;
+  /**
+   * Fired each time a presentation finishes loading without an error, with the slide count
+   * and canvas size.
+   */
+  onLoad?: (detail: ViewerLoadDetail) => void;
+  /** Fired once per distinct load failure, and for each failed Save / Save As, with a human-readable message. */
+  onError?: (message: string) => void;
+  /**
+   * Host override for the File ▸ Open action. When provided, the built-in
+   * native file picker is bypassed and this is invoked instead; the host is
+   * then responsible for supplying a new `content` buffer. When omitted, the
+   * viewer opens its own picker and loads the chosen presentation in place.
+   */
+  onOpenFile?: () => void;
+  /** Whether editing actions are enabled */
+  canEdit?: boolean;
+  /**
+   * Makes the deck read-only (default `false`). It is the inverse of the edit switch: true wins
+   * over it, false only lifts this restriction, so editing still needs the edit switch and
+   * is never granted over a collaboration `viewer` role or `capabilities.edit`.
+   */
+  readOnly?: boolean;
+  /**
+   * Recovery autosave: after an edit the deck is re-serialised (always as a
+   * plain, unencrypted package, because recovery has no password) and stashed
+   * in the shared IndexedDB store keyed by {@link filePath}. It is a crash-
+   * safety net and never replaces the user's real Save: the document stays
+   * dirty. On load, a newer snapshot is offered back through a recovery prompt.
+   *
+   * **The prop is a policy ceiling; the title-bar AutoSave toggle is the user's
+   * preference inside it.** `false` turns autosave off and makes the toggle
+   * inert (a user cannot switch on what the application forbade). `true` or
+   * omitted permits it, and the toggle decides, defaulting to on. Identical in
+   * all five bindings; see `resolveAutosaveActivation` in `pptx-viewer-shared`.
+   *
+   * @default true
+   */
+  autosave?: boolean;
+  /**
+   * Recovery cadence in milliseconds. An explicit value is a host policy and is
+   * honoured as given; omit it to follow the user's File > Options > Save >
+   * "Save AutoRecover information every N minutes" (two minutes by default).
+   */
+  autosaveIntervalMs?: number;
+  /**
+   * Host-owned storage (`DocumentStorage` from `ooxml-core/embedding`). When set,
+   * Save and Save As hand the bytes to `storage.save()` instead of downloading
+   * them, and recovery autosave snapshots go to the storage's recovery methods
+   * (`readRecovery` / `writeRecovery` / `clearRecovery`) instead of IndexedDB
+   * when it provides them.
+   */
+  storage?: DocumentStorage;
+  /**
+   * Cloud places for File > Open (OneDrive through `createOneDriveFileProvider` from
+   * `ooxml-core/embedding/onedrive`, or a provider of your own). When non-empty, the Open page
+   * lists "This device" and one place per provider. A file opened from a place loads like a
+   * normal open (read-only when the service does not allow editing, or when `canEdit` /
+   * `readOnly` already forbid it); File > Save, Save As and recovery of that document go to the
+   * file's own storage instead of `storage`, until another document is loaded.
+   */
+  fileProviders?: readonly CloudFileProvider[];
+  /** Fired with the serialised deck each time a recovery autosave snapshot is written. */
+  onAutosave?: (content: Uint8Array) => void;
+  /** Fired when the user enables or disables autosave (title bar or File > Options). */
+  onAutosaveToggle?: (enabled: boolean) => void;
+  /** Fired on every autosave lifecycle transition (`idle`, `saving`, `saved`, `error`). */
+  onAutosaveStatus?: (status: ViewerAutosaveStatus) => void;
+  /**
+   * Fired when a recovery snapshot left by a previous session is found for this deck. The
+   * built-in recovery prompt is shown as well.
+   */
+  onAutosaveRecovery?: (record: AutosaveRecord) => void;
+  /** Fired after any committed document edit (move, resize, text, undo, redo, ...). */
+  onChange?: () => void;
+  /** Fired with the changed fields when the user saves the document properties dialog. */
+  onPropertiesChange?: (updates: Partial<PptxCoreProperties>) => void;
+  /** Fired with the new speaker-notes text when the user edits the notes of a slide. */
+  onNotesUpdate?: (notes: string) => void;
+  /** Fired when presentation (slide show) mode is entered (`true`) or left (`false`). */
+  onPresentationChange?: (presenting: boolean) => void;
+  /** Fired on every collaboration connection-status transition. */
+  onCollaborationStatus?: (status: ConnectionStatus) => void;
+  /** Optional class name */
+  className?: string;
+  /**
+   * Display name used as the author for comments and annotations.
+   * Falls back to `collaboration.userName` when collaborating, or `'You'`.
+   */
+  authorName?: string;
+  /**
+   * Theme configuration for customising the viewer's appearance.
+   *
+   * Accepts partial color overrides, a custom border-radius, and
+   * arbitrary CSS custom properties. Unset values fall back to the
+   * built-in dark theme.
+   *
+   * @example
+   * ```tsx
+   * <PowerPointViewer
+   *   content={bytes}
+   *   theme={{
+   *     colors: { primary: "#6366f1", background: "#0f172a" },
+   *     radius: "0.75rem",
+   *   }}
+   * />
+   * ```
+   *
+   * @see {@link ViewerTheme} for the full type definition.
+   */
+  theme?: ViewerTheme;
+  /**
+   * Initial key into `availableThemes` (or the built-in `THEME_CATALOG`) for
+   * File > Options > Appearance. Ignored once the user picks a different
+   * entry in that session, and always overridden by the `theme` prop when
+   * both are supplied. Falls back to a persisted `localStorage` choice, then
+   * `'default'`.
+   */
+  defaultThemeKey?: string;
+  /**
+   * Theme choices offered by File > Options > Appearance. Defaults to the
+   * shared `THEME_CATALOG` (default/light/vermilionLight/vermilionDark).
+   */
+  availableThemes?: ThemeCatalogEntry[];
+  /**
+   * Called when the user picks a theme from File > Options > Appearance.
+   * When provided, the host owns persisting the choice (the viewer will not
+   * also write it to `localStorage`); otherwise the viewer persists it via
+   * the shared `writeStoredViewerPrefs` helper.
+   */
+  onThemeChange?: (key: string) => void;
+  /**
+   * Initial locale code for File > Options > Language. Falls back to a persisted `localStorage`
+   * choice, then `'en'`. Ignored inside a `PptxI18nProvider`, whose `locale` is the language.
+   * Without a provider it applies only while the viewer reads a configured react-i18next
+   * instance; with neither (for example `pptx-react-viewer/no-i18next` on its own) the viewer
+   * shows its built-in English text and ignores it.
+   */
+  defaultLocale?: string;
+  /**
+   * Locale choices offered by File > Options > Language. Without a provider they default to the
+   * codes registered on the host's `react-i18next` instance, and have no effect when the viewer
+   * reads no configured instance (see `defaultLocale`). Inside a `PptxI18nProvider` there is no
+   * default: pass two or more, together with `onLocaleChange`, to show the Language category.
+   */
+  availableLocales?: LocaleCatalogEntry[];
+  /**
+   * Called when the user picks a language from File > Options > Language. When provided, the
+   * host owns applying and persisting the choice; otherwise the viewer applies and persists it
+   * itself. Inside a `PptxI18nProvider` the host always owns the language: without this callback
+   * the Language category is left out. Without a provider, when the viewer reads no configured
+   * react-i18next instance (see `defaultLocale`), the Language category is left out and this is
+   * never called.
+   */
+  onLocaleChange?: (code: string) => void;
+  /**
+   * Optional hook point for File > Account's sign-in section. Disabled by
+   * default (renders nothing extra); pass `{ enabled: true, onSignIn }` to
+   * surface a real sign-in flow.
+   */
+  accountAuth?: AccountAuthConfig;
+  /**
+   * Optional real-time collaboration configuration.
+   *
+   * When provided, the viewer enables collaborative editing with live
+   * cursors, user presence indicators, and CRDT-based state sync via Yjs.
+   * Requires `yjs` and `y-websocket` peer dependencies.
+   *
+   * @example
+   * ```tsx
+   * <PowerPointViewer
+   *   content={bytes}
+   *   collaboration={{
+   *     roomId: "my-room-123",
+   *     serverUrl: "wss://collab.example.com",
+   *     userName: "Alice",
+   *     userColor: "#6366f1",
+   *   }}
+   * />
+   * ```
+   */
+  collaboration?: CollaborationInput;
+  /**
+   * Callback invoked when the user starts a collaboration session from the
+   * Share dialog. The host app should use this to set the `collaboration`
+   * prop with the returned config.
+   */
+  onStartCollaboration?: (config: CollaborationConfig) => void;
+  /**
+   * Callback invoked when the user stops a collaboration session from the
+   * Share dialog. The host app should clear the `collaboration` prop.
+   */
+  onStopCollaboration?: () => void;
+  /**
+   * Reports the shared `CollaborationState` (the contract Word, Excel and Visio
+   * use): called when a session starts or stops (the off state), and when its
+   * connection status, synced flag or people change. Works for viewer-owned and
+   * host-owned (`collaboration.session`) sessions; unchanged states are not repeated.
+   */
+  onCollaborationChange?: (state: CollaborationState) => void;
+  /**
+   * Default values for the Share dialog fields. The host app should provide
+   * these to control the session name, user display name, and server URL.
+   * If omitted, the Share dialog fields will be empty and require user input.
+   *
+   * @example
+   * ```tsx
+   * <PowerPointViewer
+   *   shareDefaults={{
+   *     roomId: "session-abc123",
+   *     userName: "Alice",
+   *     serverUrl: "ws://localhost:1234",
+   *   }}
+   * />
+   * ```
+   */
+  shareDefaults?: {
+    roomId?: string;
+    userName?: string;
+    serverUrl?: string;
+  };
+  /**
+   * Opt in to the Three.js SmartArt renderer. When `true`, SmartArt diagrams
+   * render as extruded 3D blocks on a WebGL canvas instead of flat SVG.
+   * Requires the optional `three` peer dependency; when it is not installed
+   * (or the diagram has no geometry), the viewer transparently falls back to
+   * the SVG `SmartArtRenderer`. Default `false`.
+   */
+  smartArt3D?: boolean;
+  /**
+   * Opt in to the interactive Three.js surface-chart renderer. When `true`,
+   * `surface`/`surface3D` charts render as a WebGL mesh
+   * instead of the static SVG isometric
+   * projection. Chart marks are not selectable/draggable in this mode.
+   * Requires the optional `three` peer dependency; when it is not installed
+   * (or the chart has no plottable grid), the viewer transparently falls back
+   * to the SVG surface renderer. Default `false`.
+   */
+  surfaceChart3D?: boolean;
+  /**
+   * Opt in to the interactive Three.js bar3D-chart renderer. When `true`,
+   * `bar3D` charts render as real box meshes instead of the flat SVG oblique-projection
+   * illusion. Chart marks are not selectable/draggable in this mode.
+   * Requires the optional `three` peer dependency; when it is not installed
+   * (or the chart has no plottable grid, or it is a horizontal 3-D Bar), the
+   * viewer transparently falls back to the flat SVG bar3D renderer. Default
+   * `false`.
+   */
+  barChart3D?: boolean;
+  /**
+   * Opt in to the interactive Three.js line3D-chart renderer. When `true`,
+   * `line3D` charts render as a real tube-path mesh per
+   * series, one per depth ("series") plane,
+   * instead of the flat SVG oblique-projection illusion. Chart marks are not
+   * selectable/draggable in this mode. Requires the optional `three` peer
+   * dependency; when it is not installed (or the chart has no plottable
+   * grid), the viewer transparently falls back to the flat SVG line3D
+   * renderer. Default `false`.
+   */
+  lineChart3D?: boolean;
+  /**
+   * Opt in to the interactive Three.js area3D-chart renderer. When `true`,
+   * `area3D` charts render as a real tube path + filled
+   * ribbon mesh per series, one per depth ("series") plane, instead of the flat SVG oblique-projection illusion.
+   * Chart marks are not selectable/draggable in this mode. Requires the
+   * optional `three` peer dependency; when it is not installed (or the chart
+   * has no plottable grid), the viewer transparently falls back to the flat
+   * SVG area3D renderer. Default `false`.
+   */
+  areaChart3D?: boolean;
+  /**
+   * Opt in to the interactive Three.js pie3D-chart renderer. When `true`,
+   * `pie3D` charts render as real wedge meshes instead of the flat SVG oblique-projection
+   * illusion. Chart marks are not selectable/draggable in this mode.
+   * Requires the optional `three` peer dependency; when it is not installed
+   * (or the chart has no plottable series), the viewer transparently falls
+   * back to the flat SVG pie3D renderer. Default `false`.
+   */
+  pieChart3D?: boolean;
+  /**
+   * Zero-based slide shown after each load, clamped into the deck. Default
+   * `0`. Changing it later does not move the current slide; it applies to
+   * the next load.
+   */
+  initialSlide?: number;
+  /**
+   * Google Fonts fallback for deck fonts that are neither installed nor
+   * embedded. Unset: File > Options > Trust Center > "Download fonts that
+   * are not installed or embedded" decides (on by default: the viewer
+   * loads them from `fonts.googleapis.com`). Any other value locks that
+   * option: off for `false` or an invalid `baseUrl`, on for a mirror.
+   * `false`: no request goes to Google (`fonts.googleapis.com` or
+   * `fonts.gstatic.com`); text uses installed, embedded or fallback fonts.
+   * `{ baseUrl }`: requests go to a self-hosted mirror of the Google Fonts
+   * CSS2 API instead, so the user's browser never contacts Google. An
+   * invalid `baseUrl` disables the fallback (with a console warning).
+   */
+  googleFonts?: GoogleFontsOption;
+  /**
+   * How far Bullets / Numbering reach from a bare caret (no text selected).
+   * `'paragraph'` (default, PowerPoint behaviour): only the caret's paragraph
+   * changes. `'list'` (Word / Google Docs behaviour): when the caret's
+   * paragraph is already a list item and the command switches it between
+   * bullets and numbering, every adjacent item of that list converts with it.
+   * A range selection always affects only the paragraphs it touches.
+   */
+  listConversionScope?: ListConversionScope;
+  /**
+   * Show the editor chrome: title bar, ribbon and toolbar, protected-view
+   * and read-only banners, the mobile toolbar and the status bar. Default
+   * `true`; `false` leaves the canvas (and the thumbnail pane, if shown).
+   */
+  showToolbar?: boolean;
+  /**
+   * Show the slide thumbnail pane. Default `true`. The pane still follows
+   * the user's own collapse toggle and the `slidesPane` customisation panel.
+   */
+  showThumbnails?: boolean;
+  /**
+   * Show the compatibility warning toast stack after a load. Default `true`.
+   * `false` hides the stack only; the warnings are still collected.
+   */
+  showCompatibilityToasts?: boolean;
+  /**
+   * Hide individual toolbar buttons and/or ribbon tabs instead of the whole
+   * toolbar. Accepts any mix of button ids (`share`, `broadcast`, `export`,
+   * `undo`, `redo`, `record`, `notes`, `fullscreen`, `zoom`, `navigation`)
+   * and ribbon-tab ids (`file`, `home`, `insert`, `draw`, `design`,
+   * `transitions`, `animations`, `slideShow`, `record`, `review`, `view`,
+   * `help`). `zoom` and `navigation` each hide their whole control cluster
+   * (zoom in/out/fit; previous/next slide), not each sub-button. `record`
+   * is shared between the quick-access Record button and the Record ribbon
+   * tab: hiding it hides both. Omitted or empty hides nothing (default,
+   * fully backward compatible).
+   *
+   * @example
+   * ```tsx
+   * <PowerPointViewer content={bytes} hiddenActions={['share', 'broadcast', 'record']} />
+   * ```
+   */
+  hiddenActions?: ToolbarActionId[];
+  /**
+   * Ribbon tabs the host adds after Help, as an Office add-in does. Each
+   * command runs its `run` callback and dispatches a bubbling
+   * `office-ribbon-add-in` DOM event (`{ tab, command }`) from the viewer. A
+   * tab cannot take the id of a built-in tab, and a drop-down (`items`) is
+   * drawn as its items. The desktop ribbon shows them; the phone toolbar does not.
+   *
+   * @example
+   * ```tsx
+   * <PowerPointViewer
+   *   content={bytes}
+   *   ribbonAddIns={[{ id: 'reports', label: 'Reports', groups: [
+   *     { label: 'Export', commands: [{ id: 'export', label: 'Export', run: exportReport }] },
+   *   ] }]}
+   * />
+   * ```
+   */
+  ribbonAddIns?: readonly RibbonAddInTab[];
+  /**
+   * Opt in to the built-in AI assistant. When provided, a Sparkles toggle
+   * appears in the toolbar and opens a chat panel; when omitted, no AI icon
+   * renders and no AI code is loaded (the panel and its `@ai-sdk/react`
+   * dependency are `React.lazy`-imported only on first open).
+   *
+   * Pass a plain `PptxAiConfig` (supported and not deprecated), or the opaque
+   * handle `createAiAssistant(config)` returns (from `pptx-react-viewer/ai`, the
+   * opt-in entry that brings the chat panel). Both open the same panel. Only a
+   * value from `createAiAssistant` is read as a handle; any other value is a
+   * plain config, which the viewer does not validate. The config supplies the
+   * model connection (a backend `endpoint`, an in-browser `model`, or a custom
+   * `transport`) plus optional tool allow/deny lists and a write policy.
+   * Requires the optional `ai` and `@ai-sdk/react` peers.
+   *
+   * @example
+   * ```tsx
+   * import { createAiAssistant } from 'pptx-react-viewer/ai';
+   *
+   * const assistant = createAiAssistant({ connection: { kind: 'endpoint', api: '/api/chat' } });
+   * <PowerPointViewer content={bytes} ai={assistant} />
+   * ```
+   *
+   * @see {@link PptxAiConfig}
+   */
+  ai?: PptxAiConfig | PptxAiAssistant;
+  /**
+   * Framework-neutral UI customisation. See docs/guide/customization.md.
+   * Unioned with `hiddenActions`. A new object replaces the whole
+   * customisation, including edits made through the handle helpers.
+   */
+  /** Initial inspector visibility; omitted preserves the desktop/mobile default. */
+  inspectorInitiallyOpen?: boolean;
+  customization?: ViewerCustomization;
+  /**
+   * Host switch for content a deck links from another server (http(s)
+   * relationship targets): pictures, picture fills and bullets, video, audio
+   * and poster frames. `false`: none of it is fetched. `true`: it is allowed.
+   * Either value locks File > Options > Trust Center > "Allow external
+   * content" to match; unset keeps the user's choice there. Google Fonts
+   * requests are separate (see `googleFonts`).
+   * A change applies from the next load.
+   */
+  allowExternalContent?: boolean;
+  /**
+   * Bounds on the work loading a deck may do, for hosts that show untrusted
+   * decks: `maxInputBytes`, `maxUncompressedBytes`, `maxEntries`, `maxSlides`
+   * and `maxShapes` (see `PptxLoadLimits`). Unset keeps the core defaults
+   * (500 MiB inflated, 65,536 ZIP entries, no other limit). A deck over a
+   * limit shows the load-error screen with the limit and the deck's value.
+   * A change applies from the next load.
+   */
+  limits?: PptxLoadLimits;
+}
+interface PowerPointViewerHandle extends FileViewerHandle, PowerPointViewerAPI, ViewerCustomizationApi {
+  getContent: () => Promise<Uint8Array>;
+}
+
+declare function getAnimationInitialStyle(preset: PptxAnimationPreset | undefined, nativeAnimation?: PptxNativeAnimation): React$1__default.CSSProperties;
+/**
+ * Root React component for the PowerPoint viewer/editor.
+ *
+ * Accepts binary `.pptx` content and renders a full-featured editor with
+ * slide canvas, toolbar, inspector panels, presentation mode, and more.
+ *
+ * Uses `forwardRef` to expose a `PowerPointViewerHandle` for imperative
+ * access (e.g. serialising the current content for saving).
+ */
+declare const PowerPointViewer: React$1.ForwardRefExoticComponent<PowerPointViewerProps & React$1.RefAttributes<PowerPointViewerHandle>>;
+interface PptxI18nProviderProps {
+  /**
+   * Translates a viewer key; see {@link PptxTranslate}. Keep it referentially stable (a
+   * module-level function or `useCallback`): the viewer re-translates, re-rendering and re-running
+   * every translated effect, whenever `translate` or `locale` changes. To pick up messages loaded
+   * later for the same language, pass a new function.
+   */
+  readonly translate: PptxTranslate;
+  /**
+   * The host's active language: what the viewer reports and File > Options > Language shows as
+   * selected. A change re-translates the viewer, also when `translate` stays the same.
+   */
+  readonly locale: string;
+  readonly children?: ReactNode;
+}
+/**
+ * Translates every viewer component below it (`PowerPointViewer` and the standalone building
+ * blocks) through the host's own i18n library instead of react-i18next. A `PowerPointViewer`
+ * reads the provider nearest above it; a provider rendered inside the viewer is ignored, so the
+ * whole viewer shares one language. React only: the other bindings translate through their
+ * framework's i18n library or a `messages` dictionary.
+ */
+declare function PptxI18nProvider({ translate, locale, children }: PptxI18nProviderProps): ReactElement;
+
+interface ToolbarProps {
+  fileName?: string;
+  mode: ViewerMode;
+  canEdit: boolean;
+  /**
+   * True when `canEdit` is false because Trust Center > "Open presentations
+   * in Protected View" is on (not because the host itself withheld edit
+   * permission). Turns the toolbar's read-only badge into an "Enable
+   * Editing" action.
+   */
+  isProtectedView?: boolean;
+  /** Drops the Protected View override for this session. Only offered when `isProtectedView` is true. */
+  onEnableEditing?: () => void;
+  isNarrowViewport: boolean;
+  isSidebarCollapsed: boolean;
+  isInspectorPaneOpen: boolean;
+  isCompactToolbarOpen: boolean;
+  toolbarSection: ToolbarSection;
+  scale: number;
+  canUndo: boolean;
+  canRedo: boolean;
+  undoLabel: string | undefined;
+  redoLabel: string | undefined;
+  findReplaceOpen: boolean;
+  selectedElement: PptxElement | null;
+  tableEditorState?: TableCellEditorState | null;
+  editTemplateMode: boolean;
+  newShapeType: SupportedShapeType;
+  /** The armed Freeform: Shape / Curve tool, or null. */
+  activeFreeformTool?: FreeformToolKind | null;
+  activeTool: DrawingTool;
+  drawingColor: string;
+  drawingWidth: number;
+  clipboardPayload: ElementClipboardPayload | null;
+  onSetMode: (mode: ViewerMode) => void;
+  /**
+   * PowerPoint's "From Beginning" (F5): enters the show on the show's FIRST
+   * slide regardless of the currently active slide, unlike `onSetMode`
+   * ('present') which enters "From Current Slide". Falls back to
+   * `onSetMode('present')` when omitted.
+   */
+  onPresentFromBeginning?: () => void;
+  onToggleSidebar: () => void;
+  onToggleInspector: () => void;
+  /** Opens the inspector pane and switches to the properties tab (for animation panel). */
+  onOpenAnimationPanel: () => void;
+  /**
+   * Adds an animation to the selected element. For the three preset buckets
+   * `preset` is a `PptxAnimationPreset`; for `motionPath` it is a motion-path
+   * catalogue id.
+   */
+  onAddAnimation?: (preset: string, group: AnimationApplyGroup) => void;
+  /** Removes all animations from the selected element. */
+  onRemoveAnimation?: () => void;
+  onToggleCompactToolbar: () => void;
+  onSetToolbarSection: (section: ToolbarSection) => void;
+  onZoomIn: () => void;
+  onZoomOut: () => void;
+  onZoomToFit: () => void;
+  onUndo: () => void;
+  onRedo: () => void;
+  onToggleFindReplace: () => void;
+  onSetNewShapeType: (type: SupportedShapeType) => void;
+  /** Arm (or, with null, disarm) a Freeform: Shape / Curve tool. */
+  onArmFreeformTool?: (tool: FreeformToolKind | null) => void;
+  onAddTextBox: () => void;
+  onAddShape: () => void;
+  onAddTable: (rows?: number, columns?: number) => void;
+  onAddChart?: (chartKind: InsertChartKind) => void;
+  /** Opens the Insert Chart dialog; without it the Chart menu leaves "Insert Chart..." out. */
+  onOpenChartDialog?: () => void;
+  onAddSmartArt: () => void;
+  onAddEquation: () => void;
+  onAddActionButton: (shapeType: string) => void;
+  onInsertField?: (fieldType: string, value?: string) => void;
+  onOpenHeaderFooter?: () => void;
+  onOpenImagePicker: () => void;
+  onOpenMediaPicker: () => void;
+  onSetActiveTool: (tool: DrawingTool) => void;
+  onSetDrawingColor: (color: string) => void;
+  onSetDrawingWidth: (width: number) => void;
+  onSetEditTemplateMode: (mode: boolean) => void;
+  spellCheckEnabled: boolean;
+  showGrid: boolean;
+  showRulers: boolean;
+  /** Whether the drawing guides are painted on the canvas (View ▸ Guides). */
+  showGuides: boolean;
+  snapToGrid: boolean;
+  snapToShape: boolean;
+  onSetSpellCheckEnabled: (enabled: boolean) => void;
+  onSetShowGrid: (enabled: boolean) => void;
+  onSetShowRulers: (enabled: boolean) => void;
+  onSetShowGuides: (enabled: boolean) => void;
+  onSetSnapToGrid: (enabled: boolean) => void;
+  onSetSnapToShape: (enabled: boolean) => void;
+  onAddGuide: (axis: 'h' | 'v') => void;
+  onAlignElements: (align: string) => void;
+  onDistributeElements: (axis: string) => void;
+  canDistribute: boolean;
+  onCopy: () => void;
+  onCut: () => void;
+  onPaste: () => void;
+  onFlip: (direction: 'horizontal' | 'vertical') => void;
+  onMoveLayer: (direction: string) => void;
+  onMoveLayerToEdge: (direction: string) => void;
+  /** Combine the multi-selection into one group element. */
+  onGroupElements: () => void;
+  /** Dissolve the selected group back into its children. */
+  onUngroupElement: () => void;
+  /** Patch the selected element's shape style (outline width, fill, ...). */
+  onUpdateElementStyle: (updates: Partial<ShapeStyle>) => void;
+  /** How many elements the multi-select currently holds. */
+  selectedCount: number;
+  /** Whether every selected element allows `a:spLocks/@noGrp` grouping. */
+  selectionGroupable: boolean;
+  /** Open the hyperlink editor for the current selection. */
+  onOpenHyperlinkDialog: () => void;
+  onDuplicate: () => void;
+  onDelete: () => void;
+  /** Open another presentation (File ▸ Open). Hidden when not provided. */
+  onOpenFile?: () => void;
+  onOpenRecentFile?: (key: string) => void;
+  onCreatePresentation: (templateId: string) => void;
+  onExportPng: () => void;
+  onExportPdf: () => void;
+  onExportVideo: () => void;
+  onExportGif: () => void;
+  onExportJson: () => void;
+  onOpenShareDialog?: () => void;
+  /** File > Save (the backstage Save item): reported to host storage as `save`, not Save As. */
+  onSave?: () => void;
+  onSaveAsPptx: () => void;
+  onSaveAsPpsx: () => void;
+  onSaveAsPptm: () => void;
+  onSaveAsPpt: () => void;
+  hasMacros: boolean;
+  onCopySlideAsImage: () => void;
+  onPrint: () => void;
+  onToggleShortcuts: () => void;
+  onOpenSettings?: () => void;
+  onRunAccessibilityCheck: () => void;
+  onToggleSlideSorter: () => void;
+  /**
+   * View > Normal: leave whichever alternate view (slide sorter, reading,
+   * outline, master) is open and return to the ordinary editing canvas.
+   */
+  onGoToNormalView?: () => void;
+  /** Enter PowerPoint's Reading View (full window, not the fullscreen show). */
+  onOpenReadingView: () => void;
+  /** Enter PowerPoint's Outline view: the deck as editable indented text. */
+  onOpenOutlineView: () => void;
+  onUpdateTextStyle: (updates: Partial<TextStyle>) => void;
+  /** Bullets / Numbering for the selected text element (shared paragraph bullet toggle). */
+  onToggleBullets: (kind: 'bullet' | 'numbered') => void;
+  /** Rewrite the selected text's characters (PowerPoint's Aa "Change Case" dropdown). */
+  onTransformTextCase: (mode: ChangeCaseMode) => void;
+  isOverflowMenuOpen: boolean;
+  onSetOverflowMenuOpen: (open: boolean) => void;
+  layoutOptions: PptxLayoutOption[];
+  /** `layoutPath` of the active slide, marking the current gallery tile. */
+  currentLayoutPath?: string;
+  /** Supplies gallery artwork; without it the menus stay name-only. */
+  loadLayoutPreviews?: () => Promise<PptxLayoutPreview[]>;
+  /** Theme major/minor latin faces, leading the font dropdown. */
+  themeFonts?: {
+    heading?: string;
+    body?: string;
+  };
+  /** Families the deck embeds, offered as their own dropdown group. */
+  embeddedFontFamilies?: readonly string[];
+  /** Families registered this session via File > Options > Fonts. */
+  customFontFamilies?: readonly string[];
+  onInsertSlideFromLayout: (path: string, name?: string) => void;
+  /** Re-map the active slide onto another of its master's layouts. */
+  onApplyLayout?: (path: string) => void;
+  /** Insert a pre-designed starter slide from the template gallery. */
+  onInsertSlideFromTemplate?: (templateId: SlideTemplateId) => void;
+  /** Deck scheme map so template gallery previews show the deck theme. */
+  templateScheme?: Record<string, string>;
+  customShows: PptxCustomShow[];
+  activeCustomShowId: string | null;
+  onSetActiveCustomShowId: (id: string | null) => void;
+  onCreateCustomShow: () => void;
+  onRenameActiveCustomShow: () => void;
+  onDeleteActiveCustomShow: () => void;
+  onToggleCurrentSlideInActiveShow: () => void;
+  isCurrentSlideInActiveShow: boolean;
+  onToggleVersionHistory?: () => void;
+  onOpenPasswordProtection?: () => void;
+  onOpenDocumentProperties?: () => void;
+  /** Design > Slide Size: reveal the inspector card that owns the slide size. */
+  onOpenSlideSize?: () => void;
+  onOpenFontEmbedding?: () => void;
+  onOpenDigitalSignatures?: () => void;
+  onEnterMasterView: () => void;
+  onCloseMasterView: () => void;
+  onEnterPresenterView?: () => void;
+  onEnterRehearsalMode?: () => void;
+  onToggleThemeEditor: () => void;
+  isThemeEditorOpen: boolean;
+  onToggleThemeGallery: () => void;
+  isThemeGalleryOpen: boolean;
+  onCompare?: () => void;
+  onToggleComments?: () => void;
+  isCommentsPanelOpen?: boolean;
+  /** The phone Insert sheet (opened from the bottom bar) and how it asks to close. */
+  isMobileInsertOpen?: boolean;
+  onCloseMobileInsert?: () => void;
+  spellCheckActive?: boolean;
+  slideCommentCount?: number;
+  /** Review > Comments Previous / Next / Delete: the deck's slides and how to rewrite them. */
+  reviewComments?: ReviewCommentsHost;
+  formatPainterActive?: boolean;
+  onToggleFormatPainter?: () => void;
+  canActivateFormatPainter?: boolean;
+  isSelectionPaneOpen?: boolean;
+  onToggleSelectionPane?: () => void;
+  eyedropperActive?: boolean;
+  onToggleEyedropper?: () => void;
+  onOpenSetUpSlideShow?: () => void;
+  /** Slide Show > Custom Slide Show: open the Custom Shows dialog. */
+  onOpenCustomShows?: () => void;
+  /** PowerPoint's Hide Slide toggle for the active slide (Slide Show tab). */
+  onToggleHideSlide?: () => void;
+  /** Whether the active slide is hidden, for Hide Slide's pressed state. */
+  activeSlideHidden?: boolean;
+  onOpenBroadcastDialog?: () => void;
+  onToggleSubtitles?: () => void;
+  showSubtitles?: boolean;
+  activeSlide?: PptxSlide;
+  onTransitionChange: (updates: Partial<PptxSlideTransition>) => void;
+  onApplyTransitionToAll: () => void;
+  /**
+   * Home > Slides > Reset: re-apply the active slide's own layout, restoring
+   * inherited placeholder geometry. Undeclared until now, which is why
+   * `SlidesGroup` bound `undefined` and the button did nothing.
+   */
+  onResetSlide?: () => void;
+  /** Home > Slides > Section: start a new section at the active slide. */
+  onAddSection?: () => void;
+  /** Home > Editing > Select > Select All (every element on the active slide). */
+  onSelectAll?: () => void;
+  /**
+   * Slide Show > Options: what the four checkboxes read, and how a tick is
+   * committed. See shared `ribbon-slide-show-options`.
+   */
+  presentationProperties?: PptxPresentationProperties;
+  onPresentationPropertiesChange?: (updates: Partial<PptxPresentationProperties>) => void;
+  /** Host-supplied list of toolbar buttons/ribbon tabs to hide. See `PowerPointViewerProps.hiddenActions`. */
+  hiddenActions?: readonly ToolbarActionId[];
+  /** File > Options > Advanced > "Quickly access this number of Recent Documents". */
+  recentPresentationsCount?: number;
+  /** Whether the AI assistant is available (the host passed the `ai` prop). */
+  aiEnabled?: boolean;
+  /** Whether the AI assistant panel is currently open. */
+  isAiPanelOpen?: boolean;
+  /** Toggle the AI assistant panel. */
+  onToggleAiPanel?: () => void;
+  /**
+   * Run a Quick Access command beyond the dedicated Save/Undo/Redo trio, by
+   * catalog id. Used for the below-ribbon strip when Options > Quick Access
+   * Toolbar > position is "below" (the same handler `TitleBar` uses for its
+   * own inline strip when position is "above").
+   */
+  onQuickCommand?: (id: string) => void;
+}
+type CanvasImagePasteHandlers = Pick<EditorImagePasteOptions, 'getTarget' | 'insertElement'>;
+/**
+ * Table band / header / emphasis styling for the React table renderer.
+ *
+ * The resolution itself (`ppt/tableStyles.xml` lookup, whole-table and banded
+ * fills, header / total / first / last emphasis, `a:fontRef@idx` font resolution,
+ * gradient and pattern fills) lives in `pptx-viewer-shared`, so every binding
+ * paints a table the same way. This module is the React adapter: it narrows the
+ * element, maps the theme onto the shared context, and hands back a
+ * `CSSProperties` object.
+ *
+ * @module viewer/utils/table-band-style
+ */
+/** Context for resolving table style colours from the theme. */
+interface TableStyleContext {
+  tableStyleMap?: ParsedTableStyleMap;
+  theme?: PptxTheme;
+}
+/** Wiring for Edit Points and the Freeform: Shape / Curve tools. */
+interface OutlineAuthoringProps {
+  /** The shape in Edit Points mode, or null. */
+  editPointsElementId: string | null;
+  /** Edit Points menu commands the host hid. */
+  hiddenEditPointsCommands?: ReadonlySet<EditPointsCommandId>;
+  /** Apply one Edit Points edit (one undo step). */
+  onCommitEditPoints: (elementId: string, patch: EditPointsElementPatch) => void;
+  onExitEditPoints: () => void;
+  /** The armed drawing tool, or null. */
+  freeformTool: FreeformToolKind | null;
+  /** Insert a drawn freeform (the tool then disarms). */
+  onFreeformCommit: (element: ShapePptxElement) => void;
+  onFreeformCancel: () => void;
+}
+interface ZoomViewport {
+  canvasViewportRef: React$1__default.RefObject<HTMLDivElement | null>;
+  /** Optional mount notification for hook-owned fit and wheel listeners. */
+  setCanvasViewportNode?: React$1__default.RefCallback<HTMLDivElement>;
+  editWrapperRef: React$1__default.RefObject<HTMLDivElement | null>;
+  canvasStageRef: React$1__default.RefObject<HTMLDivElement | null>;
+  editorScale: number;
+}
+interface SlideCanvasProps {
+  /** The viewer-owned live channel; absent for static/custom non-collaborative canvases. */
+  livePatcher?: CollaborationLivePatcher;
+  registerInlineEditReader?: (elementId: string, read: () => InlineListReadResult) => () => void;
+  /** Native image paste commands supplied by the stock or headless editor. */
+  imagePaste?: CanvasImagePasteHandlers;
+  activeSlide: PptxSlide | undefined;
+  templateElements: PptxElement[];
+  canvasSize: CanvasSize$1;
+  zoom: ZoomViewport;
+  mode: ViewerMode;
+  canEdit: boolean;
+  editTemplateMode: boolean;
+  selectedElementIdSet: Set<string>;
+  selectedElement: PptxElement | null;
+  inlineEditingElementId: string | null;
+  inlineEditingText: string;
+  spellCheckEnabled: boolean;
+  mediaDataUrls: Map<string, string>;
+  tableEditorState: TableCellEditorState | null;
+  marqueeSelectionState: MarqueeSelectionState | null;
+  snapLines: Array<{
+    axis: string;
+    position: number;
+  }>;
+  showGrid: boolean;
+  /** Grid spacing in CSS px (derived from PPTX gridSpacing EMUs). */
+  gridSpacingPx?: number;
+  showRulers: boolean;
+  /** Unit system for rulers (default: inches). */
+  rulerUnit?: RulerUnit;
+  guides: Array<{
+    id: string;
+    axis: 'h' | 'v';
+    position: number;
+  }>;
+  presentationElementStates?: Map<string, ElementAnimationState>;
+  presentationKeyframesCss?: string;
+  onClick: (elementId: string, e: React$1__default.MouseEvent) => void;
+  onDoubleClick: (elementId: string, e: React$1__default.MouseEvent) => void;
+  onMouseDown: (elementId: string, e: React$1__default.MouseEvent) => void;
+  onContextMenu: (elementId: string, e: React$1__default.MouseEvent) => void;
+  /** Called when the user presses mouse down on empty canvas space. */
+  onCanvasMouseDown?: (e: React$1__default.MouseEvent) => void;
+  /** Right-click on empty canvas (no element hit); opens the canvas context menu. */
+  onCanvasContextMenu?: (e: React$1__default.MouseEvent) => void;
+  onResizePointerDown: (elementId: string, e: React$1__default.MouseEvent, handle: string) => void;
+  onAdjustmentPointerDown: (elementId: string, e: React$1__default.MouseEvent, descriptor: ShapeAdjustmentHandleDescriptor) => void;
+  /** Commit a new rotation (degrees) when the on-canvas rotate handle is dragged. */
+  onRotate?: (elementId: string, rotationDeg: number) => void;
+  onInlineEditChange: (text: string, snapshot?: InlineTextEditSnapshot) => void;
+  onInlineEditCommit: () => void;
+  onInlineEditCancel: () => void;
+  onTableCellSelect: (cell: Omit<TableCellEditorState, 'elementId'> | null, elementId: string) => void;
+  /** Called when an edited table cell should be committed. */
+  onCommitCellEdit?: (elementId: string, rowIndex: number, colIndex: number, text: string) => void;
+  /**
+   * Commit a partial update to a SmartArt element from inline (on-canvas) node
+   * editing. Routed to the same element-update path the inspector uses (undo/redo
+   * + dirty marking). When absent, inline SmartArt editing is disabled.
+   */
+  onUpdateSmartArtElement?: (elementId: string, updates: Partial<PptxElement>) => void;
+  /**
+   * Apply a text-style toggle (Ctrl/Cmd+B/I/U) to the element being
+   * inline-edited. Routed to the same updateSelectedTextStyle path as the
+   * toolbar. When absent, the inline formatting shortcuts are inert.
+   */
+  onFormatText?: (updates: Partial<TextStyle>) => void;
+  /** Called when table column widths are resized. */
+  onResizeTableColumns?: (elementId: string, newWidths: number[]) => void;
+  /** Called when a table row is resized. */
+  onResizeTableRow?: (elementId: string, rowIndex: number, newHeight: number) => void;
+  /** Find & Replace results (all matches across all slides). */
+  findResults?: ReadonlyArray<{
+    slideIndex: number;
+    elementId: string;
+    segmentIndex: number;
+    startOffset: number;
+    length: number;
+  }>;
+  /** Index of the currently focused find result (-1 for none). */
+  findResultIndex?: number;
+  /** Index of the currently visible slide (needed to filter find results). */
+  activeSlideIndex?: number;
+  /** Currently active drawing tool ("select" means no drawing overlay). */
+  activeTool?: DrawingTool;
+  /** Stroke colour for pen / highlighter. */
+  drawingColor?: string;
+  /** Stroke width for pen / highlighter. */
+  drawingWidth?: number;
+  /** Ref that is true while a pointer stroke is in progress. */
+  isDrawingRef?: React$1__default.RefObject<boolean>;
+  /** Called when a completed ink stroke should be added to the slide. */
+  onAddInkElement?: (ink: InkPptxElement) => void;
+  /** Called when a freeform drawing stroke should be added as a shape element. */
+  onAddFreeformShape?: (shape: ShapePptxElement) => void;
+  /** Called when the eraser tool removes an ink element. */
+  onEraseInkElement?: (elementId: string) => void;
+  /** Called when a shape-level action is clicked (e.g. slide jump, URL). */
+  onActionClick?: (elementId: string, action: PptxAction) => void;
+  /** Called when a text-level hyperlink is clicked. */
+  onHyperlinkClick?: (url: string) => void;
+  /** Comments for the current slide (used for on-canvas markers). */
+  comments?: PptxComment[];
+  /** Whether to show comment markers on the slide canvas. */
+  showCommentMarkers?: boolean;
+  /** Called when a comment marker is clicked. */
+  onCommentMarkerClick?: (commentId: string) => void;
+  onMoveGuide?: (guideId: string, position: number) => void;
+  onDeleteGuide?: (guideId: string) => void;
+  onCreateGuideFromRuler?: (axis: 'h' | 'v', positionPx: number) => void;
+  /**
+   * Commits the slide's animation list after an on-canvas motion-path edit
+   * (dragging the path's end handle). Absent means the path is drawn but
+   * read-only.
+   */
+  onUpdateSlideAnimations?: (animations: PptxElementAnimation[]) => void;
+  /** When true, shows connection sites on shapes and enables connector drawing. */
+  connectorCreationMode?: boolean;
+  /** Called when a new connector is created between two shapes. */
+  onCreateConnector?: (connector: ConnectorPptxElement) => void;
+  /** All slides in the presentation (for zoom element thumbnails). */
+  allSlides?: readonly PptxSlide[];
+  /** Callback fired when a zoom element is clicked in presentation mode. */
+  onZoomClick?: (target: ZoomNavigationTarget, returnSlideIndex: number) => void;
+  /** Index of the current slide (for zoom return navigation). */
+  sourceSlideIndex?: number;
+  /** Context for text field placeholder substitution (slide number, header/footer, etc.). */
+  fieldContext?: FieldSubstitutionContext;
+  /** Theme + table style map for resolving table band/header colours. */
+  tableStyleContext?: TableStyleContext;
+  /** Optional collaboration cursor overlay rendered on top of the canvas. */
+  collaborationOverlay?: React$1__default.ReactNode;
+  /**
+   * When true, the stage marks itself `data-pptx-ai-active` so element colour
+   * changes tween while the AI assistant is working (see AiFocusHighlightOverlay).
+   */
+  aiActive?: boolean;
+  outlineAuthoring?: OutlineAuthoringProps;
+}
+interface SlidesPaneSidebarProps {
+  slides: PptxSlide[];
+  templateElementsBySlideId: Record<string, PptxElement[]>;
+  activeSlideIndex: number;
+  canvasSize: CanvasSize$1;
+  sectionGroups: SlideSectionGroup[];
+  isOpen: boolean;
+  canEdit: boolean;
+  onSelectSlide: (index: number) => void;
+  onSlideContextMenu: (e: React$1__default.MouseEvent, index: number) => void;
+  onMoveSlide: (fromIndex: number, toIndex: number) => void;
+  onAddSlide: () => void;
+  onAddSlideAfter: (index: number) => void;
+  onDuplicateSlides: (indexes: number[]) => void;
+  onDeleteSlides: (indexes: number[]) => void;
+  onHideSlides: (indexes: number[]) => void;
+  /** Makes `index` active, then opens the Layout gallery anchored at (x, y). */
+  onOpenLayoutForSlide: (index: number, x: number, y: number) => void;
+  onCollapse: () => void;
+  onAddSection?: (name: string, afterSlideIndex: number) => void;
+  onRenameSection?: (sectionId: string, newName: string) => void;
+  onDeleteSection?: (sectionId: string) => void;
+  onMoveSectionUp?: (sectionId: string) => void;
+  onMoveSectionDown?: (sectionId: string) => void;
+  /**
+   * Persist the collapse flag onto the section model, so it round-trips
+   * through save exactly as it does in the other four bindings.
+   */
+  onToggleSectionCollapse?: (sectionId: string) => void;
+  /** Recorded rehearsal timings in ms, keyed by slide index. */
+  rehearsalTimings?: Record<number, number>;
+  /** Width of the panel in pixels (for resizable panels). */
+  panelWidth?: number;
+  /**
+   * Presentation-wide field context (date/header/footer/custom props) so
+   * thumbnails substitute the same field placeholders as the canvas.
+   */
+  fieldContext?: FieldSubstitutionContext;
+  /** Theme + table style map so thumbnails resolve table band/header colours. */
+  tableStyleContext?: TableStyleContext;
+}
+/** The one autosave status every binding renders (`PptxAutosaveStatus` in `ooxml-ui/pptx`). */
+type AutosaveStatus = PptxAutosaveStatus;
+interface UseViewerBuildingBlocksInput extends ViewportFitOptions {
+  /** Optional collaboration, including a host-owned document and presence session. */
+  collaboration?: CollaborationInput;
+  /** PPTX content as ArrayBuffer/Uint8Array, or null/undefined while no file is loaded. */
+  content: ArrayBuffer | Uint8Array | null | undefined;
+  /** Whether editing actions are enabled. Defaults to false (view-only). */
+  canEdit?: boolean;
+  /** Original file path, used for autosave recovery. */
+  filePath?: string;
+  /** Display name for the toolbar's file-name-aware controls (e.g. title bar hosts build themselves). */
+  fileName?: string;
+  /**
+   * Zero-based slide shown after each load, clamped into the deck, as `PowerPointViewer`'s
+   * `initialSlide`. It is applied in the same render that shows the loaded deck, so slide 1 is
+   * never shown first. Changing it later applies to the next load, not the current slide; use
+   * the handle's `goTo` to move an open deck.
+   */
+  initialSlide?: number;
+  /** As `PowerPointViewer`'s `googleFonts`: the Google Fonts fallback policy (off, or a self-hosted mirror). */
+  googleFonts?: GoogleFontsOption;
+  /**
+   * As `PowerPointViewer`'s `listConversionScope`: how far Bullets / Numbering reach from a
+   * bare caret. `'paragraph'` (default, PowerPoint behaviour) changes only the caret's
+   * paragraph; `'list'` (Word / Google Docs behaviour) converts the whole adjacent list when
+   * the caret switches a list paragraph between bullets and numbering.
+   */
+  listConversionScope?: ListConversionScope;
+  /**
+   * As `PowerPointViewer`'s `allowExternalContent`: `false` fetches no linked
+   * http(s) content, `true` allows it, either value locks the Trust Center
+   * setting; unset keeps the user's choice. A change applies from the next load.
+   */
+  allowExternalContent?: boolean;
+  /**
+   * As `PowerPointViewer`'s `limits`: bounds on loading a deck (input and
+   * inflated size, ZIP entries, slides, shapes); unset keeps the core
+   * defaults. A change applies from the next load.
+   */
+  limits?: PptxLoadLimits;
+  /** Whether the built-in autosave-to-localStorage recovery timer is active. Defaults to true. */
+  autosaveEnabled?: boolean;
+  /** Display name used as the author for comments. */
+  userName?: string;
+  /** Host-supplied list of toolbar buttons/ribbon tabs to hide. */
+  hiddenActions?: readonly ToolbarActionId[];
+  /** Imperative handle ref, exposing the same `PowerPointViewerHandle` API `PowerPointViewer` does. */
+  handle?: React$1__default.ForwardedRef<PowerPointViewerHandle>;
+  onContentChange?: (content: Uint8Array) => void;
+  onDirtyChange?: (dirty: boolean) => void;
+  onActiveSlideChange?: (index: number) => void;
+  onModeChange?: (mode: ViewerMode) => void;
+  onZoomChange?: (zoom: number) => void;
+  onSelectionChange?: (ids: string[]) => void;
+  onSlideCountChange?: (count: number) => void;
+  /** Fired by the toolbar's "Settings" button; the host owns rendering that dialog. */
+  onOpenSettings?: () => void;
+  /** Fired by the toolbar's "Header & Footer" button; the host owns rendering that panel. */
+  onOpenHeaderFooter?: () => void;
+  /** Fired by the toolbar's "Share" button; the host owns rendering that dialog. */
+  onOpenShareDialog?: () => void;
+  /**
+   * Fired by the "Layout" entry of a slide's context menu in `<SlidesPane>`,
+   * after that slide is made active; the host owns rendering the Layout
+   * gallery (for example anchored at the click point).
+   */
+  onOpenLayoutGallery?: (request: SlidesPaneLayoutGalleryRequest) => void;
+}
+interface ViewerBuildingBlocksResult {
+  /** Connection and presence state for a custom status bar, or null when disabled. */
+  collaboration: CollaborationContextValue | null;
+  /**
+   * Effective edit permission plus connection/presence counts, in the shape
+   * every binding's custom shell receives (Vue/Svelte `shellState`, Angular
+   * `state()`, Vanilla `getState()`); pass it to
+   * `describeCollaborationShellState` for a localised status line.
+   */
+  shellState: CollaborationShellState;
+  /** Flat, self-contained props for the standalone `<Toolbar>` component. */
+  toolbarProps: ToolbarProps;
+  /** Flat, self-contained props for the standalone `<SlideCanvas>` component. */
+  canvasProps: SlideCanvasProps;
+  /**
+   * Flat, self-contained props for the standalone `<SlidesPane>` component:
+   * the slide thumbnail rail `PowerPointViewer` shows beside the canvas.
+   * Its open state is the toolbar's sidebar toggle.
+   */
+  slidesPaneProps: SlidesPaneSidebarProps;
+  /** Current viewer mode (edit, view, present, master). */
+  mode: ViewerMode;
+  /** True while the initial parse of `content` is in progress. */
+  loading: boolean;
+  /** Parse error message, or null. */
+  error: string | null;
+  /** Current autosave-to-localStorage recovery status. */
+  autosaveStatus: AutosaveStatus;
+}
+declare function useViewerBuildingBlocks(input: UseViewerBuildingBlocksInput): ViewerBuildingBlocksResult;
+
+declare function Toolbar(p: ToolbarProps): React$1__default.ReactElement;
+declare function SlideCanvas(props: SlideCanvasProps): React$1.JSX.Element;
+declare function SlidesPaneSidebar({ slides, templateElementsBySlideId, activeSlideIndex, canvasSize, sectionGroups, isOpen, canEdit, onSelectSlide, onSlideContextMenu, onMoveSlide, onAddSlide, onAddSlideAfter, onDuplicateSlides, onDeleteSlides, onHideSlides, onOpenLayoutForSlide, onCollapse: _onCollapse, onAddSection, onRenameSection, onDeleteSection, onMoveSectionUp, onMoveSectionDown, onToggleSectionCollapse, rehearsalTimings, panelWidth, fieldContext, tableStyleContext }: SlidesPaneSidebarProps): React$1__default.ReactElement | null;
+/**
+ * A static, scaled-down drawing of one slide, as the slides pane shows it. It renders from the
+ * slide model, so it follows unsaved edits. Feed it from `slidesPaneProps`:
+ * `templateElementsBySlideId[slide.id]`, `canvasSize`, `fieldContext` and `tableStyleContext`.
+ */
+interface SlideThumbnailProps {
+  /** The slide to draw. A different slide object (every edit makes one) redraws it. */
+  slide: PptxSlide;
+  /** The slide's inherited layout and master elements, drawn beneath its own. */
+  templateElements: PptxElement[];
+  canvasSize: CanvasSize$1;
+  /**
+   * Thumbnail width in pixels; the height follows the deck's aspect ratio. Set it to fill a host
+   * strip without the pane's frame. Omitted, the thumbnail is the pane width with a border.
+   */
+  previewWidth?: number;
+  /** Presentation-wide field context (date/header/footer/custom props). */
+  fieldContext?: FieldSubstitutionContext;
+  /** Theme + table style map for resolving table band/header colours. */
+  tableStyleContext?: TableStyleContext;
+}
+declare function SlideThumbnailImpl({ slide, templateElements, canvasSize, previewWidth, fieldContext, tableStyleContext }: SlideThumbnailProps): React$1__default.ReactElement;
+declare const SlideThumbnail: React$1__default.MemoExoticComponent<typeof SlideThumbnailImpl>;
+interface SlideTemplateGalleryDialogProps {
+  isOpen: boolean;
+  onClose: () => void;
+  onInsert: (templateId: SlideTemplateId) => void;
+  /** Optional deck scheme so previews show the deck's theme colours. */
+  scheme?: Record<string, string>;
+}
+declare function SlideTemplateGalleryDialog({ isOpen, onClose, onInsert, scheme }: SlideTemplateGalleryDialogProps): React$1__default.ReactElement | null;
+interface SlideTemplatePreviewProps {
+  templateId: SlideTemplateId;
+  /** Optional deck scheme so the preview shows the deck's theme colours. */
+  scheme?: Record<string, string>;
+}
+declare function SlideTemplatePreview({ templateId, scheme }: SlideTemplatePreviewProps): React$1__default.ReactElement;
+/**
+ * A drop-in replacement for `html2canvas(element, options)` that first
+ * resolves any oklch / oklab / lch / lab / color() values in the cloned
+ * DOM to rgb()/hex, preventing parse errors in html2canvas <= 1.x.
+ *
+ * Three-pronged approach:
+ * 1. Patch `<style>` elements to replace oklch in CSS custom properties.
+ * 2. Resolve `:root` / `<body>` inline custom properties.
+ * 3. Walk every element and convert computed colour values to sRGB.
+ *
+ * Usage:
+ * ```ts
+ * import { renderToCanvas } from "./canvas-export";
+ * const canvas = await renderToCanvas(element, { scale: 2 });
+ * ```
+ */
+declare function renderToCanvas(element: HTMLElement, options?: Partial<Options>): Promise<HTMLCanvasElement>;
+
+export { PowerPointViewer, PptxI18nProvider, SlideCanvas, SlideTemplateGalleryDialog, SlideTemplatePreview, SlideThumbnail, SlidesPaneSidebar as SlidesPane, Toolbar, ViewerThemeProvider, getAnimationInitialStyle, renderToCanvas, useViewerBuildingBlocks, useViewerTheme };
+export type { CollaborationContextValue, PowerPointViewerHandle, PowerPointViewerProps, PptxI18nProviderProps, PptxTranslate, PptxTranslateParams, SlideCanvasProps, SlideTemplateGalleryDialogProps, SlideTemplatePreviewProps, SlideThumbnailProps, SlidesPaneSidebarProps as SlidesPaneProps, ToolbarProps, UseViewerBuildingBlocksInput, ViewerBuildingBlocksResult, ViewerLoadDetail };