ooxml-core 0.10.0 → 0.12.0

package/dist/pptx/automation/index.d.ts

@@ -0,0 +1,1474 @@
+import { $i as PptxChartMarkerSymbol, $t as PptxCustomProperty, C as PptxSlide, Co as PptxThemeColorRef, Ct as PptxElement, Et as PptxElementWithText, Hi as PptxChartErrBars, Jt as PptxAppProperties, Qt as PptxCoreProperties, at as PptxThemeFontScheme, d as PptxData, dr as ParsedTableStyleBorders, io as TextSegment, pr as ParsedTableStyleFill, to as ShapeStyle, tt as PptxThemeColorScheme, ut as ChartPptxElement, va as PptxChartUserShape, x as PptxPresentationProperties, xr as PptxTableCell3D, yr as ParsedTableStyleText } from "../chunks/text-operations-2tKzrY5o.js";
+import { Nf as OlePayloadEditorKind, Yi as TableStylePartName, gf as OleNestedDeckSlideDetail, kf as OleSheetGrid, xt as ChartAxisEdit } from "../chunks/index-LoCVDu8Z.js";
+import { C as PptxJsonAssetStats, yt as PresentationDiff } from "../chunks/index-BWRd8p4y.js";
+import { Doc, Text } from "yjs";
+declare namespace types_d_exports {
+  export { CollaborationProvider, ExecutionContext, FileSystemProvider, PptxData, PptxElement, PptxSlide, TableStyleSaveOptions, ToolContext, ToolResult, ViewerProvider };
+}
+/**
+ * Platform-agnostic context passed to every tool function.
+ * No Electron, no RoomManager, no framework dependencies.
+ */
+export interface ToolContext {
+  /** Current presentation data (parsed PptxData from pptx-viewer-core). */
+  pptxData: PptxData;
+  /** Optional: resolve external image paths to binary data. */
+  resolveImage?: (path: string) => Promise<Uint8Array>;
+  /** Optional: resolve external media paths to binary data. */
+  resolveMedia?: (path: string) => Promise<Uint8Array>;
+}
+/**
+ * Save-time instructions that don't live on `pptxData` itself and so cannot
+ * be expressed as a model mutation: today, only `ppt/tableStyles.xml`'s
+ * archive-level "repoint the default style" / "delete a style" operations
+ * (`set_default_table_style`, `delete_table_style`). Mirrors the same-named
+ * fields on `pptx-viewer-core`'s save options structurally (not imported, so
+ * a tool result stays independent of the core package's internal type
+ * export surface).
+ */
+export interface TableStyleSaveOptions {
+  /** GUID to set as `ppt/tableStyles.xml`'s `<a:tblStyleLst @def>`. */
+  tableStylesDefaultId?: string;
+  /** GUIDs to remove from `ppt/tableStyles.xml` entirely. */
+  tableStylesToDelete?: string[];
+}
+/**
+ * Every tool function returns this.
+ * The consumer decides what to do with the mutated pptxData.
+ */
+export interface ToolResult<T = unknown> {
+  /** The (potentially mutated) presentation data. */
+  pptxData: PptxData;
+  /** Tool-specific return value (e.g., slide info, element ID, search results). */
+  result: T;
+  /** Whether pptxData was modified (signals need to save). */
+  dirty: boolean;
+  /**
+   * Extra `handler.save()` instructions this result requires beyond the
+   * ordinary `pptxData` mutation, merged in by `savePresentation` /
+   * `executeToolWithContext`. See {@link TableStyleSaveOptions}.
+   */
+  saveOptions?: TableStyleSaveOptions;
+}
+/**
+ * Abstraction for Y.Doc room management.
+ * fz-electron implements this with RoomManager.
+ */
+export interface CollaborationProvider {
+  /** Get an active collaboration room for a file path, or null. */
+  getRoom(filePath: string): {
+    ydoc: Doc;
+  } | null;
+  /** Get the format codec for a file path, or null. */
+  getCodec(filePath: string): {
+    hydrate(ydoc: Doc, bytes: Uint8Array, origin?: string): Promise<void>;
+    dehydrate(ydoc: Doc): Promise<Uint8Array>;
+  } | null;
+  /** Create an agent origin tag for undo isolation. */
+  agentOrigin(name: string): string;
+}
+/**
+ * Abstraction for file system access.
+ * fz-electron implements this with window.electron.files.
+ * MCP server implements this with node:fs.
+ */
+export interface FileSystemProvider {
+  readFile(path: string): Promise<Uint8Array>;
+  writeFile(path: string, data: Uint8Array): Promise<void>;
+}
+/**
+ * Abstraction for updating an open file viewer.
+ * Only fz-electron implements this.
+ */
+export interface ViewerProvider {
+  replaceContent(filePath: string, bytes: Uint8Array, options: {
+    markDirty: boolean;
+    mimeType?: string;
+  }): void;
+  openFile(filePath: string): Promise<void>;
+}
+/**
+ * Full execution context for running tools with collaboration support.
+ */
+export interface ExecutionContext {
+  /** File system for reading/writing PPTX files. */
+  filesystem: FileSystemProvider;
+  /** Optional collaboration provider for Y.Doc routing. */
+  collaboration?: CollaborationProvider;
+  /** Optional viewer integration for live document updates. */
+  viewer?: ViewerProvider;
+  /** Agent name for collaboration origin tracking. */
+  agentName?: string;
+}
+declare namespace slide_tools_d_exports {
+  export { AddSlideParams, AddSlideResult, DeleteSlidesParams, DeleteSlidesResult, DuplicateSlideParams, GetSlideResult, ReorderSlidesParams, SetCanvasSizeParams, SetSlideTransitionParams, UpdateSlidePropertiesParams, addSlide, deleteSlides, duplicateSlide, getSlide, reorderSlides, setCanvasSize, setSlideTransition, updateSlideProperties };
+}
+interface GetSlideResult {
+  slideIndex: number;
+  slideNumber: number;
+  hidden: boolean;
+  layoutName?: string;
+  backgroundColor?: string;
+  notes: string;
+  commentCount: number;
+  elements: Record<string, unknown>[];
+}
+export declare function getSlide(ctx: ToolContext, params: {
+  slideIndex: number;
+}): ToolResult<GetSlideResult>;
+interface AddSlideParams {
+  insertAfterIndex?: number;
+  backgroundColor?: string;
+}
+interface AddSlideResult {
+  newSlideIndex: number;
+  slideCount: number;
+}
+export declare function addSlide(ctx: ToolContext, params: AddSlideParams): ToolResult<AddSlideResult>;
+interface DeleteSlidesParams {
+  slideIndexes: number[];
+}
+interface DeleteSlidesResult {
+  deletedCount: number;
+  slideCount: number;
+}
+export declare function deleteSlides(ctx: ToolContext, params: DeleteSlidesParams): ToolResult<DeleteSlidesResult>;
+interface ReorderSlidesParams {
+  newOrder: number[];
+}
+export declare function reorderSlides(ctx: ToolContext, params: ReorderSlidesParams): ToolResult<{
+  slideCount: number;
+}>;
+interface DuplicateSlideParams {
+  slideIndex: number;
+  targetIndex?: number;
+}
+export declare function duplicateSlide(ctx: ToolContext, params: DuplicateSlideParams): ToolResult<{
+  newSlideIndex: number;
+  slideCount: number;
+}>;
+interface UpdateSlidePropertiesParams {
+  slideIndex: number;
+  backgroundColor?: string;
+  backgroundGradient?: string;
+  backgroundImage?: string;
+  notes?: string;
+  hidden?: boolean;
+}
+export declare function updateSlideProperties(ctx: ToolContext, params: UpdateSlidePropertiesParams): ToolResult<{
+  slideIndex: number;
+}>;
+interface SetSlideTransitionParams {
+  slideIndex: number;
+  type: string;
+  durationMs?: number;
+  direction?: string;
+  advanceOnClick?: boolean;
+  advanceAfterMs?: number;
+}
+export declare function setSlideTransition(ctx: ToolContext, params: SetSlideTransitionParams): ToolResult<{
+  slideIndex: number;
+  transitionType: string;
+}>;
+interface SetCanvasSizeParams {
+  width: number;
+  height: number;
+}
+export declare function setCanvasSize(ctx: ToolContext, params: SetCanvasSizeParams): ToolResult<{
+  canvasWidth: number;
+  canvasHeight: number;
+}>;
+declare namespace helpers_d_exports {
+  export { describeElement, extractSlideText, generateElementId, generateSlideId, validateSlideIndex };
+}
+export declare function generateElementId(): string;
+export declare function generateSlideId(): string;
+/** Build a concise text representation of a slide element for tool output. */
+export declare function describeElement(el: PptxElement): Record<string, unknown>;
+/** Extract text from a slide's elements for search purposes. */
+export declare function extractSlideText(slide: PptxSlide): string;
+/** Validate slideIndex is within range, return error string or null. */
+export declare function validateSlideIndex(slideIndex: number, slideCount: number): string | null;
+declare namespace element_tools_d_exports {
+  export { AddElementParams, AddElementResult, ArrangeElementsParams, BatchUpdateElementsParams, CloneElementParams, CloneElementResult, DeleteElementsParams, GroupElementsParams, GroupElementsResult, RenameElementParams, SetElementAnimationParams, UngroupElementsParams, UngroupElementsResult, UpdateElementParams, addElement, arrangeElements, batchUpdateElements, cloneElement, deleteElements, groupElements, renameElement, setElementAnimation, ungroupElements, updateElement };
+}
+interface AddElementParams {
+  slideIndex: number;
+  type: 'text' | 'shape' | 'image' | 'table' | 'connector';
+  x?: number;
+  y?: number;
+  width?: number;
+  height?: number;
+  text?: string;
+  fontSize?: number;
+  fontFamily?: string;
+  fontColor?: string;
+  bold?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  alignment?: 'left' | 'center' | 'right' | 'justify';
+  shapeType?: string;
+  fillColor?: string;
+  strokeColor?: string;
+  strokeWidth?: number;
+  imageData?: string;
+  altText?: string;
+  rows?: number;
+  columns?: number;
+  cellData?: string[][];
+  headerRow?: boolean;
+  startArrow?: string;
+  endArrow?: string;
+  startShapeId?: string;
+  endShapeId?: string;
+}
+interface AddElementResult {
+  elementId: string;
+  slideIndex: number;
+}
+export declare function addElement(ctx: ToolContext, params: AddElementParams): ToolResult<AddElementResult>;
+interface UpdateElementParams {
+  slideIndex: number;
+  elementId: string;
+  x?: number;
+  y?: number;
+  width?: number;
+  height?: number;
+  rotation?: number;
+  text?: string;
+  textSegments?: TextSegment[];
+  fontSize?: number;
+  fontFamily?: string;
+  fontColor?: string;
+  /**
+   * A theme colour for the run text (`{ scheme: 'accent1', lumMod: 0.8 }`).
+   * Wins on save (`<a:schemeClr>` instead of a canonical `<a:srgbClr>`), and
+   * resolves `fontColor` immediately when `fontColor` was not also given.
+   * Passing `fontColor` alone clears a previously-set text theme colour.
+   */
+  fontThemeColor?: PptxThemeColorRef;
+  bold?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  alignment?: 'left' | 'center' | 'right' | 'justify';
+  fillColor?: string;
+  strokeColor?: string;
+  strokeWidth?: number;
+  opacity?: number;
+  hidden?: boolean;
+  flipH?: boolean;
+  flipV?: boolean;
+  /** Accessibility description; see {@link applyElementAltText} for the accepted kinds. */
+  altText?: string;
+  /** Accessibility title; see {@link applyElementTitle} for the accepted kinds. */
+  title?: string;
+}
+export declare function updateElement(ctx: ToolContext, params: UpdateElementParams): ToolResult<{
+  elementId: string;
+}>;
+interface RenameElementParams {
+  slideIndex: number;
+  elementId: string;
+  /** New element name (`cNvPr/@name`); an empty string clears the name. */
+  name: string;
+}
+export declare function renameElement(ctx: ToolContext, params: RenameElementParams): ToolResult<{
+  elementId: string;
+  name: string;
+}>;
+interface DeleteElementsParams {
+  slideIndex: number;
+  elementIds: string[];
+}
+export declare function deleteElements(ctx: ToolContext, params: DeleteElementsParams): ToolResult<{
+  deletedCount: number;
+}>;
+interface ArrangeElementsParams {
+  slideIndex: number;
+  action: 'align' | 'reorderLayer';
+  elementIds?: string[];
+  alignment?: 'left' | 'right' | 'top' | 'bottom' | 'centerH' | 'centerV';
+  elementId?: string;
+  layerAction?: 'bringToFront' | 'sendToBack' | 'bringForward' | 'sendBackward';
+}
+export declare function arrangeElements(ctx: ToolContext, params: ArrangeElementsParams): ToolResult<{
+  slideIndex: number;
+}>;
+interface CloneElementParams {
+  slideIndex: number;
+  elementId: string;
+  targetSlideIndexes?: number[];
+  offsetX?: number;
+  offsetY?: number;
+}
+interface CloneElementResult {
+  clonedIds: string[];
+}
+export declare function cloneElement(ctx: ToolContext, params: CloneElementParams): ToolResult<CloneElementResult>;
+interface SetElementAnimationParams {
+  slideIndex: number;
+  elementId: string;
+  entrance?: string;
+  exit?: string;
+  durationMs?: number;
+  delayMs?: number;
+  order?: number;
+}
+export declare function setElementAnimation(ctx: ToolContext, params: SetElementAnimationParams): ToolResult<{
+  elementId: string;
+}>;
+interface GroupElementsParams {
+  slideIndex: number;
+  elementIds: string[];
+}
+interface GroupElementsResult {
+  groupId: string;
+}
+export declare function groupElements(ctx: ToolContext, params: GroupElementsParams): ToolResult<GroupElementsResult>;
+interface UngroupElementsParams {
+  slideIndex: number;
+  groupElementId: string;
+}
+interface UngroupElementsResult {
+  restoredIds: string[];
+}
+export declare function ungroupElements(ctx: ToolContext, params: UngroupElementsParams): ToolResult<UngroupElementsResult>;
+interface BatchUpdateElementsParams {
+  slideIndex: number;
+  elementIds: string[];
+  x?: number;
+  y?: number;
+  width?: number;
+  height?: number;
+  rotation?: number;
+  opacity?: number;
+  hidden?: boolean;
+}
+export declare function batchUpdateElements(ctx: ToolContext, params: BatchUpdateElementsParams): ToolResult<{
+  updatedCount: number;
+}>;
+declare namespace table_tools_d_exports {
+  export { ManageTableStructureParams, UpdateTableCellsParams, manageTableStructure, updateTableCells };
+}
+interface UpdateTableCellsParams {
+  slideIndex: number;
+  elementId: string;
+  cells: Array<{
+    row: number;
+    col: number;
+    text: string;
+  }>;
+}
+export declare function updateTableCells(ctx: ToolContext, params: UpdateTableCellsParams): ToolResult<{
+  updatedCount: number;
+}>;
+interface ManageTableStructureParams {
+  slideIndex: number;
+  elementId: string;
+  action: 'insertRow' | 'deleteRow' | 'insertColumn' | 'deleteColumn';
+  position?: number;
+  referenceIndex?: number;
+  cellTexts?: string[];
+}
+export declare function manageTableStructure(ctx: ToolContext, params: ManageTableStructureParams): ToolResult<{
+  rowCount: number;
+  columnCount: number;
+}>;
+declare namespace table_style_tools_d_exports {
+  export { AssignTableStyleParams, CreateTableStyleParams, DeleteTableStyleParams, SetTableStyleSectionParams, assignTableStyle, createTableStyle, deleteTableStyle, setTableStyleSection };
+}
+interface SetTableStyleSectionParams {
+  styleId: string;
+  section: TableStylePartName;
+  styleName?: string;
+  fill?: ParsedTableStyleFill;
+  text?: ParsedTableStyleText;
+  borders?: ParsedTableStyleBorders;
+  cell3D?: PptxTableCell3D;
+}
+/**
+ * Patch one facet (fill/text/borders/cell3D) of one `CT_TableStyle` section
+ * on an EXISTING style in `pptxData.tableStyleMap`. Facets not supplied are
+ * left untouched (matches `applyTableStyleEntryToNode`'s merge semantics).
+ * Throws if `styleId` names no loaded style: use `create_table_style` first.
+ */
+export declare function setTableStyleSection(ctx: ToolContext, params: SetTableStyleSectionParams): ToolResult<{
+  styleId: string;
+  section: TableStylePartName;
+}>;
+interface CreateTableStyleParams {
+  styleName: string;
+  /** Deep-clone every section from this existing style GUID as the starting point. */
+  basedOnStyleId?: string;
+  /** Repoint `ppt/tableStyles.xml`'s `@def` at the new style on save. */
+  setAsDefault?: boolean;
+}
+export declare function createTableStyle(ctx: ToolContext, params: CreateTableStyleParams): ToolResult<{
+  styleId: string;
+}>;
+interface DeleteTableStyleParams {
+  styleId: string;
+  /** Delete even though a table on some slide still references this style. */
+  force?: boolean;
+}
+export declare function deleteTableStyle(ctx: ToolContext, params: DeleteTableStyleParams): ToolResult<{
+  deleted: boolean;
+}>;
+interface AssignTableStyleParams {
+  slideIndex: number;
+  elementId: string;
+  /**
+   * Defaults to `pptxData.tableStylesDefaultId` (the deck's current
+   * `ppt/tableStyles.xml/a:tblStyleLst/@def`) when omitted, matching what
+   * PowerPoint's "Insert > Table" applies without an explicit style choice.
+   */
+  styleId?: string;
+  bandedRows?: boolean;
+  bandedColumns?: boolean;
+  firstRowHeader?: boolean;
+  lastRow?: boolean;
+  firstCol?: boolean;
+  lastCol?: boolean;
+}
+/**
+ * Assign a table style (and, optionally, the row/column emphasis flags that
+ * decide which of its sections actually show) to an EXISTING table element.
+ * `tableData.tableStyleId` already round-trips through the save pipeline for
+ * both new and previously-loaded tables (`save-table-merge-helpers.ts`); this
+ * tool just exposes that assignment over MCP.
+ */
+export declare function assignTableStyle(ctx: ToolContext, params: AssignTableStyleParams): ToolResult<{
+  elementId: string;
+  styleId: string;
+}>;
+declare namespace style_tools_d_exports {
+  export { ALT_TEXT_ELEMENT_TYPES, AccessibilityCheckResult, AccessibilityIssue, TITLE_ELEMENT_TYPES, UpdateElementStyleParams, applyElementAltText, applyElementTitle, runAccessibilityCheck, updateElementStyle };
+}
+interface UpdateElementStyleParams {
+  slideIndex: number;
+  elementId: string;
+  fillColor?: string;
+  /**
+   * A theme colour for the fill (`{ scheme: 'accent1', lumMod: 0.8 }`).
+   * Wins on save: the shape is written as `<a:schemeClr>` instead of a
+   * canonical `<a:srgbClr>`, so it keeps following the theme after a later
+   * theme change. Also resolves `fillColor` immediately (against the
+   * deck's `themeColorMap`) when `fillColor` was not explicitly given.
+   * Passing `fillColor` alone (no `fillThemeColor`) clears any previously
+   * set fill theme colour, matching a user typing a custom hex.
+   */
+  fillThemeColor?: PptxThemeColorRef;
+  fillMode?: ShapeStyle['fillMode'];
+  fillGradientStops?: Array<{
+    color: string;
+    position: number;
+    opacity?: number;
+  }>;
+  fillGradientAngle?: number;
+  fillGradientType?: 'linear' | 'radial';
+  fillOpacity?: number;
+  strokeColor?: string;
+  /** A theme colour for the outline; see {@link fillThemeColor}. */
+  strokeThemeColor?: PptxThemeColorRef;
+  strokeWidth?: number;
+  strokeDash?: ShapeStyle['strokeDash'];
+  strokeOpacity?: number;
+  shadowColor?: string;
+  shadowBlur?: number;
+  shadowOffsetX?: number;
+  shadowOffsetY?: number;
+  shadowOpacity?: number;
+  glowColor?: string;
+  glowRadius?: number;
+  glowOpacity?: number;
+  softEdgeRadius?: number;
+  cropLeft?: number;
+  cropTop?: number;
+  cropRight?: number;
+  cropBottom?: number;
+  brightness?: number;
+  contrast?: number;
+  grayscale?: boolean;
+  /**
+   * Accessibility description (`p:cNvPr/@descr`). Accepted for pictures,
+   * every graphic frame kind (table, chart, smartArt, ole, media), and a
+   * plain shape / text box / connector: the core writer serialises all
+   * eight kinds, so the tool must not stop at images.
+   */
+  altText?: string;
+  /**
+   * Accessibility title (`p:cNvPr/@title`). Accepted for every kind that
+   * models it: table, chart, smartArt, ole, media, text, shape and
+   * connector (a picture has no separate title field, only `altText`).
+   */
+  title?: string;
+}
+/** Element kinds whose core type models `altText` and whose writer persists it. */
+declare const ALT_TEXT_ELEMENT_TYPES: ReadonlySet<PptxElement['type']>;
+/** Element kinds whose core type models `title` and whose writer persists it. */
+declare const TITLE_ELEMENT_TYPES: ReadonlySet<PptxElement['type']>;
+/**
+ * Write `altText` onto `el`, or throw when the element kind has nowhere to
+ * persist it.
+ */
+declare function applyElementAltText(el: PptxElement, altText: string): void;
+/**
+ * Write `title` onto `el`, or throw when the element kind has nowhere to
+ * persist it (a picture's `p:cNvPr` only ever carries `@descr`, not `@title`).
+ */
+declare function applyElementTitle(el: PptxElement, title: string): void;
+export declare function updateElementStyle(ctx: ToolContext, params: UpdateElementStyleParams): ToolResult<{
+  elementId: string;
+}>;
+interface AccessibilityIssue {
+  slideIndex: number;
+  elementId?: string;
+  severity: 'error' | 'warning' | 'info';
+  message: string;
+}
+interface AccessibilityCheckResult {
+  slideCount: number;
+  totalIssues: number;
+  errorCount: number;
+  warningCount: number;
+  infoCount: number;
+  issues: AccessibilityIssue[];
+}
+export declare function runAccessibilityCheck(ctx: ToolContext): ToolResult<AccessibilityCheckResult>;
+declare namespace content_tools_d_exports {
+  export { CommentInfo, FindTextParams, FindTextResult, ManageCommentsParams, ManageCommentsResult, ReplaceTextParams, ReplaceTextResult, TextMatch, findText, manageComments, replaceText };
+}
+interface FindTextParams {
+  query: string;
+  useRegex?: boolean;
+  caseSensitive?: boolean;
+  slideIndexes?: number[];
+}
+interface TextMatch {
+  slideIndex: number;
+  elementId: string;
+  elementType: string;
+  matchedText: string;
+  context: string;
+}
+interface FindTextResult {
+  query: string;
+  matchCount: number;
+  matches: TextMatch[];
+}
+export declare function findText(ctx: ToolContext, params: FindTextParams): ToolResult<FindTextResult>;
+interface ReplaceTextParams {
+  query: string;
+  replacement: string;
+  useRegex?: boolean;
+  caseSensitive?: boolean;
+  slideIndexes?: number[];
+}
+interface ReplaceTextResult {
+  query: string;
+  replacement: string;
+  replacementCount: number;
+}
+export declare function replaceText(ctx: ToolContext, params: ReplaceTextParams): ToolResult<ReplaceTextResult>;
+interface ManageCommentsParams {
+  action: 'list' | 'add' | 'delete' | 'resolve';
+  slideIndex?: number;
+  text?: string;
+  author?: string;
+  commentId?: string;
+  resolved?: boolean;
+  includeResolved?: boolean;
+}
+interface CommentInfo {
+  id: string;
+  slideIndex: number;
+  text: string;
+  author?: string;
+  createdAt?: string;
+  resolved?: boolean;
+}
+interface ManageCommentsResult {
+  action: string;
+  comments?: CommentInfo[];
+  commentId?: string;
+  count?: number;
+}
+export declare function manageComments(ctx: ToolContext, params: ManageCommentsParams): ToolResult<ManageCommentsResult>;
+declare namespace conversion_tools_d_exports {
+  export { ConvertToMarkdownParams, ConvertToMarkdownResult, convertToMarkdown };
+}
+interface ConvertToMarkdownParams {
+  outputDir?: string;
+  mediaFolderName?: string;
+  includeMetadata?: boolean;
+  slideRange?: {
+    start?: number;
+    end?: number;
+  };
+  includeSpeakerNotes?: boolean;
+  semanticMode?: boolean;
+  sourceName?: string;
+  /**
+   * Root directory under which `outputDir` must resolve. Only meaningful when
+   * {@link ConvertToMarkdownParams.scopeOutputDir} is supplied. Defaults to
+   * `process.env.PPTX_TOOLS_ROOT` if set, else `process.cwd()`.
+   */
+  rootDir?: string;
+  /**
+   * Optional host-supplied guard that resolves `outputDir` under `rootDir` and
+   * rejects traversal escapes.
+   *
+   * Confining an output directory is a filesystem concern that only exists on
+   * the server, and it needs `node:path` to do correctly. This module is also
+   * reached from the browser (the in-viewer AI assistant calls this tool for
+   * the markdown string, with no filesystem, so `outputDir` is just a prefix
+   * for image links), and a `node:path` import here (even a lazy one behind a
+   * runtime check) puts a Node builtin into every bundler's module graph and
+   * makes browser builds warn. So the MCP server injects
+   * {@link resolveScopedDir} instead and browsers simply omit it.
+   */
+  scopeOutputDir?: (outputDir: string, rootDir?: string) => string;
+}
+interface ConvertToMarkdownResult {
+  markdown: string;
+  slidesConverted: number;
+  totalSlides: number;
+  imagesExtracted: number;
+}
+export declare function convertToMarkdown(ctx: ToolContext, params: ConvertToMarkdownParams): Promise<ToolResult<ConvertToMarkdownResult>>;
+declare namespace theme_tools_d_exports {
+  export { ApplyThemePresetParams, ApplyThemePresetResult, ThemeInfo, UpdateThemeColorsParams, UpdateThemeFontsParams, applyThemePreset, getThemeInfo, updateThemeColors, updateThemeFonts };
+}
+interface ThemeInfo {
+  themeName?: string;
+  colorScheme?: PptxThemeColorScheme;
+  fontScheme?: PptxThemeFontScheme;
+  availablePresets: string[];
+}
+export declare function getThemeInfo(ctx: ToolContext): ToolResult<ThemeInfo>;
+interface ApplyThemePresetParams {
+  presetName: string;
+}
+interface ApplyThemePresetResult {
+  appliedPreset: string;
+  colorScheme: PptxThemeColorScheme;
+}
+export declare function applyThemePreset(ctx: ToolContext, params: ApplyThemePresetParams): ToolResult<ApplyThemePresetResult>;
+interface UpdateThemeColorsParams {
+  dk1?: string;
+  lt1?: string;
+  dk2?: string;
+  lt2?: string;
+  accent1?: string;
+  accent2?: string;
+  accent3?: string;
+  accent4?: string;
+  accent5?: string;
+  accent6?: string;
+  hlink?: string;
+  folHlink?: string;
+}
+export declare function updateThemeColors(ctx: ToolContext, params: UpdateThemeColorsParams): ToolResult<{
+  colorScheme: PptxThemeColorScheme;
+}>;
+interface UpdateThemeFontsParams {
+  majorFont?: string;
+  minorFont?: string;
+}
+export declare function updateThemeFonts(ctx: ToolContext, params: UpdateThemeFontsParams): ToolResult<{
+  fontScheme: PptxThemeFontScheme;
+}>;
+declare namespace chart_tools_d_exports {
+  export { AddChartSeriesParams, CreateChartParams, CreateChartResult, RemoveChartSeriesParams, UpdateChartParams, UpdateChartSeriesDataParams, addChartSeriesT, createChart, removeChartSeriesT, updateChart, updateChartSeriesData };
+}
+interface UpdateChartParams {
+  slideIndex: number;
+  elementId: string;
+  chartType?: string;
+  title?: string;
+  grouping?: 'clustered' | 'stacked' | 'percentStacked';
+  legend?: {
+    show?: boolean;
+    position?: string;
+  };
+  dataLabels?: {
+    show?: boolean;
+    showValue?: boolean;
+    showCategory?: boolean;
+    showSeriesName?: boolean;
+    showPercent?: boolean;
+  };
+  axis?: {
+    type: string;
+    edit: ChartAxisEdit;
+  };
+  categories?: string[];
+}
+export declare function updateChart(ctx: ToolContext, params: UpdateChartParams): ToolResult<{
+  elementId: string;
+}>;
+interface AddChartSeriesParams {
+  slideIndex: number;
+  elementId: string;
+  name: string;
+  values: number[];
+  color?: string;
+}
+export declare function addChartSeriesT(ctx: ToolContext, params: AddChartSeriesParams): ToolResult<{
+  elementId: string;
+  seriesCount: number;
+}>;
+interface RemoveChartSeriesParams {
+  slideIndex: number;
+  elementId: string;
+  seriesIndex: number;
+}
+export declare function removeChartSeriesT(ctx: ToolContext, params: RemoveChartSeriesParams): ToolResult<{
+  elementId: string;
+  seriesCount: number;
+}>;
+interface UpdateChartSeriesDataParams {
+  slideIndex: number;
+  elementId: string;
+  seriesIndex: number;
+  values: number[];
+}
+export declare function updateChartSeriesData(ctx: ToolContext, params: UpdateChartSeriesDataParams): ToolResult<{
+  elementId: string;
+}>;
+interface CreateChartParams {
+  slideIndex: number;
+  chartType: string;
+  x?: number;
+  y?: number;
+  width?: number;
+  height?: number;
+  title?: string;
+  categories?: string[];
+  series?: Array<{
+    name: string;
+    values: number[];
+    color?: string;
+  }>;
+  legend?: {
+    show: boolean;
+    position?: string;
+  };
+}
+interface CreateChartResult {
+  elementId: string;
+  slideIndex: number;
+}
+export declare function createChart(ctx: ToolContext, params: CreateChartParams): ToolResult<CreateChartResult>;
+declare namespace chart_formatting_tools_d_exports {
+  export { FormatChartDataLabelParams, FormatChartDataPointParams, FormatChartSeriesParams, SetChartColorMapOverrideParams, SetChartHelperLineParams, formatChartDataLabel, formatChartDataPoint, formatChartSeries, setChartColorMapOverrideT, setChartHelperLineT };
+}
+interface FormatChartDataPointParams {
+  slideIndex: number;
+  elementId: string;
+  seriesIndex: number;
+  pointIndex: number;
+  /** Fill colour; `null` clears just the style entirely (see `clearStyle`). */
+  fillColor?: string;
+  strokeColor?: string;
+  strokeWidth?: number;
+  strokeDashStyle?: string;
+  /** Remove all `c:dPt/c:spPr` formatting for this point. */
+  clearStyle?: boolean;
+  /** Pie/doughnut slice pull-out distance (0-100). `null` clears it. */
+  explosion?: number | null;
+  marker?: {
+    symbol?: PptxChartMarkerSymbol;
+    size?: number;
+    fillColor?: string;
+  } | null;
+}
+export declare function formatChartDataPoint(ctx: ToolContext, params: FormatChartDataPointParams): ToolResult<{
+  elementId: string;
+}>;
+interface FormatChartDataLabelParams {
+  slideIndex: number;
+  elementId: string;
+  seriesIndex: number;
+  pointIndex: number;
+  /** Pass with no other field, and `remove: true`, to drop the override entirely. */
+  remove?: boolean;
+  showValue?: boolean;
+  showCategory?: boolean;
+  showSeriesName?: boolean;
+  showPercent?: boolean;
+  showLegendKey?: boolean;
+  position?: 'bestFit' | 'b' | 'ctr' | 'inBase' | 'inEnd' | 'l' | 'outEnd' | 'r' | 't';
+  /** Custom label text. Pass `''` to clear it. */
+  text?: string;
+  /** This label's own fill/line formatting; `null` removes it. */
+  spPr?: {
+    fillColor?: string;
+    strokeColor?: string;
+    strokeWidth?: number;
+    strokeDashStyle?: string;
+  } | null;
+  /** This label's own font; `null` removes it. */
+  txPr?: {
+    fontFamily?: string;
+    fontSize?: number;
+    bold?: boolean;
+    italic?: boolean;
+    color?: string;
+  } | null;
+}
+export declare function formatChartDataLabel(ctx: ToolContext, params: FormatChartDataLabelParams): ToolResult<{
+  elementId: string;
+}>;
+interface FormatChartSeriesParams {
+  slideIndex: number;
+  elementId: string;
+  seriesIndex: number;
+  marker?: {
+    symbol?: PptxChartMarkerSymbol;
+    size?: number;
+    fillColor?: string;
+    strokeColor?: string;
+    strokeWidth?: number;
+    strokeDashStyle?: string;
+  } | null;
+  trendline?: {
+    trendlineType: 'linear' | 'exponential' | 'logarithmic' | 'polynomial' | 'power' | 'movingAvg';
+    color?: string;
+    lineWidth?: number;
+    lineDashStyle?: string;
+    order?: number;
+    period?: number;
+    displayEq?: boolean;
+    displayRSq?: boolean;
+  } | null;
+  errorBars?: (PptxChartErrBars & {
+    width?: number;
+    dashStyle?: string;
+  }) | null;
+}
+export declare function formatChartSeries(ctx: ToolContext, params: FormatChartSeriesParams): ToolResult<{
+  elementId: string;
+}>;
+interface SetChartHelperLineParams {
+  slideIndex: number;
+  elementId: string;
+  line: 'dropLines' | 'hiLowLines';
+  /** `null` removes the line entirely. */
+  style: {
+    color?: string;
+    width?: number;
+    dashStyle?: string;
+  } | null;
+}
+export declare function setChartHelperLineT(ctx: ToolContext, params: SetChartHelperLineParams): ToolResult<{
+  elementId: string;
+}>;
+interface SetChartColorMapOverrideParams {
+  slideIndex: number;
+  elementId: string;
+  /** `null` removes the override entirely. */
+  overrides: Record<string, string> | null;
+}
+export declare function setChartColorMapOverrideT(ctx: ToolContext, params: SetChartColorMapOverrideParams): ToolResult<{
+  elementId: string;
+}>;
+declare namespace chart_user_shape_tools_d_exports {
+  export { AddChartUserShapeParams, ChartUserShapeInput, ListChartUserShapesParams, RemoveChartUserShapeParams, UpdateChartUserShapeParams, addChartUserShapeT, listChartUserShapesT, removeChartUserShapeT, updateChartUserShapeT };
+}
+/** The overlay-shape fields an AI tool call can set, flattened from `PptxChartUserShape`. */
+interface ChartUserShapeInput {
+  kind?: 'sp' | 'cxnSp';
+  anchor?: 'rel' | 'abs';
+  from: {
+    x: number;
+    y: number;
+  };
+  to?: {
+    x: number;
+    y: number;
+  };
+  ext?: {
+    cx: number;
+    cy: number;
+  };
+  prst?: string;
+  fill?: string;
+  stroke?: string;
+  strokeWidth?: number;
+  /** Plain text content; mapped onto a single centred paragraph. */
+  text?: string;
+}
+interface ListChartUserShapesParams {
+  slideIndex: number;
+  elementId: string;
+}
+export declare function listChartUserShapesT(ctx: ToolContext, params: ListChartUserShapesParams): ToolResult<{
+  shapes: PptxChartUserShape[];
+}>;
+interface AddChartUserShapeParams {
+  slideIndex: number;
+  elementId: string;
+  shape: ChartUserShapeInput;
+}
+export declare function addChartUserShapeT(ctx: ToolContext, params: AddChartUserShapeParams): ToolResult<{
+  elementId: string;
+  index: number;
+}>;
+interface UpdateChartUserShapeParams {
+  slideIndex: number;
+  elementId: string;
+  index: number;
+  patch: Partial<ChartUserShapeInput>;
+}
+export declare function updateChartUserShapeT(ctx: ToolContext, params: UpdateChartUserShapeParams): ToolResult<{
+  elementId: string;
+}>;
+interface RemoveChartUserShapeParams {
+  slideIndex: number;
+  elementId: string;
+  index: number;
+}
+export declare function removeChartUserShapeT(ctx: ToolContext, params: RemoveChartUserShapeParams): ToolResult<{
+  elementId: string;
+}>;
+declare namespace smartart_tools_d_exports {
+  export { ManageSmartArtParams, ManageSmartArtResult, SmartArtNodeInfo, manageSmartArt };
+}
+interface ManageSmartArtParams {
+  slideIndex: number;
+  elementId: string;
+  action: 'addNode' | 'removeNode' | 'updateNodeText' | 'reorderNode' | 'promoteNode' | 'demoteNode' | 'decompose' | 'getNodes';
+  nodeId?: string;
+  text?: string;
+  afterNodeId?: string;
+  direction?: number;
+}
+interface SmartArtNodeInfo {
+  id: string;
+  text: string;
+  children?: SmartArtNodeInfo[];
+}
+interface ManageSmartArtResult {
+  action: string;
+  elementId: string;
+  nodes?: SmartArtNodeInfo[];
+  decomposedCount?: number;
+}
+export declare function manageSmartArt(ctx: ToolContext, params: ManageSmartArtParams): ToolResult<ManageSmartArtResult>;
+declare namespace merge_tools_d_exports {
+  export { DiffPresentationsParams, MergePresentationParams, MergePresentationResult, diffPresentationsT, mergePresentationT };
+}
+interface MergePresentationParams {
+  /** The source presentation data to merge FROM. */
+  sourceData: PptxData;
+  /** Specific slide indices from source to merge. If omitted, all slides. */
+  slideIndices?: number[];
+  /** Where to insert in the target (0-based). Defaults to end. */
+  insertAt?: number;
+  /** Whether to keep the source theme. */
+  keepSourceTheme?: boolean;
+}
+interface MergePresentationResult {
+  slidesAdded: number;
+  totalSlides: number;
+}
+export declare function mergePresentationT(ctx: ToolContext, params: MergePresentationParams): ToolResult<MergePresentationResult>;
+interface DiffPresentationsParams {
+  /** The other presentation data to diff against. */
+  otherData: PptxData;
+}
+export declare function diffPresentationsT(ctx: ToolContext, params: DiffPresentationsParams): ToolResult<PresentationDiff>;
+declare namespace template_tools_d_exports {
+  export { ApplyTemplateParams, ApplyTemplateResult, FindPlaceholdersResult, applyTemplateT, findPlaceholdersT };
+}
+interface FindPlaceholdersResult {
+  placeholders: string[];
+  count: number;
+}
+export declare function findPlaceholdersT(ctx: ToolContext): ToolResult<FindPlaceholdersResult>;
+interface ApplyTemplateParams {
+  data: Record<string, unknown>;
+}
+interface ApplyTemplateResult {
+  applied: boolean;
+  slideCount: number;
+}
+export declare function applyTemplateT(ctx: ToolContext, params: ApplyTemplateParams): ToolResult<ApplyTemplateResult>;
+declare namespace metadata_tools_d_exports {
+  export { MetadataResult, UpdateMetadataParams, getMetadata, updateMetadata };
+}
+interface MetadataResult {
+  coreProperties?: PptxCoreProperties;
+  appProperties?: PptxAppProperties;
+  customProperties?: PptxCustomProperty[];
+  slideCount: number;
+}
+export declare function getMetadata(ctx: ToolContext): ToolResult<MetadataResult>;
+interface UpdateMetadataParams {
+  title?: string;
+  subject?: string;
+  creator?: string;
+  keywords?: string;
+  description?: string;
+  lastModifiedBy?: string;
+  category?: string;
+  company?: string;
+  manager?: string;
+  customProperties?: Array<{
+    name: string;
+    value: string | number | boolean;
+  }>;
+}
+export declare function updateMetadata(ctx: ToolContext, params: UpdateMetadataParams): ToolResult<{
+  updated: string[];
+}>;
+declare namespace section_tools_d_exports {
+  export { ManageSectionsParams, ManageSectionsResult, SectionInfo, manageSections };
+}
+interface ManageSectionsParams {
+  action: 'list' | 'add' | 'remove' | 'reorder' | 'moveSlides' | 'getForSlide';
+  name?: string;
+  slideIndices?: number[];
+  sectionId?: string;
+  sectionIds?: string[];
+  slideIndex?: number;
+}
+interface SectionInfo {
+  id: string;
+  name: string;
+  slideIds: string[];
+  collapsed?: boolean;
+  color?: string;
+}
+interface ManageSectionsResult {
+  action: string;
+  sections?: SectionInfo[];
+  section?: SectionInfo | null;
+  success?: boolean;
+}
+export declare function manageSections(ctx: ToolContext, params: ManageSectionsParams): ToolResult<ManageSectionsResult>;
+declare namespace export_tools_d_exports {
+  export { ExportSlideSvgParams, ExportSlideSvgResult, ExportToSvgParams, ExportToSvgResult, exportSlideSvg, exportToSvg };
+}
+interface ExportToSvgParams {
+  slideIndices?: number[];
+  includeHidden?: boolean;
+  defaultFontFamily?: string;
+  defaultFontSize?: number;
+}
+interface ExportToSvgResult {
+  svgStrings: string[];
+  slideCount: number;
+}
+export declare function exportToSvg(ctx: ToolContext, params: ExportToSvgParams): ToolResult<ExportToSvgResult>;
+interface ExportSlideSvgParams {
+  slideIndex: number;
+  defaultFontFamily?: string;
+  defaultFontSize?: number;
+}
+interface ExportSlideSvgResult {
+  svg: string;
+  slideIndex: number;
+}
+export declare function exportSlideSvg(ctx: ToolContext, params: ExportSlideSvgParams): ToolResult<ExportSlideSvgResult>;
+declare namespace json_tools_d_exports {
+  export { ExportToJsonParams, ExportToJsonResult, ImportFromJsonParams, ImportFromJsonResult, exportToJson, importFromJson };
+}
+interface ExportToJsonParams {
+  /** Pretty-print with 2-space indentation. Default `true`. */
+  pretty?: boolean;
+}
+interface ExportToJsonResult {
+  /** The serialized `pptx-viewer-json` document text. */
+  json: string;
+  slideCount: number;
+  /** UTF-8 byte size of the serialized document. */
+  byteSize: number;
+  /** Embedded binary-asset accounting (count + decoded bytes). */
+  assets: PptxJsonAssetStats;
+}
+/**
+ * Serialize the presentation to the portable, self-contained
+ * `pptx-viewer-json` document format (binary assets embedded as base64).
+ */
+export declare function exportToJson(ctx: ToolContext, params: ExportToJsonParams): ToolResult<ExportToJsonResult>;
+interface ImportFromJsonParams {
+  /** The `pptx-viewer-json` document text to import. */
+  json: string;
+}
+interface ImportFromJsonResult {
+  slideCount: number;
+  width: number;
+  height: number;
+}
+/**
+ * Replace the presentation content with a deck imported from a
+ * `pptx-viewer-json` document: every presentation-level field the document
+ * defines wins, and the slide array is replaced wholesale. The context's
+ * `pptxData` object is mutated in place so hosts holding a reference (viewer
+ * bridges, the save pipeline) observe the imported deck.
+ */
+export declare function importFromJson(ctx: ToolContext, params: ImportFromJsonParams): ToolResult<ImportFromJsonResult>;
+declare namespace hyperlink_tools_d_exports {
+  export { HyperlinkInfo, ManageHyperlinksParams, ManageHyperlinksResult, manageHyperlinks };
+}
+interface ManageHyperlinksParams {
+  slideIndex: number;
+  action: 'list' | 'set' | 'remove';
+  elementId?: string;
+  trigger?: 'click' | 'hover';
+  url?: string;
+  tooltip?: string;
+  targetSlideIndex?: number;
+  actionType?: 'url' | 'slide' | 'nextSlide' | 'prevSlide' | 'firstSlide' | 'lastSlide' | 'endShow';
+}
+interface HyperlinkInfo {
+  elementId: string;
+  trigger: 'click' | 'hover';
+  url?: string;
+  tooltip?: string;
+  targetSlideIndex?: number;
+  actionType?: string;
+}
+interface ManageHyperlinksResult {
+  action: string;
+  hyperlinks?: HyperlinkInfo[];
+  elementId?: string;
+}
+export declare function manageHyperlinks(ctx: ToolContext, params: ManageHyperlinksParams): ToolResult<ManageHyperlinksResult>;
+declare namespace geometry_tools_d_exports {
+  export { ReplaceGeometryParams, replaceGeometry };
+}
+interface ReplaceGeometryParams {
+  slideIndex: number;
+  elementId: string;
+  /** New preset shape type (e.g. "roundRect", "star5", "ellipse"). */
+  shapeType?: string;
+  /** Custom SVG path data (mutually exclusive with shapeType). */
+  svgPath?: string;
+  /** Width of the custom path coordinate space. */
+  pathWidth?: number;
+  /** Height of the custom path coordinate space. */
+  pathHeight?: number;
+  /** Adjustment values for the new geometry. */
+  adjustments?: Record<string, number>;
+}
+export declare function replaceGeometry(ctx: ToolContext, params: ReplaceGeometryParams): ToolResult<{
+  elementId: string;
+  geometryType: string;
+}>;
+declare namespace lock_tools_d_exports {
+  export { SetElementLockParams, setElementLockT };
+}
+interface SetElementLockParams {
+  slideIndex: number;
+  elementId: string;
+  locked: boolean;
+  noMove?: boolean;
+  noResize?: boolean;
+  noRotation?: boolean;
+  noSelect?: boolean;
+  noTextEdit?: boolean;
+}
+export declare function setElementLockT(ctx: ToolContext, params: SetElementLockParams): ToolResult<{
+  elementId: string;
+  locked: boolean;
+}>;
+declare namespace validation_tools_d_exports {
+  export { RepairPresentationResult, ValidatePresentationResult, repairPresentation, validatePresentation };
+}
+interface ValidatePresentationResult {
+  valid: boolean;
+  issueCount: number;
+  errors: number;
+  warnings: number;
+  issues: Array<{
+    severity: string;
+    code: string;
+    message: string;
+    path?: string;
+  }>;
+}
+/**
+ * Validate requires the raw bytes (ArrayBuffer) so this tool needs special
+ * handling: the MCP server must pass rawBytes alongside the context.
+ * We store a reference in ToolContext via resolveMedia or pass it directly.
+ */
+export declare function validatePresentation(rawBytes: ArrayBuffer): Promise<ValidatePresentationResult>;
+interface RepairPresentationResult {
+  repairCount: number;
+  repairs: string[];
+}
+export declare function repairPresentation(rawBytes: ArrayBuffer): Promise<{
+  result: RepairPresentationResult;
+  repairedBytes: ArrayBuffer;
+}>;
+declare namespace presentation_tools_d_exports {
+  export { UpdatePresentationPropertiesParams, getPresentationProperties, updatePresentationProperties };
+}
+export declare function getPresentationProperties(ctx: ToolContext): ToolResult<{
+  properties: PptxPresentationProperties | undefined;
+  slideCount: number;
+  width?: number;
+  height?: number;
+}>;
+interface UpdatePresentationPropertiesParams {
+  showType?: 'presented' | 'browsed' | 'kiosk';
+  loopContinuously?: boolean;
+  showWithNarration?: boolean;
+  showWithAnimation?: boolean;
+  advanceMode?: 'manual' | 'useTimings';
+  showSlidesMode?: 'all' | 'customShow' | 'range';
+  showSlidesFrom?: number;
+  showSlidesTo?: number;
+  penColor?: string;
+}
+export declare function updatePresentationProperties(ctx: ToolContext, params: UpdatePresentationPropertiesParams): ToolResult<{
+  properties: PptxPresentationProperties;
+}>;
+declare namespace layout_tools_d_exports {
+  export { ApplyLayoutParams, ApplyLayoutResult, GetLayoutsResult, LayoutInfo, applyLayout, getLayouts };
+}
+interface LayoutInfo {
+  name: string;
+  path?: string;
+  type?: string;
+}
+interface GetLayoutsResult {
+  layouts: LayoutInfo[];
+  count: number;
+}
+export declare function getLayouts(ctx: ToolContext): ToolResult<GetLayoutsResult>;
+interface ApplyLayoutParams {
+  slideIndex: number;
+  layoutName?: string;
+  layoutType?: string;
+}
+interface ApplyLayoutResult {
+  slideIndex: number;
+  layoutName: string;
+}
+export declare function applyLayout(ctx: ToolContext, params: ApplyLayoutParams): ToolResult<ApplyLayoutResult>;
+declare namespace ole_tools_d_exports {
+  export { GetOleContentParams, GetOleContentResult, ReplaceOleFileParams, SetOleContentResult, SetOleDeckSlideTitleParams, SetOleDocumentParagraphParams, SetOleObjectNameParams, SetOleSheetCellParams, getOleContent, replaceOleFileT, setOleDeckSlideTitle, setOleDocumentParagraph, setOleObjectNameT, setOleSheetCell };
+}
+interface GetOleContentParams {
+  slideIndex: number;
+  elementId: string;
+}
+interface GetOleContentResult {
+  elementId: string;
+  /** Which in-place editor applies to the object's current payload. */
+  kind: OlePayloadEditorKind;
+  /** Whether `ole_set_*` can act on this object; `false` steers to `ole_replace_file`. */
+  editable: boolean;
+  /** Human-readable note, set when `editable` is `false`. */
+  message?: string;
+  /** Present when `kind` is `sheet-xlsx` or `sheet-xls`. */
+  sheet?: OleSheetGrid;
+  /** Present when `kind` is `document-docx` or `document-doc`. */
+  paragraphs?: string[];
+  /** Present when `kind` is `deck-pptx`: every slide's text-element inventory. */
+  deckSlides?: OleNestedDeckSlideDetail[];
+}
+/**
+ * Describe an OLE object's editable content: the resolved payload kind, plus
+ * whichever of the sheet grid / paragraph list / nested-deck slide summaries
+ * applies. `file` (anything unsupported, or a missing/unreadable payload, or
+ * a `document-doc` this editor declined to touch, see `getOleDocumentParagraphs`
+ * in `pptx-viewer-core`) comes back as not editable in place; the caller
+ * should use {@link replaceOleFileT} instead.
+ */
+export declare function getOleContent(ctx: ToolContext, params: GetOleContentParams): Promise<ToolResult<GetOleContentResult>>;
+interface SetOleContentResult {
+  elementId: string;
+  /** `false` when the edit was a no-op (e.g. value unchanged, or wrong payload kind). */
+  changed: boolean;
+}
+interface SetOleSheetCellParams {
+  slideIndex: number;
+  elementId: string;
+  row: number;
+  col: number;
+  value: string;
+}
+/** Edit one cell of an Excel-payload (`.xlsx`/`.xls`) OLE object's first worksheet. */
+export declare function setOleSheetCell(ctx: ToolContext, params: SetOleSheetCellParams): Promise<ToolResult<SetOleContentResult>>;
+interface SetOleDocumentParagraphParams {
+  slideIndex: number;
+  elementId: string;
+  paragraphIndex: number;
+  text: string;
+}
+/** Replace one paragraph's text in a Word-payload (`.docx` or legacy binary `.doc`) OLE object. */
+export declare function setOleDocumentParagraph(ctx: ToolContext, params: SetOleDocumentParagraphParams): Promise<ToolResult<SetOleContentResult>>;
+interface SetOleDeckSlideTitleParams {
+  slideIndex: number;
+  elementId: string;
+  deckSlideIndex: number;
+  /** The id of the text-bearing shape to edit, from `ole_get_content`'s `deckSlides[n].elements[i].elementId`. */
+  deckElementId: string;
+  title: string;
+}
+/**
+ * Replace one specific text-bearing shape's text on one slide of a
+ * nested-deck (embedded PowerPoint) OLE object: a full round-trip through
+ * the nested deck's own `PptxHandler` load/save, so any text-bearing shape
+ * on any slide is a real edit target, not only a fixed "title" slot. Call
+ * `ole_get_content` first to discover each slide's `elementId`s.
+ */
+export declare function setOleDeckSlideTitle(ctx: ToolContext, params: SetOleDeckSlideTitleParams): Promise<ToolResult<SetOleContentResult>>;
+interface SetOleObjectNameParams {
+  slideIndex: number;
+  elementId: string;
+  /** New Object Name (`p:oleObj/@name`); blank/whitespace clears it. */
+  name: string;
+}
+/**
+ * Rename an OLE object's Object Name (`p:oleObj/@name`). When the object is
+ * displayed `showAsIcon`, this also regenerates the baked-in icon caption
+ * (see `setOleObjectName` in `pptx-viewer-core`) so the new name is visible
+ * once the deck is reopened in real PowerPoint.
+ */
+export declare function setOleObjectNameT(ctx: ToolContext, params: SetOleObjectNameParams): Promise<ToolResult<SetOleContentResult>>;
+interface ReplaceOleFileParams {
+  slideIndex: number;
+  elementId: string;
+  /** New payload as a base64 data URL, e.g. `data:application/pdf;base64,...`. */
+  fileData: string;
+  /** Optional new file name; also updates the resolved MIME type. */
+  fileName?: string;
+}
+/**
+ * Replace an OLE object's payload wholesale with an arbitrary file. Always
+ * available regardless of the object's current kind, and the only edit
+ * available for a generic "Package" object or an unsupported format.
+ */
+export declare function replaceOleFileT(ctx: ToolContext, params: ReplaceOleFileParams): Promise<ToolResult<SetOleContentResult>>;
+declare namespace execution_d_exports {
+  export { executeToolWithContext, loadPresentation, savePresentation };
+}
+/**
+ * Load PptxData from a file, checking collaboration rooms first.
+ * If a Y.Doc room is active the current in-memory state is dehydrated
+ * so that unsaved edits are included in the tool's view of the document.
+ */
+export declare function loadPresentation(filePath: string, execCtx: ExecutionContext): Promise<{
+  pptxData: PptxData;
+  rawBytes: Uint8Array;
+}>;
+/**
+ * Save mutated PptxData back: routes through collaboration Y.Doc or disk.
+ */
+export declare function savePresentation(filePath: string, pptxData: PptxData, rawBytes: Uint8Array, execCtx: ExecutionContext, tableStyleSaveOptions?: TableStyleSaveOptions): Promise<{
+  savedToDisk: boolean;
+  routedThroughCollaboration: boolean;
+}>;
+/**
+ * Execute a pure tool function with full collaboration-aware load/save pipeline.
+ * Handles dehydrate-from-room → tool → hydrate-back-to-room routing automatically.
+ */
+export declare function executeToolWithContext<T>(filePath: string, execCtx: ExecutionContext, toolFn: (ctx: ToolContext) => ToolResult<T> | Promise<ToolResult<T>>): Promise<T & {
+  savedToDisk?: boolean;
+  routedThroughCollaboration?: boolean;
+}>;
+declare namespace chart_pareto_d_exports {
+  export { applyParetoChartTypeAlias };
+}
+/**
+ * Translate an MCP/AI request for `chartType: "pareto"` into this SDK's
+ * actual chart model.
+ *
+ * "Pareto" is not a distinct `PptxChartType` here: a PowerPoint-authored
+ * Pareto chart is modeled (both on parse and on save) as
+ * `chartType: 'histogram'` with one `clusteredColumn`-layout series (the bin
+ * frequencies) and one `paretoLine`-layout series (the cumulative
+ * percentage) -- see `PptxHandlerRuntimeChartDetection` and
+ * `chart-cx-generator.ts`. `createChart`/`updateChart` accept a free-form
+ * `chartType` string for MCP/LLM ergonomics, so a literal `"pareto"` request
+ * would otherwise silently fall back to a plain bar chart: `canGenerateChartEx`
+ * does not recognise the string `"pareto"`, and the classic (non-ChartEx)
+ * writer has no container for it either.
+ *
+ * Mutates `chart.chartData` in place: sets the chart type to `'histogram'`,
+ * marks the first series as the frequency bars, and appends a computed
+ * cumulative-percentage series (unless one is already present) so the result
+ * round-trips as a real ChartEx Pareto chart. No-ops for any other
+ * `requestedType`.
+ */
+declare function applyParetoChartTypeAlias(chart: ChartPptxElement, requestedType: string): void;
+declare namespace text_editing_d_exports {
+  export { replaceElementText, setElementText };
+}
+declare function setElementText(element: PptxElementWithText, text: string): void;
+declare function replaceElementText(element: PptxElementWithText, regex: RegExp, replacement: string): number;
+declare namespace pptx_codec_d_exports {
+  export { COMPLEX_FIELD_MAP, COMPLEX_SLIDE_FIELD_MAP, FormatCodec, ORIGIN_FILE_LOAD, PptxCodec, SCALAR_ELEMENT_KEYS, SCALAR_SLIDE_KEYS };
+}
+declare const ORIGIN_FILE_LOAD = "file-load";
+/**
+ * Bidirectional format codec: file bytes <-> Y.Doc shared types.
+ *
+ * Y.Doc schema:
+ *   pptx:meta    Y.Map  - width, height, widthEmu, heightEmu, sourceBytes
+ *   pptx:slides  Y.Array<Y.Map> - one map per slide
+ *     Each slide Y.Map: scalar fields + `_`-prefixed JSON blobs + `elements` Y.Array<Y.Map>
+ *     Each element Y.Map: scalar fields + `_`-prefixed JSON blobs + `textBody` Y.Text
+ *     textBody Y.Text: one delta op per TextSegment (see text-body-codec.ts)
+ *
+ * NOTE: the viewer bindings' sync schema (pptx-viewer-shared
+ * collaboration-sync.ts) uses SHORT complex-field key prefixes (`_ts`, `_tr`)
+ * while this codec uses long ones (`_textStyle`, `_transition`). The two doc
+ * layouts are similar but NOT interchangeable on the same Y.Doc.
+ */
+interface FormatCodec {
+  readonly formatId: string;
+  readonly extensions: string[];
+  hydrate: (ydoc: Doc, bytes: Uint8Array, origin?: string) => Promise<void>;
+  dehydrate: (ydoc: Doc, dirtyPaths?: string[]) => Promise<Uint8Array>;
+  observe: (ydoc: Doc, onChange: () => void) => () => void;
+}
+/**
+ * Field coverage is derived from `pptx-viewer-core`'s
+ * `ELEMENT_FIELD_KIND`/`SLIDE_FIELD_KIND` (the same canonical inventory the
+ * viewer's `collaboration-sync.ts` allowlists derive from), so this codec
+ * automatically tracks every field `PptxElement`/`PptxSlide` declares
+ * instead of drifting out of sync with a hand-maintained list. Wire-format
+ * prefixes stay long-form (`_textStyle`) here versus the viewer schema's
+ * short-form (`_ts`) - the two Y.Doc layouts are intentionally NOT
+ * interchangeable, only the field *coverage* is required to match.
+ *
+ * `asset`-kind fields (large binary payloads like `mediaData`) are simply
+ * embedded as scalars here rather than routed through a separate asset map:
+ * this codec does one-shot bidirectional file<->Y.Doc conversion, not a
+ * live P2P transport, so there's no repeated-write cost to avoid.
+ */
+declare const SCALAR_ELEMENT_KEYS: Set<string>;
+declare const COMPLEX_FIELD_MAP: Record<string, string>;
+declare const SCALAR_SLIDE_KEYS: Set<string>;
+declare const COMPLEX_SLIDE_FIELD_MAP: Record<string, string>;
+declare class PptxCodec implements FormatCodec {
+  readonly formatId = "pptx";
+  readonly extensions: string[];
+  hydrate(ydoc: Doc, bytes: Uint8Array, origin?: string): Promise<void>;
+  dehydrate(ydoc: Doc, _dirtyPaths?: string[]): Promise<Uint8Array>;
+  observe(ydoc: Doc, onChange: () => void): () => void;
+  private _slideToYMap;
+  private _yMapToSlide;
+  private _elementToYMap;
+  private _yMapToElement;
+}
+declare namespace text_body_codec_d_exports {
+  export { decodeTextBodyFromYText, encodeTextBodyToYText };
+}
+/** Encode an array of TextSegment-shaped objects into a Y.Text. */
+declare function encodeTextBodyToYText(segments: unknown[], ytext: Text): void;
+/** Decode a Y.Text delta back into TextSegment-shaped objects. */
+declare function decodeTextBodyFromYText(ytext: Text): Record<string, unknown>[];
+declare namespace index_d_exports {
+  export { COMPLEX_FIELD_MAP, COMPLEX_SLIDE_FIELD_MAP, FormatCodec, ORIGIN_FILE_LOAD, PptxCodec, SCALAR_ELEMENT_KEYS, SCALAR_SLIDE_KEYS };
+}
+//#endregion
+export { type AccessibilityCheckResult, type AccessibilityIssue, type AddChartSeriesParams, type AddChartUserShapeParams, type AddElementParams, type AddElementResult, type AddSlideParams, type AddSlideResult, type ApplyLayoutParams, type ApplyLayoutResult, type ApplyTemplateParams, type ApplyTemplateResult, type ApplyThemePresetParams, type ApplyThemePresetResult, type ArrangeElementsParams, type AssignTableStyleParams, type BatchUpdateElementsParams, type ChartUserShapeInput, type CloneElementParams, type CloneElementResult, type CommentInfo, type ConvertToMarkdownParams, type ConvertToMarkdownResult, type CreateChartParams, type CreateChartResult, type CreateTableStyleParams, type DeleteElementsParams, type DeleteSlidesParams, type DeleteSlidesResult, type DeleteTableStyleParams, type DiffPresentationsParams, type DuplicateSlideParams, type ExportSlideSvgParams, type ExportSlideSvgResult, type ExportToJsonParams, type ExportToJsonResult, type ExportToSvgParams, type ExportToSvgResult, type FindPlaceholdersResult, type FindTextParams, type FindTextResult, type FormatChartDataLabelParams, type FormatChartDataPointParams, type FormatChartSeriesParams, type GetLayoutsResult, type GetOleContentParams, type GetOleContentResult, type GetSlideResult, type GroupElementsParams, type GroupElementsResult, type HyperlinkInfo, type ImportFromJsonParams, type ImportFromJsonResult, type LayoutInfo, type ListChartUserShapesParams, type ManageCommentsParams, type ManageCommentsResult, type ManageHyperlinksParams, type ManageHyperlinksResult, type ManageSectionsParams, type ManageSectionsResult, type ManageSmartArtParams, type ManageSmartArtResult, type ManageTableStructureParams, type MergePresentationParams, type MergePresentationResult, type MetadataResult, type PptxData, type PptxElement, type PptxSlide, type RemoveChartSeriesParams, type RemoveChartUserShapeParams, type RenameElementParams, type ReorderSlidesParams, type RepairPresentationResult, type ReplaceGeometryParams, type ReplaceOleFileParams, type ReplaceTextParams, type ReplaceTextResult, type SectionInfo, type SetCanvasSizeParams, type SetChartColorMapOverrideParams, type SetChartHelperLineParams, type SetElementAnimationParams, type SetElementLockParams, type SetOleContentResult, type SetOleDeckSlideTitleParams, type SetOleDocumentParagraphParams, type SetOleObjectNameParams, type SetOleSheetCellParams, type SetSlideTransitionParams, type SetTableStyleSectionParams, type SmartArtNodeInfo, type TextMatch, type ThemeInfo, type UngroupElementsParams, type UngroupElementsResult, type UpdateChartParams, type UpdateChartSeriesDataParams, type UpdateChartUserShapeParams, type UpdateElementParams, type UpdateElementStyleParams, type UpdateMetadataParams, type UpdatePresentationPropertiesParams, type UpdateSlidePropertiesParams, type UpdateTableCellsParams, type UpdateThemeColorsParams, type UpdateThemeFontsParams, type ValidatePresentationResult, pptx_codec_d_exports as apiCodecPptxCodec, text_body_codec_d_exports as apiCodecTextBodyCodec, execution_d_exports as apiExecution, chart_formatting_tools_d_exports as apiToolsChartFormattingTools, chart_pareto_d_exports as apiToolsChartPareto, chart_tools_d_exports as apiToolsChartTools, chart_user_shape_tools_d_exports as apiToolsChartUserShapeTools, content_tools_d_exports as apiToolsContentTools, conversion_tools_d_exports as apiToolsConversionTools, element_tools_d_exports as apiToolsElementTools, export_tools_d_exports as apiToolsExportTools, geometry_tools_d_exports as apiToolsGeometryTools, helpers_d_exports as apiToolsHelpers, hyperlink_tools_d_exports as apiToolsHyperlinkTools, json_tools_d_exports as apiToolsJsonTools, layout_tools_d_exports as apiToolsLayoutTools, lock_tools_d_exports as apiToolsLockTools, merge_tools_d_exports as apiToolsMergeTools, metadata_tools_d_exports as apiToolsMetadataTools, ole_tools_d_exports as apiToolsOleTools, presentation_tools_d_exports as apiToolsPresentationTools, section_tools_d_exports as apiToolsSectionTools, slide_tools_d_exports as apiToolsSlideTools, smartart_tools_d_exports as apiToolsSmartartTools, style_tools_d_exports as apiToolsStyleTools, table_style_tools_d_exports as apiToolsTableStyleTools, table_tools_d_exports as apiToolsTableTools, template_tools_d_exports as apiToolsTemplateTools, text_editing_d_exports as apiToolsTextEditing, theme_tools_d_exports as apiToolsThemeTools, validation_tools_d_exports as apiToolsValidationTools, types_d_exports as apiTypes, index_d_exports as codec };
+//# sourceMappingURL=index.d.ts.map