pptx-react-viewer 3.21.0 → 4.1.0

package/dist/internals.d.ts

@@ -11492,6 +11492,23 @@ interface TextStyleAnimationDescriptor {
 //#region src/render/collaboration-presence.d.ts
 /** Connection lifecycle states for the Yjs WebSocket provider. */
 type ConnectionStatus$1 = 'disconnected' | 'connecting' | 'connected' | 'error';
+/**
+ * Presence data for a remote collaborator, sanitised from the awareness
+ * protocol. Returned by {@link sanitizePresence}; coordinates are in unscaled
+ * slide pixels, clamped to the supplied canvas bounds.
+ */
+interface SanitizedPresence {
+  clientId: number;
+  userName: string;
+  userAvatar?: string;
+  userColor: string;
+  activeSlideIndex: number;
+  cursorX: number;
+  cursorY: number;
+  lastUpdated: string;
+  selectedElementId?: string;
+  role?: CollaborationRole;
+}
 //#endregion
 //#region src/render/collaboration-presence-publisher.d.ts
 /**
@@ -11745,6 +11762,47 @@ interface CollaborationConfig {
   writeBackDebounceMs?: number;
 }
 //#endregion
+//#region src/render/text-run-style.d.ts
+/** A plain CSS style map (keys are CSS properties; binding-agnostic). */
+type RunStyle = Record<string, string | number>;
+/** One script-tagged piece of a run's text, ready for a binding's nested span. */
+interface ScriptFontPiece {
+  text: string;
+  /**
+   * CSS for a nested span wrapping `text`, or `undefined` when this piece
+   * needs no span at all (its script's font equals the run's own, so plain
+   * text renders identically). When present it carries the `fontFamily`
+   * override plus the run's own decoration subset, repeated because
+   * `text-decoration-*` does not inherit into a nested span (see
+   * `nestedTextDecorationStyle`).
+   */
+  style?: RunStyle;
+}
+//#endregion
+//#region src/render/reflection.d.ts
+/**
+ * CSS `mask-image`/`-webkit-mask-image` value plus the raw `transform` for a
+ * mirrored reflection sibling. Every value is a ready-to-apply CSS string (or
+ * `'none'` sentinel avoided - fields are omitted when the browser default
+ * already matches), so a binding can spread this directly onto its own style
+ * object with no further per-framework logic.
+ */
+interface ReflectionWrapperStyle {
+  position: 'absolute';
+  left: string;
+  /** `calc(100% + <dist>px)`: sits `@dist` px below the source element's box. */
+  top: string;
+  width: string;
+  height: string;
+  /** Mirror (`scaleY(-1)`) composed with `@sx`/`@sy`/`@kx`/`@ky`/`@rot`. */
+  transform: string;
+  /** Anchor point for the transform above, from `@algn` (default `center top`). */
+  transformOrigin: string;
+  maskImage: string;
+  WebkitMaskImage: string;
+  pointerEvents: 'none';
+}
+//#endregion
 //#region src/render/animation-timeline-build-descriptors.d.ts
 /**
  * `animation-timeline-build-descriptors` - staged-build (`p:bldChart` /
@@ -11925,6 +11983,272 @@ type AnimationApplyGroup = 'entrance' | 'emphasis' | 'exit' | 'motionPath';
 type SlideTemplateId = 'title' | 'titleAndContent' | 'sectionHeader' | 'agenda' | 'twoContent' | 'comparison' | 'quote' | 'timeline' | 'keyMetrics' | 'titleOnly' | 'blank' | 'closing';
 /** The unit system used for ruler display. */
 type RulerUnit = 'inches' | 'centimetres';
+/** Framework-neutral picture-bullet source, sizing, and accessible fallback. */
+interface PictureBulletMarker {
+  src?: string;
+  sizePx: number;
+  fallbackMarker: string;
+  accessibleLabel: string;
+  imageRelId?: string;
+}
+//#endregion
+//#region src/render/text-run-meta.d.ts
+/** A run's resolved hyperlink target. */
+interface RunHyperlink {
+  /**
+   * The URL to hand a click handler. For an internal `ppaction://hlinksldjump`
+   * the resolved slide index is appended as a `slideIndex` query parameter, so
+   * the target survives a callback whose only argument is the URL (see
+   * `parsePpactionUrl`, which reads it back off).
+   */
+  url: string;
+  /**
+   * A safe, renderable `href` for a plain `<a>`, or `undefined` when the target
+   * is an internal `ppaction://` action or fails the URL safety check. A
+   * binding with no click handler renders the run as text in that case, which
+   * is what every binding did for every link before this field existed.
+   */
+  href?: string;
+  /** `a:hlinkClick/@tooltip`, for the anchor's `title`. */
+  tooltip?: string;
+  /**
+   * `<a target>` for a real (non-`ppaction://`) hyperlink, from
+   * `a:hlinkClick/@tgtFrame` when authored, else `_blank` (every binding's
+   * pre-existing hardcoded default). Only meaningful alongside {@link href}.
+   */
+  target?: string;
+  /** `<a rel>` paired with {@link target} (see `resolveHyperlinkTargetAttrs`). */
+  rel?: string;
+  /** Resolved target slide for an internal slide jump. */
+  targetSlideIndex?: number;
+  /**
+   * True when the target came from `a:hlinkMouseOver` rather than
+   * `a:hlinkClick`: PowerPoint follows it on hover, not on click, so a binding
+   * that renders a plain anchor should not make it look clickable.
+   */
+  onHover?: boolean;
+}
+/** An inline equation run (`m:oMath`), rendered as MathML rather than text. */
+interface RunEquation {
+  /** The raw OMML node, for `convertOmmlToMathMl`. */
+  xml: Record<string, unknown>;
+  /** Display number for a numbered equation, without its parentheses. */
+  number?: string;
+}
+//#endregion
+//#region src/render/text-run-ruby.d.ts
+/** A run's phonetic guide, ready to render as `<rt>` above the base text. */
+interface RunRuby {
+  /** The annotation itself (`a:ruby/a:rt`), e.g. the furigana reading. */
+  text: string;
+  /** Inline style for the `<rt>` element (size, family, alignment, colour). */
+  style: RunStyle;
+}
+//#endregion
+//#region src/render/text-tab-run-build.d.ts
+/** One tabbed-line piece, ready to spread onto a binding's own span element. */
+interface TabbedRunPiece {
+  text: string;
+  /**
+   * CSS for the span that wraps `text`: inline-block layout, this run's own
+   * decoration repeated, and this piece's own PowerPoint advance-width
+   * correction as `letter-spacing` (see `buildTabbedLine`). The piece is
+   * nested inside the run's own span, and neither property inherits the way a
+   * caller would want: `text-decoration-*` does not inherit into a nested
+   * element at all (an ancestor's underline is drawn *through* its
+   * descendants, but each descendant still computes `none` of its own), so a
+   * caller passes the run's decoration subset (`nestedTextDecorationStyle`) to
+   * have it repeated here; `letter-spacing` DOES inherit, which is exactly why
+   * this piece sets it explicitly rather than only when non-zero - the run's
+   * container span carries its own (wrong, whole-text) correction that would
+   * otherwise leak in.
+   */
+  style: RunStyle;
+  /** CSS for the leader-fill span preceding this piece, or `undefined` when there is no gap to fill. */
+  leaderStyle?: RunStyle;
+  /** Leader glyphs sized to fill `leaderStyle`'s width. Present only alongside `leaderStyle`. */
+  leaderText?: string;
+  /**
+   * `a:rPr/@u="words"` per-word/gap sub-pieces of THIS tab piece's own text
+   * (see `splitWordsForUnderline`), present only when the run's underline is
+   * `words`. A tab-separated piece is otherwise rendered as a single span
+   * (`text` + `style`), which underlines it continuously - correct for a
+   * one-word piece, but wrong for a piece like `"Hello World"` between two tab
+   * stops, which needs a gap under the space. A binding renders one SIBLING
+   * span per entry IN PLACE OF the piece's single `text` span: each entry's
+   * `style` is the piece's own `style` (the same inline-block layout and
+   * advance-width correction, so the line measures exactly as before), with
+   * the underline stripped on a gap entry. They must be siblings, not spans
+   * nested inside the piece span: an ancestor's underline is drawn through
+   * every inline descendant, so a nested gap could not lose it. `text`/`style`
+   * stay the continuous-underline fallback for a binding that does not
+   * render this field.
+   */
+  words?: Array<{
+    text: string;
+    style: RunStyle;
+  }>;
+}
+/** One `\n`-split line of a run's tabbed text. */
+interface TabbedLineRun {
+  pieces: TabbedRunPiece[];
+}
+//#endregion
+//#region src/render/paragraph-types.d.ts
+/** A single rendered run within a paragraph. */
+interface ParagraphRun {
+  text: string;
+  style: RunStyle;
+  /**
+   * The run's hyperlink (`a:hlinkClick` / `a:hlinkMouseOver`), when it has one.
+   * A binding renders the run inside an `<a href>` when {@link RunHyperlink.href}
+   * is set, and routes {@link RunHyperlink.url} to its click handler otherwise
+   * (internal `ppaction://` slide jumps).
+   */
+  hyperlink?: RunHyperlink;
+  /**
+   * An inline equation (`m:oMath`) this run renders INSTEAD of `text`, which is
+   * empty for it. Emitted in the run sequence so the maths lands at its
+   * authored position between the runs around it.
+   */
+  equation?: RunEquation;
+  /**
+   * The run's phonetic guide (`a:ruby`: furigana, pinyin, bopomofo), when it
+   * has one. A binding renders `<ruby>{text}<rt style>{ruby.text}</rt></ruby>`;
+   * a run carrying one is never split per word, so the annotation appears once
+   * over the whole base run.
+   *
+   * Core parsed and saved ruby from the start, but `buildParagraphs` never read
+   * it, so the annotation rendered in React alone.
+   */
+  ruby?: RunRuby;
+  /**
+   * Index of the `textSegments` entry (of the override list when one was
+   * supplied) this run was built from.
+   *
+   * Shared splits one authored run into several per-word runs for PowerPoint's
+   * metric tracking, so this is many-to-one. It is the seam a binding uses to
+   * reach the facts the neutral model does not carry - React's find-match
+   * highlights, per-script font spans, tab stops and ruby all key off the
+   * originating segment - without regrouping the segments itself and drifting
+   * from the grouping here.
+   */
+  segmentIndex?: number;
+  /**
+   * Offset of this run's `text` within its segment's RENDERED text (after field
+   * substitution), so a caller holding per-segment character offsets can map
+   * them onto the split runs.
+   */
+  charStart?: number;
+  /**
+   * Per-script (`a:ea`/`a:cs`/`a:sym`) font-fallback pieces for this run's
+   * text, when a script it contains needs a font distinct from its own. A
+   * binding renders these as nested spans in place of `text` (see
+   * `text-script-fonts.ts`); absent for the common single-font case.
+   */
+  scriptRuns?: ScriptFontPiece[];
+  /**
+   * Measured tab-stop layout for this run's text, present when it contains an
+   * authored `\t` and the paragraph declares explicit tab stops. A binding
+   * renders these lines/pieces in place of `text`, honouring per-stop
+   * alignment and leader glyphs a plain CSS `tab-size` cannot express (see
+   * `text-tab-run-build.ts`). Absent for the common no-tab case.
+   */
+  tabLines?: TabbedLineRun[];
+  /**
+   * `a:rPr/@u="words"` word/gap pieces of a RUBY run's base text, present only
+   * when such a run's underline is `words` (the ordinary per-word split emits
+   * sibling runs instead; a tab piece carries its own `words`). Same shape as
+   * `scriptRuns` and rendered the same way, in place of `text`: a word entry
+   * carries the decoration for its own span, a gap entry is bare text. The
+   * run's own `style` has the underline stripped when this is set (see
+   * `paragraph-run-build.ts`).
+   */
+  underlineWordPieces?: ScriptFontPiece[];
+  /**
+   * `a:reflection` mirrored-sibling wrapper style for this run (the text-run
+   * counterpart of a shape/picture's `ComputedEffectStyle.reflection`), or
+   * `undefined` for the common no-reflection case. A binding renders a sibling
+   * node just below the run's own, painted with the same text, positioned and
+   * masked by this style - see `render/reflection.ts`'s
+   * `getTextReflectionWrapperStyle`.
+   */
+  reflection?: ReflectionWrapperStyle;
+}
+/** A rendered paragraph: runs plus resolved bullet + hanging-indent metadata. */
+interface RenderParagraph {
+  runs: ParagraphRun[];
+  /** Bullet glyph / number to render before the runs (or `undefined`). */
+  bulletMarker?: string;
+  /** Picture marker rendered before runs, or fallback metadata when unresolved. */
+  bulletPicture?: PictureBulletMarker;
+  /** Inline style for the bullet marker (font / size / colour). */
+  bulletStyle: RunStyle;
+  /** `margin-left` in px for the whole paragraph (hanging-indent layout). */
+  marginLeftPx?: number;
+  /** `text-indent` in px (first-line / hanging indent). */
+  textIndentPx?: number;
+  /**
+   * Per-paragraph `line-height` from this paragraph's own `a:pPr > a:lnSpc`.
+   * A unitless multiplier for proportional spacing (`a:spcPct`) or a `"<n>pt"`
+   * string for exact spacing (`a:spcPts`). Undefined when the paragraph does
+   * not override spacing (binding keeps the body-level line-height).
+   */
+  lineHeight?: number | string;
+  /** `margin-top` in px from this paragraph's `a:pPr > a:spcBef` (space before). */
+  spaceBeforePx?: number;
+  /** `margin-bottom` in px from this paragraph's `a:pPr > a:spcAft` (space after). */
+  spaceAfterPx?: number;
+  /**
+   * `font-size` in px to set on the paragraph element so its CSS line boxes
+   * are built from its OWN runs rather than the text body's default size.
+   * Undefined when the paragraph already matches the body default.
+   *
+   * See `resolveParagraphStrutFontSize` for why this is needed: without it a
+   * paragraph of small runs inside a larger-defaulting body is laid out on
+   * too-tall lines and overflows its shape.
+   */
+  strutFontSizePx?: number;
+  /**
+   * True when the paragraph has no runs and no bullet: an authored blank line
+   * (`<a:p><a:endParaRPr/></a:p>`).
+   *
+   * PowerPoint gives such a paragraph a full line box, which is how decks
+   * space a heading away from the bullet list under it. A binding must render
+   * something with height for it (a `<br>`), or the gap disappears and the
+   * block reads as one dense run of text (issue #131, slides 13-14).
+   */
+  isEmpty?: boolean;
+  /**
+   * Indices of this paragraph's segments in the rendered segment list (the
+   * override list when one was supplied), in authored order and INCLUDING the
+   * bullet-marker segment the runs drop.
+   *
+   * The seam a binding uses to reach paragraph facts the neutral model does not
+   * carry, without regrouping the segments itself and drifting from the
+   * grouping here - which is exactly how React ended up splitting on every
+   * `"\n"` and treating a soft `a:br` as a paragraph break.
+   */
+  segmentIndices: number[];
+  /**
+   * True when this paragraph resolves right-to-left (`a:pPr/@rtl`, or the text
+   * body's default). A binding that mirrors its hanging indent for RTL reads
+   * this; the direction itself is already in {@link paragraphStyle}.
+   */
+  rtl?: boolean;
+  /**
+   * Extra CSS for the paragraph box, beyond the margin / indent / spacing
+   * fields above: this paragraph's own `text-align` (`a:pPr/@algn`), its BiDi
+   * `direction`, and the kinsoku line-breaking rules (`@eaLnBrk`,
+   * `@latinLnBrk`, `@hangingPunct`). Absent when the paragraph overrides none
+   * of them, which is the common case.
+   *
+   * All three used to be resolved in React's private paragraph renderer only,
+   * so a deck that centred one paragraph of a left-aligned body, or set CJK
+   * break rules, rendered differently in the other four bindings.
+   */
+  paragraphStyle?: RunStyle;
+}
 //#endregion
 //#region src/render/inline-list-types.d.ts
 /** Current editor payload. Missing segments explicitly denotes plain-text fallback. */
@@ -11933,6 +12257,15 @@ interface InlineTextEditSnapshot {
   text: string;
   textSegments?: TextSegment[];
 }
+type InlineListReadResult = {
+  kind: 'supported';
+  snapshot: InlineTextEditSnapshot;
+  paragraphs: RenderParagraph[];
+} | {
+  kind: 'unsupported';
+  reason: string;
+  text: string;
+};
 //#endregion
 //#region src/render/text-field-substitution.d.ts
 /**
@@ -12179,6 +12512,12 @@ interface ShapeAdjustmentDragState {
    */
   startAdjustments?: Record<string, number>;
 }
+interface CollaborationShellState {
+  canEdit: boolean;
+  status: ConnectionStatus$1;
+  remoteUsers: readonly SanitizedPresence[];
+  connectedCount: number;
+}
 //#endregion
 //#region src/render/collaboration-text-codec.d.ts
 /**
@@ -12203,6 +12542,62 @@ interface YTextLike {
   toString: () => string;
 }
 //#endregion
+//#region src/render/collaboration-text-merge.d.ts
+/** Y.Text surface needed for in-place edits (delete/format on top of insert). */
+interface YTextEditableLike extends YTextLike {
+  delete: (index: number, length: number) => void;
+  format: (index: number, length: number, attributes: Record<string, string | null>) => void;
+}
+//#endregion
+//#region src/render/collaboration-text-positions.d.ts
+interface TextPositionCell {
+  index: number;
+  left?: TextPositionCell;
+  right?: TextPositionCell;
+}
+interface TrackedTextPosition {
+  /** Internal identity, shared by snapshots that observed the same character. */
+  readonly cell: TextPositionCell;
+  readonly association: number;
+}
+//#endregion
+//#region src/render/collaboration-text-session-delta.d.ts
+/** Browser edit range mapped to the editor's pre-input encoded coordinates. */
+interface LocalTextReplacement {
+  from: number;
+  to: number;
+}
+/** Desired UTF-16 units mapped to the editor's previously observed identities. */
+interface TextSessionCorrespondence {
+  readonly retainedIndices: readonly (number | null)[];
+  /** Old carriers for known paragraph attributes, independently of character identity. */
+  readonly paragraphSources?: readonly (number | null)[];
+}
+type LocalTextEdit = LocalTextReplacement | TextSessionCorrespondence;
+//#endregion
+//#region src/render/collaboration-text-session.d.ts
+/** Supplied by the binding's existing Yjs runtime, bound to this exact Y.Text. */
+interface TextSessionPositions<Position> {
+  capture: (index: number, association: number) => Position;
+  resolve: (position: Position) => number | null;
+  /** Synchronize tracked positions once per batch, including in-transaction writes. */
+  refresh?: () => boolean | void;
+  /** Release only resources created for this session. */
+  dispose?: () => void;
+}
+/** Opaque acknowledgement identity for an exact remote snapshot painted by an adapter. */
+interface CollaborationTextSnapshot {
+  readonly delta: readonly DeltaOp[];
+}
+interface CollaborationTextSession {
+  applyLocalDelta: (delta: readonly DeltaOp[], edit?: LocalTextEdit) => boolean;
+  readMerged: () => CollaborationTextSnapshot | undefined;
+  adoptMerged: (snapshot: CollaborationTextSnapshot) => boolean;
+  /** Capture an offset in the last painted/local draft, not the newer remote string. */
+  bookmark: (index: number, association: number) => () => number | null;
+  dispose: () => void;
+}
+//#endregion
 //#region src/render/collaboration-sync.d.ts
 interface YMapLike {
   get: (key: string) => unknown;
@@ -12236,6 +12631,8 @@ interface YjsFactories {
   createMap: () => YMapLike;
   createArray: () => YArrayLike;
   createText: () => YTextLike;
+  /** Track character identities using the binding's existing Yjs runtime. */
+  createTextPositions?: (text: YTextEditableLike) => TextSessionPositions<TrackedTextPosition>;
 }
 //#endregion
 //#region src/render/collaboration-live-patch-target.d.ts
@@ -12252,7 +12649,20 @@ interface LiveTextSource {
   textSegments?: TextSegment[];
   textStyle?: TextStyle;
 }
+//#endregion
+//#region src/render/collaboration-text-target.d.ts
+interface CollaborationInlineSnapshot extends CollaborationTextSnapshot {
+  readonly inline: InlineTextEditSnapshot;
+}
+/** A mounted editor owns this handle, never the document or its provider. */
+interface CollaborationTextTarget extends CollaborationTextSession {
+  readMerged: () => CollaborationInlineSnapshot | undefined;
+  /** A bookmark follows character identity rather than a mutable numeric offset. */
+  bookmark: (index: number, association: number) => () => number | null;
+}
 interface CollaborationLivePatcher {
+  /** Bind a mounted native editor; its handle must be disposed on unmount. */
+  beginTextEdit?: (slideId: string | undefined, elementId: string, onChange?: () => void, ownsModel?: (element: PptxElement) => boolean) => CollaborationTextTarget | undefined;
   /** Attach a live doc (or `null` to go dormant). Pending patches are dropped. */
   configure: (doc: YDocLike | null, factories: YjsFactories | null,
   /** Publish synchronously when the host may revoke write readiness at any time. */
@@ -13594,6 +14004,23 @@ interface ToolbarProps {
   onQuickCommand?: (id: string) => void;
 }
 //#endregion
+//#region src/viewer/hooks/useInlineEditingState.d.ts
+interface PendingInlineEditReader {
+  elementId: string;
+  read: () => InlineListReadResult;
+}
+interface InlineEditingState {
+  inlineEditingElementId: string | null;
+  setInlineEditingElementId: Dispatch<SetStateAction<string | null>>;
+  inlineEditingText: string;
+  setInlineEditingText: (value: SetStateAction<string>, snapshot?: InlineTextEditSnapshot) => void;
+  inlineEditingElementIdRef: MutableRefObject<string | null>;
+  inlineEditingTextRef: MutableRefObject<string>;
+  inlineEditingSnapshotRef: MutableRefObject<InlineTextEditSnapshot | undefined>;
+  inlineEditingReaderRef?: MutableRefObject<PendingInlineEditReader | undefined>;
+  registerInlineEditReader?: (elementId: string, read: () => InlineListReadResult) => () => void;
+}
+//#endregion
 //#region src/viewer/hooks/canvas-interaction-types.d.ts
 /**
  * Shared type for canvas interaction handler signatures.
@@ -13790,6 +14217,7 @@ interface UseCanvasInteractionsInput {
   inlineEditingText: string;
   inlineEditingTextRef?: React.MutableRefObject<string>;
   inlineEditingSnapshotRef?: React.MutableRefObject<InlineTextEditSnapshot | undefined>;
+  inlineEditingReaderRef?: React.MutableRefObject<PendingInlineEditReader | undefined>;
   ops: ElementOperations;
   history: EditorHistoryResult;
   presentationHandleAction: (action: Record<string, unknown>) => void;
@@ -14525,17 +14953,6 @@ interface ViewerDialogsResult {
 //#region src/viewer/hooks/useViewerDialogs.d.ts
 declare function useViewerDialogs(input: UseViewerDialogsInput): ViewerDialogsResult;
 //#endregion
-//#region src/viewer/hooks/useInlineEditingState.d.ts
-interface InlineEditingState {
-  inlineEditingElementId: string | null;
-  setInlineEditingElementId: Dispatch<SetStateAction<string | null>>;
-  inlineEditingText: string;
-  setInlineEditingText: (value: SetStateAction<string>, snapshot?: InlineTextEditSnapshot) => void;
-  inlineEditingElementIdRef: MutableRefObject<string | null>;
-  inlineEditingTextRef: MutableRefObject<string>;
-  inlineEditingSnapshotRef: MutableRefObject<InlineTextEditSnapshot | undefined>;
-}
-//#endregion
 //#region src/viewer/hooks/viewer-core-state-types.d.ts
 /**
  * Input parameters for the {@link useViewerCoreState} hook.
@@ -14982,6 +15399,9 @@ interface ZoomViewport {
   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;
@@ -15178,8 +15598,10 @@ interface UseAutosaveResult {
 }
 declare function useAutosave(input: UseAutosaveInput): UseAutosaveResult;
 //#endregion
-//#region src/viewer/hooks/useViewerBuildingBlocks.d.ts
+//#region src/viewer/hooks/useViewerBuildingBlocks-types.d.ts
 interface UseViewerBuildingBlocksInput extends ViewportFitOptions {
+  /** Optional collaboration, including a host-owned document and presence session. */
+  collaboration?: CollaborationConfig;
   /** 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). */
@@ -15195,7 +15617,7 @@ interface UseViewerBuildingBlocksInput extends ViewportFitOptions {
   /** 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.ForwardedRef<PowerPointViewerHandle>;
+  handle?: React$1.ForwardedRef<PowerPointViewerHandle>;
   onContentChange?: (content: Uint8Array) => void;
   onDirtyChange?: (dirty: boolean) => void;
   onActiveSlideChange?: (index: number) => void;
@@ -15211,6 +15633,15 @@ interface UseViewerBuildingBlocksInput extends ViewportFitOptions {
   onOpenShareDialog?: () => 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. */
@@ -15224,6 +15655,8 @@ interface ViewerBuildingBlocksResult {
   /** Current autosave-to-localStorage recovery status. */
   autosaveStatus: AutosaveStatus;
 }
+//#endregion
+//#region src/viewer/hooks/useViewerBuildingBlocks.d.ts
 declare function useViewerBuildingBlocks(input: UseViewerBuildingBlocksInput): ViewerBuildingBlocksResult;
 
 //#region src/viewer/hooks/useThemeSwitching.d.ts
@@ -15946,6 +16379,7 @@ interface UseSerializeInput {
   inlineEditingElementIdRef: React$1.MutableRefObject<string | null>;
   inlineEditingTextRef: React$1.MutableRefObject<string>;
   inlineEditingSnapshotRef?: React$1.MutableRefObject<InlineTextEditSnapshot | undefined>;
+  inlineEditingReaderRef?: React$1.MutableRefObject<PendingInlineEditReader | undefined>;
   transformCommittedText?: (text: string) => string;
   password?: string;
   /**