import { Doc } from "yjs";
import { ChartAxisEdit, PptxAppProperties, PptxCoreProperties, PptxCustomProperty, PptxData, PptxData as PptxData$1, PptxData as PptxData$2, PptxElement, PptxElement as PptxElement$1, PptxHandler, PptxPresentationProperties, PptxSlide, PptxSlide as PptxSlide$1, PptxThemeColorScheme, PptxThemeFontScheme, PresentationDiff, ShapeStyle } from "pptx-viewer-core";
//#region src/types.d.ts
/**
 * Platform-agnostic context passed to every tool function.
 * No Electron, no RoomManager, no framework dependencies.
 */
interface ToolContext {
  /** Current presentation data (parsed PptxData from pptx-viewer-core). */
  pptxData: PptxData$2;
  /** 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>;
}
/**
 * Every tool function returns this.
 * The consumer decides what to do with the mutated pptxData.
 */
interface ToolResult<T = unknown> {
  /** The (potentially mutated) presentation data. */
  pptxData: PptxData$2;
  /** Tool-specific return value (e.g., slide info, element ID, search results). */
  result: T;
  /** Whether pptxData was modified (signals need to save). */
  dirty: boolean;
}
/**
 * Abstraction for Y.Doc room management.
 * fz-electron implements this with RoomManager.
 */
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.
 */
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.
 */
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.
 */
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;
}
//#endregion
//#region src/execution.d.ts
/**
 * 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.
 */
declare function loadPresentation(filePath: string, execCtx: ExecutionContext): Promise<{
  pptxData: PptxData$1;
  rawBytes: Uint8Array;
}>;
/**
 * Save mutated PptxData back: routes through collaboration Y.Doc or disk.
 */
declare function savePresentation(filePath: string, pptxData: PptxData$1, rawBytes: Uint8Array, execCtx: ExecutionContext): 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.
 */
declare function executeToolWithContext<T>(filePath: string, execCtx: ExecutionContext, toolFn: (ctx: ToolContext) => ToolResult<T> | Promise<ToolResult<T>>): Promise<T & {
  savedToDisk?: boolean;
  routedThroughCollaboration?: boolean;
}>;
//#endregion
//#region src/tools/slide-tools.d.ts
interface GetSlideResult {
  slideIndex: number;
  slideNumber: number;
  hidden: boolean;
  layoutName?: string;
  backgroundColor?: string;
  notes: string;
  commentCount: number;
  elements: Record<string, unknown>[];
}
declare function getSlide(ctx: ToolContext, params: {
  slideIndex: number;
}): ToolResult<GetSlideResult>;
interface AddSlideParams {
  insertAfterIndex?: number;
  backgroundColor?: string;
}
interface AddSlideResult {
  newSlideIndex: number;
  slideCount: number;
}
declare function addSlide(ctx: ToolContext, params: AddSlideParams): ToolResult<AddSlideResult>;
interface DeleteSlidesParams {
  slideIndexes: number[];
}
interface DeleteSlidesResult {
  deletedCount: number;
  slideCount: number;
}
declare function deleteSlides(ctx: ToolContext, params: DeleteSlidesParams): ToolResult<DeleteSlidesResult>;
interface ReorderSlidesParams {
  newOrder: number[];
}
declare function reorderSlides(ctx: ToolContext, params: ReorderSlidesParams): ToolResult<{
  slideCount: number;
}>;
interface DuplicateSlideParams {
  slideIndex: number;
  targetIndex?: number;
}
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;
}
declare function updateSlideProperties(ctx: ToolContext, params: UpdateSlidePropertiesParams): ToolResult<{
  slideIndex: number;
}>;
interface SetSlideTransitionParams {
  slideIndex: number;
  type: string;
  durationMs?: number;
  direction?: string;
  advanceOnClick?: boolean;
  advanceAfterMs?: number;
}
declare function setSlideTransition(ctx: ToolContext, params: SetSlideTransitionParams): ToolResult<{
  slideIndex: number;
  transitionType: string;
}>;
interface SetCanvasSizeParams {
  width: number;
  height: number;
}
declare function setCanvasSize(ctx: ToolContext, params: SetCanvasSizeParams): ToolResult<{
  canvasWidth: number;
  canvasHeight: number;
}>;
//#endregion
//#region src/tools/helpers.d.ts
declare function generateElementId(): string;
declare function generateSlideId(): string;
/** Build a concise text representation of a slide element for tool output. */
declare function describeElement(el: PptxElement$1): Record<string, unknown>;
/** Extract text from a slide's elements for search purposes. */
declare function extractSlideText(slide: PptxSlide$1): string;
/** Validate slideIndex is within range, return error string or null. */
declare function validateSlideIndex(slideIndex: number, slideCount: number): string | null;
//#endregion
//#region src/tools/element-tools.d.ts
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;
}
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;
  fontSize?: number;
  fontFamily?: string;
  fontColor?: string;
  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;
}
declare function updateElement(ctx: ToolContext, params: UpdateElementParams): ToolResult<{
  elementId: string;
}>;
interface DeleteElementsParams {
  slideIndex: number;
  elementIds: string[];
}
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';
}
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[];
}
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;
}
declare function setElementAnimation(ctx: ToolContext, params: SetElementAnimationParams): ToolResult<{
  elementId: string;
}>;
interface GroupElementsParams {
  slideIndex: number;
  elementIds: string[];
}
interface GroupElementsResult {
  groupId: string;
}
declare function groupElements(ctx: ToolContext, params: GroupElementsParams): ToolResult<GroupElementsResult>;
interface UngroupElementsParams {
  slideIndex: number;
  groupElementId: string;
}
interface UngroupElementsResult {
  restoredIds: string[];
}
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;
}
declare function batchUpdateElements(ctx: ToolContext, params: BatchUpdateElementsParams): ToolResult<{
  updatedCount: number;
}>;
//#endregion
//#region src/tools/table-tools.d.ts
interface UpdateTableCellsParams {
  slideIndex: number;
  elementId: string;
  cells: Array<{
    row: number;
    col: number;
    text: string;
  }>;
}
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[];
}
declare function manageTableStructure(ctx: ToolContext, params: ManageTableStructureParams): ToolResult<{
  rowCount: number;
  columnCount: number;
}>;
//#endregion
//#region src/tools/style-tools.d.ts
interface UpdateElementStyleParams {
  slideIndex: number;
  elementId: string;
  fillColor?: string;
  fillMode?: ShapeStyle['fillMode'];
  fillGradientStops?: Array<{
    color: string;
    position: number;
    opacity?: number;
  }>;
  fillGradientAngle?: number;
  fillGradientType?: 'linear' | 'radial';
  fillOpacity?: number;
  strokeColor?: string;
  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;
  altText?: string;
}
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[];
}
declare function runAccessibilityCheck(ctx: ToolContext): ToolResult<AccessibilityCheckResult>;
//#endregion
//#region src/tools/content-tools.d.ts
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[];
}
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;
}
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;
}
declare function manageComments(ctx: ToolContext, params: ManageCommentsParams): ToolResult<ManageCommentsResult>;
//#endregion
//#region src/tools/conversion-tools.d.ts
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;
}
declare function convertToMarkdown(ctx: ToolContext, params: ConvertToMarkdownParams): Promise<ToolResult<ConvertToMarkdownResult>>;
//#endregion
//#region src/tools/theme-tools.d.ts
interface ThemeInfo {
  themeName?: string;
  colorScheme?: PptxThemeColorScheme;
  fontScheme?: PptxThemeFontScheme;
  availablePresets: string[];
}
declare function getThemeInfo(ctx: ToolContext): ToolResult<ThemeInfo>;
interface ApplyThemePresetParams {
  presetName: string;
}
interface ApplyThemePresetResult {
  appliedPreset: string;
  colorScheme: PptxThemeColorScheme;
}
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;
}
declare function updateThemeColors(ctx: ToolContext, params: UpdateThemeColorsParams): ToolResult<{
  colorScheme: PptxThemeColorScheme;
}>;
interface UpdateThemeFontsParams {
  majorFont?: string;
  minorFont?: string;
}
declare function updateThemeFonts(ctx: ToolContext, params: UpdateThemeFontsParams): ToolResult<{
  fontScheme: PptxThemeFontScheme;
}>;
//#endregion
//#region src/tools/chart-tools.d.ts
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[];
}
declare function updateChart(ctx: ToolContext, params: UpdateChartParams): ToolResult<{
  elementId: string;
}>;
interface AddChartSeriesParams {
  slideIndex: number;
  elementId: string;
  name: string;
  values: number[];
  color?: string;
}
declare function addChartSeriesT(ctx: ToolContext, params: AddChartSeriesParams): ToolResult<{
  elementId: string;
  seriesCount: number;
}>;
interface RemoveChartSeriesParams {
  slideIndex: number;
  elementId: string;
  seriesIndex: number;
}
declare function removeChartSeriesT(ctx: ToolContext, params: RemoveChartSeriesParams): ToolResult<{
  elementId: string;
  seriesCount: number;
}>;
interface UpdateChartSeriesDataParams {
  slideIndex: number;
  elementId: string;
  seriesIndex: number;
  values: number[];
}
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;
}
declare function createChart(ctx: ToolContext, params: CreateChartParams): ToolResult<CreateChartResult>;
//#endregion
//#region src/tools/smartart-tools.d.ts
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;
}
declare function manageSmartArt(ctx: ToolContext, params: ManageSmartArtParams): ToolResult<ManageSmartArtResult>;
//#endregion
//#region src/tools/merge-tools.d.ts
interface MergePresentationParams {
  /** The source presentation data to merge FROM. */
  sourceData: PptxData$1;
  /** 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;
}
declare function mergePresentationT(ctx: ToolContext, params: MergePresentationParams): ToolResult<MergePresentationResult>;
interface DiffPresentationsParams {
  /** The other presentation data to diff against. */
  otherData: PptxData$1;
}
declare function diffPresentationsT(ctx: ToolContext, params: DiffPresentationsParams): ToolResult<PresentationDiff>;
//#endregion
//#region src/tools/template-tools.d.ts
interface FindPlaceholdersResult {
  placeholders: string[];
  count: number;
}
declare function findPlaceholdersT(ctx: ToolContext): ToolResult<FindPlaceholdersResult>;
interface ApplyTemplateParams {
  data: Record<string, unknown>;
}
interface ApplyTemplateResult {
  applied: boolean;
  slideCount: number;
}
declare function applyTemplateT(ctx: ToolContext, params: ApplyTemplateParams): ToolResult<ApplyTemplateResult>;
//#endregion
//#region src/tools/metadata-tools.d.ts
interface MetadataResult {
  coreProperties?: PptxCoreProperties;
  appProperties?: PptxAppProperties;
  customProperties?: PptxCustomProperty[];
  slideCount: number;
}
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;
  }>;
}
declare function updateMetadata(ctx: ToolContext, params: UpdateMetadataParams): ToolResult<{
  updated: string[];
}>;
//#endregion
//#region src/tools/section-tools.d.ts
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;
}
declare function manageSections(ctx: ToolContext, params: ManageSectionsParams): ToolResult<ManageSectionsResult>;
//#endregion
//#region src/tools/export-tools.d.ts
interface ExportToSvgParams {
  slideIndices?: number[];
  includeHidden?: boolean;
  defaultFontFamily?: string;
  defaultFontSize?: number;
}
interface ExportToSvgResult {
  svgStrings: string[];
  slideCount: number;
}
declare function exportToSvg(ctx: ToolContext, params: ExportToSvgParams): ToolResult<ExportToSvgResult>;
interface ExportSlideSvgParams {
  slideIndex: number;
  defaultFontFamily?: string;
  defaultFontSize?: number;
}
interface ExportSlideSvgResult {
  svg: string;
  slideIndex: number;
}
declare function exportSlideSvg(ctx: ToolContext, params: ExportSlideSvgParams): ToolResult<ExportSlideSvgResult>;
//#endregion
//#region src/tools/hyperlink-tools.d.ts
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;
}
declare function manageHyperlinks(ctx: ToolContext, params: ManageHyperlinksParams): ToolResult<ManageHyperlinksResult>;
//#endregion
//#region src/tools/geometry-tools.d.ts
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>;
}
declare function replaceGeometry(ctx: ToolContext, params: ReplaceGeometryParams): ToolResult<{
  elementId: string;
  geometryType: string;
}>;
//#endregion
//#region src/tools/lock-tools.d.ts
interface SetElementLockParams {
  slideIndex: number;
  elementId: string;
  locked: boolean;
  noMove?: boolean;
  noResize?: boolean;
  noRotation?: boolean;
  noSelect?: boolean;
  noTextEdit?: boolean;
}
declare function setElementLockT(ctx: ToolContext, params: SetElementLockParams): ToolResult<{
  elementId: string;
  locked: boolean;
}>;
//#endregion
//#region src/tools/validation-tools.d.ts
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.
 */
declare function validatePresentation(rawBytes: ArrayBuffer): Promise<ValidatePresentationResult>;
interface RepairPresentationResult {
  repairCount: number;
  repairs: string[];
}
declare function repairPresentation(rawBytes: ArrayBuffer): Promise<{
  result: RepairPresentationResult;
  repairedBytes: ArrayBuffer;
}>;
//#endregion
//#region src/tools/presentation-tools.d.ts
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;
}
declare function updatePresentationProperties(ctx: ToolContext, params: UpdatePresentationPropertiesParams): ToolResult<{
  properties: PptxPresentationProperties;
}>;
//#endregion
//#region src/tools/layout-tools.d.ts
interface LayoutInfo {
  name: string;
  path?: string;
  type?: string;
}
interface GetLayoutsResult {
  layouts: LayoutInfo[];
  count: number;
}
declare function getLayouts(ctx: ToolContext): ToolResult<GetLayoutsResult>;
interface ApplyLayoutParams {
  slideIndex: number;
  layoutName?: string;
  layoutType?: string;
}
interface ApplyLayoutResult {
  slideIndex: number;
  layoutName: string;
}
declare function applyLayout(ctx: ToolContext, params: ApplyLayoutParams): ToolResult<ApplyLayoutResult>;
//#endregion
export { type AccessibilityCheckResult, type AccessibilityIssue, type AddChartSeriesParams, type AddElementParams, type AddElementResult, type AddSlideParams, type AddSlideResult, type ApplyLayoutParams, type ApplyLayoutResult, type ApplyTemplateParams, type ApplyTemplateResult, type ApplyThemePresetParams, type ApplyThemePresetResult, type ArrangeElementsParams, type BatchUpdateElementsParams, type CloneElementParams, type CloneElementResult, type CollaborationProvider, type CommentInfo, type ConvertToMarkdownParams, type ConvertToMarkdownResult, type CreateChartParams, type CreateChartResult, type DeleteElementsParams, type DeleteSlidesParams, type DeleteSlidesResult, type DiffPresentationsParams, type DuplicateSlideParams, type ExecutionContext, type ExportSlideSvgParams, type ExportSlideSvgResult, type ExportToSvgParams, type ExportToSvgResult, type FileSystemProvider, type FindPlaceholdersResult, type FindTextParams, type FindTextResult, type GetLayoutsResult, type GetSlideResult, type GroupElementsParams, type GroupElementsResult, type HyperlinkInfo, type LayoutInfo, 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, PptxHandler, type PptxSlide, type RemoveChartSeriesParams, type ReorderSlidesParams, type RepairPresentationResult, type ReplaceGeometryParams, type ReplaceTextParams, type ReplaceTextResult, type SectionInfo, type SetCanvasSizeParams, type SetElementAnimationParams, type SetElementLockParams, type SetSlideTransitionParams, type SmartArtNodeInfo, type TextMatch, type ThemeInfo, type ToolContext, type ToolResult, type UngroupElementsParams, type UngroupElementsResult, type UpdateChartParams, type UpdateChartSeriesDataParams, type UpdateElementParams, type UpdateElementStyleParams, type UpdateMetadataParams, type UpdatePresentationPropertiesParams, type UpdateSlidePropertiesParams, type UpdateTableCellsParams, type UpdateThemeColorsParams, type UpdateThemeFontsParams, type ValidatePresentationResult, type ViewerProvider, addChartSeriesT, addElement, addSlide, applyLayout, applyTemplateT, applyThemePreset, arrangeElements, batchUpdateElements, cloneElement, convertToMarkdown, createChart, deleteElements, deleteSlides, describeElement, diffPresentationsT, duplicateSlide, executeToolWithContext, exportSlideSvg, exportToSvg, extractSlideText, findPlaceholdersT, findText, generateElementId, generateSlideId, getLayouts, getMetadata, getPresentationProperties, getSlide, getThemeInfo, groupElements, loadPresentation, manageComments, manageHyperlinks, manageSections, manageSmartArt, manageTableStructure, mergePresentationT, removeChartSeriesT, reorderSlides, repairPresentation, replaceGeometry, replaceText, runAccessibilityCheck, savePresentation, setCanvasSize, setElementAnimation, setElementLockT, setSlideTransition, ungroupElements, updateChart, updateChartSeriesData, updateElement, updateElementStyle, updateMetadata, updatePresentationProperties, updateSlideProperties, updateTableCells, updateThemeColors, updateThemeFonts, validatePresentation, validateSlideIndex };
//# sourceMappingURL=index.d.ts.map