## API Report File for "@eigenpal/docx-editor-core"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import { EditorView } from 'prosemirror-view';
import { Node as Node_2 } from 'prosemirror-model';
import { Plugin as Plugin_2 } from 'prosemirror-state';

// @public
export type AgentCommand = InsertTextCommand | ReplaceTextCommand | DeleteTextCommand | FormatTextCommand | FormatParagraphCommand | ApplyStyleCommand | InsertTableCommand | InsertImageCommand | InsertHyperlinkCommand | RemoveHyperlinkCommand | InsertParagraphBreakCommand | MergeParagraphsCommand | SplitParagraphCommand | SetVariableCommand | ApplyVariablesCommand;

// @public
export interface AgentContext {
    availableStyles: StyleInfo[];
    characterCount: number;
    hasHyperlinks: boolean;
    hasImages: boolean;
    hasTables: boolean;
    language?: string;
    outline: ParagraphOutline[];
    paragraphCount: number;
    sections: SectionInfo[];
    variableCount: number;
    variables: string[];
    wordCount: number;
}

// @public
export interface AgentContextOptions {
    includeFormatting?: boolean;
    includeTableContent?: boolean;
    maxOutlineParagraphs?: number;
    outlineMaxChars?: number;
}

// @public
export interface AgentResponse {
    commands?: AgentCommand[];
    error?: string;
    metadata?: Record<string, unknown>;
    newContent?: AgentContent[];
    newText?: string;
    success: boolean;
    warnings?: string[];
}

// @public
export type AIAction = 'askAI' | 'rewrite' | 'expand' | 'summarize' | 'translate' | 'explain' | 'fixGrammar' | 'makeFormal' | 'makeCasual' | 'custom';

// @public
export interface AIActionRequest {
    action: AIAction;
    context: SelectionContext;
    customPrompt?: string;
    options?: Record<string, unknown>;
    targetLanguage?: string;
}

// @public
export interface ApplyStyleCommand extends BaseCommand {
    paragraphIndex: number;
    styleId: string;
    // (undocumented)
    type: 'applyStyle';
}

// @public
export function attemptSelectiveSave(doc: Document_2, originalBuffer: ArrayBuffer, options: SelectiveSaveOptions): Promise<ArrayBuffer | null>;

// @public
export class AutoSaveManager extends Subscribable<AutoSaveSnapshot> {
    constructor(options?: AutoSaveManagerOptions);
    acceptRecovery(): Document_2 | null;
    clear(): void;
    destroy(): void;
    disable(): void;
    dismissRecovery(): void;
    enable(): void;
    getRecoveryData(): SavedDocumentData | null;
    onDocumentChanged(document: Document_2 | null): void;
    save(): Promise<boolean>;
    startInterval(): void;
}

// @public
export interface AutoSaveManagerOptions {
    debounceDelay?: number;
    interval?: number;
    maxAge?: number;
    onError?: (error: Error) => void;
    onRecoveryAvailable?: (savedDocument: SavedDocumentData) => void;
    onSave?: (timestamp: Date) => void;
    saveOnChange?: boolean;
    storageKey?: string;
}

// @public
export interface AutoSaveSnapshot {
    // (undocumented)
    hasRecoveryData: boolean;
    // (undocumented)
    isEnabled: boolean;
    // (undocumented)
    lastSaveTime: Date | null;
    // (undocumented)
    status: AutoSaveStatus;
}

// @public
export type AutoSaveStatus = 'idle' | 'saving' | 'saved' | 'error';

// @public
export function blendColors(color1: ColorValue | undefined | null, color2: ColorValue | undefined | null, ratio: number, theme: Theme | null | undefined): string;

// @public
export type BlockContent = Paragraph | Table | BlockSdt;

// @public
export interface BookmarkEnd {
    id: number;
    // (undocumented)
    type: 'bookmarkEnd';
}

// @public
export interface BookmarkStart {
    colFirst?: number;
    // (undocumented)
    colLast?: number;
    id: number;
    name: string;
    // (undocumented)
    type: 'bookmarkStart';
}

// @public
export function buildExtendedSelectionContext(doc: Document_2, range: Range_2, options?: SelectionContextOptions): ExtendedSelectionContext;

// @public
export function buildFootnoteContentMap(footnotes: Footnote[], footnoteRefs: Array<{
    footnoteId: number;
}>, contentWidth: number, options: ConvertFootnoteOptions): Map<number, FootnoteContent>;

// @public
export function buildFootnoteRenderItems(pageFootnoteMap: Map<number, number[]>, footnoteContentMap: Map<number, FootnoteContent>, doc: Document_2 | null): Map<number, FootnoteRenderItem[]>;

// @public
export function buildPatchedDocumentXml(originalXml: string, serializedXml: string, changedIds: Set<string>): string | null;

// @public
export function buildSelectionContext(doc: Document_2, range: Range_2, options?: SelectionContextOptions): SelectionContext;

// @public
export function calculateFootnoteReservedHeights(pageFootnoteMap: Map<number, number[]>, footnoteContentMap: Map<number, {
    height: number;
}>): Map<number, number>;

// @public
export function canRenderFont(fontFamily: string, fallbackFont?: string): boolean;

// @public
interface CaretPosition_2 {
    // (undocumented)
    height: number;
    // (undocumented)
    pageIndex: number;
    // (undocumented)
    x: number;
    // (undocumented)
    y: number;
}
export { CaretPosition_2 as CaretPosition }

// @public
export interface CellCoordinates {
    // (undocumented)
    columnIndex: number;
    // (undocumented)
    rowIndex: number;
    // (undocumented)
    tableIndex: number;
}

// @public
export interface ClipboardSelection {
    // (undocumented)
    endOffset: number;
    // (undocumented)
    endParagraphIndex: number;
    // (undocumented)
    endRunIndex: number;
    // (undocumented)
    isMultiParagraph: boolean;
    // (undocumented)
    runs: Run[];
    // (undocumented)
    startOffset: number;
    // (undocumented)
    startParagraphIndex: number;
    // (undocumented)
    startRunIndex: number;
    // (undocumented)
    text: string;
}

// @public
export function collectFootnoteRefs(blocks: FlowBlock[]): Array<{
    footnoteId: number;
    pmPos: number;
}>;

// @public
export function colorsEqual(color1: ColorValue | undefined | null, color2: ColorValue | undefined | null, theme: Theme | null | undefined): boolean;

// @public
export interface ColumnResizeState {
    // (undocumented)
    columnIndex: number;
    // (undocumented)
    isResizing: boolean;
    // (undocumented)
    originalWidths: {
        left: number;
        right: number;
    };
    // (undocumented)
    startX: number;
    // (undocumented)
    tablePmStart: number;
}

// @public
interface Comment_2 {
    author: string;
    content: Paragraph[];
    date?: string;
    done?: boolean;
    id: number;
    initials?: string;
    parentId?: number;
}
export { Comment_2 as Comment }

// @public
export interface CommentRangeEnd {
    // (undocumented)
    id: number;
    // (undocumented)
    type: 'commentRangeEnd';
}

// @public
export interface CommentRangeStart {
    // (undocumented)
    id: number;
    // (undocumented)
    type: 'commentRangeStart';
}

// @public
export type ConvertFootnoteOptions = {
    styles?: StyleDefinitions | null;
    theme?: Theme | null;
    measureBlocks: MeasureBlocksFn;
    defaultTabStopTwips?: number | null;
};

// @public (undocumented)
export type ConvertHeaderFooterOptions = {
    styles?: StyleDefinitions | null;
    theme?: Theme | null;
    measureBlocks: MeasureBlocksFn;
    defaultTabStopTwips?: number | null;
};

// @public
export function convertHeaderFooterToContent(headerFooter: HeaderFooter | null | undefined, contentWidth: number, metrics: HeaderFooterMetrics, options: ConvertHeaderFooterOptions): HeaderFooterContent | undefined;

// @public
export interface CorePlugin {
    commandHandlers?: Record<string, CommandHandler>;
    dependencies?: string[];
    description?: string;
    destroy?: () => void | Promise<void>;
    id: string;
    initialize?: () => void | Promise<void>;
    mcpTools?: McpToolDefinition[];
    name: string;
    version?: string;
}

// @public
export function countPageBreaks(doc: Document_2): number;

// @public
export function createColumnBreak(): BreakContent;

// @public
export function createDocumentWithText(text: string, options?: Omit<CreateEmptyDocumentOptions, 'initialText'>): Document_2;

// @public
export function createDocx(doc: Document_2): Promise<ArrayBuffer>;

// @public
export function createEmptyDocument(options?: CreateEmptyDocumentOptions): Document_2;

// @public
export interface CreateEmptyDocumentOptions {
    initialText?: string;
    marginBottom?: number;
    marginLeft?: number;
    marginRight?: number;
    marginTop?: number;
    orientation?: 'portrait' | 'landscape';
    pageHeight?: number;
    pageWidth?: number;
}

// @public
export function createHorizontalRule(): Paragraph;

// @public
export function createLineBreak(clear?: 'none' | 'left' | 'right' | 'all'): BreakContent;

// @public
export function createPageBreak(): BreakContent;

// @public
export function createPageBreakParagraph(): Paragraph;

// @public
export function createPageBreakRun(): Run;

// @public
export function createRgbColor(hex: string): ColorValue;

// @public
export function createSelectionFromDOM(): ClipboardSelection | null;

// @public
export function createThemeColor(themeColor: ThemeColorSlot, tint?: number, shade?: number): ColorValue;

// @public
export function darkenColor(color: ColorValue | undefined | null, theme: Theme | null | undefined, percent: number): string;

// @internal
export function deleteTableFromDocument(doc: Document_2, tableIndex: number): Document_2;

// @public
export interface DeleteTextCommand extends BaseCommand {
    range: Range_2;
    // (undocumented)
    type: 'deleteText';
}

// @public
export interface Deletion {
    content: (Run | Hyperlink)[];
    info: TrackedChangeInfo;
    // (undocumented)
    type: 'deletion';
}

// @public
export function detectVariables(doc: Document_2): string[];

// @public
export function detectVariablesDetailed(doc: Document_2): VariableDetectionResult;

// @public
export function detectVariablesInBody(body: DocumentBody): string[];

// @public
export function detectVariablesInParagraph(paragraph: Paragraph): string[];

// @public
interface Document_2 {
    originalBuffer?: ArrayBuffer;
    package: DocxPackage;
    templateVariables?: string[];
    warnings?: string[];
}
export { Document_2 as Document }

// @public
export class DocumentAgent {
    constructor(source: Document_2 | ArrayBuffer);
    applyFormatting(range: Range_2, formatting: Partial<TextFormatting>): DocumentAgent;
    applyParagraphFormatting(paragraphIndex: number, formatting: Partial<ParagraphFormatting>): DocumentAgent;
    applyStyle(paragraphIndex: number, styleId: string): DocumentAgent;
    applyVariables(variables?: Record<string, string>): Promise<DocumentAgent>;
    clearPendingVariables(): DocumentAgent;
    deleteRange(range: Range_2): DocumentAgent;
    executeCommands(commands: AgentCommand[]): DocumentAgent;
    static fromBuffer(buffer: DocxInput): Promise<DocumentAgent>;
    static fromDocument(document: Document_2): DocumentAgent;
    getAgentContext(outlineMaxChars?: number): AgentContext;
    getCharacterCount(includeSpaces?: boolean): number;
    getDocument(): Document_2;
    getFormattedText(): FormattedTextSegment[];
    getPageCount(): number;
    getParagraphCount(): number;
    getPendingVariables(): Record<string, string>;
    getStyles(): StyleInfo[];
    getTableCount(): number;
    getText(): string;
    getVariables(): string[];
    getWordCount(): number;
    insertHyperlink(range: Range_2, url: string, options?: InsertHyperlinkOptions): DocumentAgent;
    insertImage(position: Position_2, src: string, options?: InsertImageOptions): DocumentAgent;
    insertParagraphBreak(position: Position_2): DocumentAgent;
    insertTable(position: Position_2, rows: number, cols: number, options?: InsertTableOptions): DocumentAgent;
    insertText(position: Position_2, text: string, options?: InsertTextOptions): DocumentAgent;
    mergeParagraphs(startParagraphIndex: number, count: number): DocumentAgent;
    removeHyperlink(range: Range_2): DocumentAgent;
    replaceRange(range: Range_2, text: string, options?: InsertTextOptions): DocumentAgent;
    setVariable(name: string, value: string): DocumentAgent;
    setVariables(variables: Record<string, string>): DocumentAgent;
    toBlob(mimeType?: string): Promise<Blob>;
    toBuffer(options?: {
        selective?: SelectiveSaveOptions;
    }): Promise<ArrayBuffer>;
}

// @public
export interface DocumentBody {
    comments?: Comment_2[];
    content: BlockContent[];
    finalSectionProperties?: SectionProperties;
    sections?: Section[];
}

// @public
export function documentHasVariables(doc: Document_2): boolean;

// @public
export type DocxInput = ArrayBuffer | Uint8Array | Blob | File;

// @public
export interface DocxPackage {
    document: DocumentBody;
    endnotes?: Endnote[];
    endnoteSeparators?: Endnote[];
    fontTable?: FontTable;
    footers?: Map<string, HeaderFooter>;
    footnotes?: Footnote[];
    footnoteSeparators?: Footnote[];
    headers?: Map<string, HeaderFooter>;
    media?: Map<string, MediaFile>;
    numbering?: NumberingDefinitions;
    properties?: {
        title?: string;
        subject?: string;
        creator?: string;
        keywords?: string;
        description?: string;
        lastModifiedBy?: string;
        revision?: number;
        created?: Date;
        modified?: Date;
    };
    relationships?: RelationshipMap;
    settings?: DocumentSettings;
    styles?: StyleDefinitions;
    theme?: Theme;
}

// @public
export const docxtemplaterPlugin: CorePlugin;

// @public (undocumented)
export class EditorCoordinator extends Subscribable<EditorCoordinatorSnapshot> {
    constructor(options?: EditorCoordinatorOptions);
    getDocument(): Document_2 | null;
    getZoom(): number;
    setDocumentLoaded(document: Document_2): void;
    setFontsLoaded(): void;
    setLoadError(error: Error): void;
    setParsingStarted(): void;
    setZoom(zoom: number): void;
    updateDocument(document: Document_2): void;
}

// @public
export interface EditorCoordinatorOptions {
    initialZoom?: number;
    onChange?: (document: Document_2) => void;
    onError?: (error: Error) => void;
}

// @public
export interface EditorCoordinatorSnapshot {
    fontsLoaded: boolean;
    isReady: boolean;
    loadingState: EditorLoadingState;
    parseError: string | null;
    version: number;
    zoom: number;
}

// @public
export interface EditorHandle {
    destroy(): void;
    focus(): void;
    getDocument(): Document_2 | null;
    save(): Promise<Blob | null>;
}

// @public
export type EditorLoadingState = 'idle' | 'parsing' | 'loading-fonts' | 'ready' | 'error';

// @public
export interface EditorPluginCore<TState = any> {
    destroy?: () => void;
    id: string;
    initialize?: (view: EditorView | null) => TState;
    name: string;
    onStateChange?: (view: EditorView) => TState | undefined;
    panelConfig?: PanelConfig;
    proseMirrorPlugins?: Plugin_2[];
    styles?: string;
}

// @public
export function emuToPixels(emu: number | undefined | null): number;

// @public
export function emuToTwips(emu: number): number;

// @public
export interface Endnote {
    content: BlockContent[];
    id: number;
    noteType?: 'normal' | 'separator' | 'continuationSeparator' | 'continuationNotice';
    // (undocumented)
    type: 'endnote';
    verbatimXml?: string;
}

// @public
export function ensureHexPrefix(hex: string): string;

// @public
export class ErrorManager extends Subscribable<ErrorManagerSnapshot> {
    constructor();
    clearAll(): void;
    destroy(): void;
    dismiss(id: string): void;
    showError(message: string, details?: string): string;
    showInfo(message: string, details?: string): string;
    showWarning(message: string, details?: string): string;
}

// @public
export interface ErrorManagerSnapshot {
    // (undocumented)
    notifications: ErrorNotification[];
}

// @public
export interface ErrorNotification {
    // (undocumented)
    details?: string;
    // (undocumented)
    dismissed?: boolean;
    // (undocumented)
    id: string;
    // (undocumented)
    message: string;
    // (undocumented)
    severity: ErrorSeverity;
    // (undocumented)
    timestamp: number;
}

// @public
export type ErrorSeverity = 'error' | 'warning' | 'info';

// @public
export function executeCommand(doc: Document_2, command: AgentCommand): Document_2;

// @public
export function executeCommands(doc: Document_2, commands: AgentCommand[]): Document_2;

// @public
export interface ExtendedSelectionContext extends SelectionContext {
    characterCount?: number;
    contentType?: 'prose' | 'list' | 'heading' | 'table' | 'mixed';
    detectedLanguage?: string;
    documentSummary?: string;
    isMultiParagraph?: boolean;
    paragraphIndices?: number[];
    wordCount?: number;
}

// @public
export function extractFormattingFromElement(element: HTMLElement): Run['formatting'];

// @public
export function extractVariablesFromText(text: string): string[];

// @public (undocumented)
export type Field = SimpleField | ComplexField;

// @public
export function findPageBreaks(doc: Document_2): InsertPosition_2[];

// @public
export function findParagraphByParaId(doc: Node_2, paraId: string): {
    node: Node_2;
    from: number;
    to: number;
} | null;

// @public
export function findStartPosForParaId(doc: Node_2, paraId: string): number | null;

// @internal
export function findTableFromClick(target: EventTarget | null, container?: HTMLElement | null): CellCoordinates | null;

// @public
export type FlowBlock = ParagraphBlock | TableBlock | ImageBlock | TextBoxBlock | SectionBreakBlock | PageBreakBlock | ColumnBreakBlock;

// @public (undocumented)
export interface FooterReference {
    // (undocumented)
    rId: string;
    // (undocumented)
    type: HeaderFooterType;
}

// @public
export interface Footnote {
    content: BlockContent[];
    id: number;
    noteType?: 'normal' | 'separator' | 'continuationSeparator' | 'continuationNotice';
    // (undocumented)
    type: 'footnote';
    verbatimXml?: string;
}

// @public
export const FOOTNOTE_SEPARATOR_HEIGHT = 12;

// @public
export type FootnoteContent = {
    id: number;
    displayNumber: number;
    blocks: FlowBlock[];
    measures: Measure[];
    height: number;
};

// @public
export function footnoteReservedHeightsEqual(a: Map<number, number>, b: Map<number, number>): boolean;

// @public
export function formatLastSaveTime(date: Date | null): string;

// @public
export function formatPx(px: number): string;

// @public
export function formatStorageSize(bytes: number): string;

// @public
export interface FormatTextCommand extends BaseCommand {
    formatting: Partial<TextFormatting>;
    range: Range_2;
    // (undocumented)
    type: 'formatText';
}

// @public
export function formatVariable(name: string): string;

// @public
export function generateThemeTintShadeMatrix(colorScheme?: ThemeColorScheme | null): ThemeMatrixCell[][];

// @public
export function getAgentContext(doc: Document_2, options?: AgentContextOptions): AgentContext;

// @public
export function getAutoSaveStatusLabel(status: AutoSaveStatus): string;

// @public
export function getAutoSaveStorageSize(storageKey?: string): number;

// @public
export function getContrastingColor(backgroundColor: ColorValue | undefined | null, theme: Theme | null | undefined): string;

// @public
export function getDocumentSummary(doc: Document_2): string;

// @public
export function getLoadedFonts(): string[];

// @public
export function getSelectionRuns(): Run[];

// @internal
export function getTableFromDocument(doc: Document_2, tableIndex: number): Table | null;

// @public
export function getTemplateTags(buffer: ArrayBuffer): string[];

// @public
export function getThemeTintShadeHex(baseHex: string, type: 'tint' | 'shade', fraction: number): string;

// @public
export function halfPointsToPixels(halfPoints: number): number;

// @public
export function hasPageBreakBefore(paragraph: Paragraph): boolean;

// @public
export function hasTemplateVariables(text: string): boolean;

// @public
export interface HeaderFooter {
    content: BlockContent[];
    hdrFtrType: HeaderFooterType;
    // (undocumented)
    type: 'header' | 'footer';
    watermark?: Watermark;
}

// @public
export type HeaderFooterMetrics = {
    section: 'header' | 'footer';
    pageSize: {
        w: number;
        h: number;
    };
    margins: PageMargins;
};

// @public
export interface HeaderReference {
    // (undocumented)
    rId: string;
    // (undocumented)
    type: HeaderFooterType;
}

// @public
export interface Hyperlink {
    anchor?: string;
    children: (Run | BookmarkStart | BookmarkEnd)[];
    docLocation?: string;
    history?: boolean;
    href?: string;
    rId?: string;
    target?: string;
    tooltip?: string;
    // (undocumented)
    type: 'hyperlink';
}

// @public
interface Image_2 {
    allowOverlap?: boolean;
    alt?: string;
    crop?: ImageCrop;
    decorative?: boolean;
    effects?: {
        brightness?: number;
        contrast?: number;
        saturation?: number;
    };
    filename?: string;
    hlinkHref?: string;
    id?: string;
    layoutInCell?: boolean;
    mimeType?: string;
    opacity?: number;
    originalSize?: ImageSize;
    outline?: ShapeOutline;
    padding?: ImagePadding;
    position?: ImagePosition;
    rId: string;
    size: ImageSize;
    src?: string;
    title?: string;
    transform?: ImageTransform;
    // (undocumented)
    type: 'image';
    wrap: ImageWrap;
}
export { Image_2 as Image }

// @public
export interface ImageSelectionInfo {
    // (undocumented)
    heightEmu: number;
    // (undocumented)
    isInline: boolean;
    // (undocumented)
    pageIndex: number;
    // (undocumented)
    pmPos: number;
    // (undocumented)
    rect: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    // (undocumented)
    widthEmu: number;
}

// @public
export function injectStyles(pluginId: string, css: string): () => void;

// @public
export function insertHorizontalRule(doc: Document_2, position: InsertPosition_2): Document_2;

// @public
export interface InsertHyperlinkCommand extends BaseCommand {
    displayText?: string;
    range: Range_2;
    tooltip?: string;
    // (undocumented)
    type: 'insertHyperlink';
    url: string;
}

// @public
export interface InsertImageCommand extends BaseCommand {
    alt?: string;
    height?: number;
    position: Position_2;
    src: string;
    // (undocumented)
    type: 'insertImage';
    width?: number;
}

// @public
export interface Insertion {
    content: (Run | Hyperlink)[];
    info: TrackedChangeInfo;
    // (undocumented)
    type: 'insertion';
}

// @public
export function insertPageBreak(doc: Document_2, position: InsertPosition_2): Document_2;

// @public
interface InsertPosition_2 {
    offset?: number;
    paragraphIndex: number;
    runIndex?: number;
}
export { InsertPosition_2 as InsertPosition }

// @public
export interface InsertTableCommand extends BaseCommand {
    columns: number;
    data?: string[][];
    hasHeader?: boolean;
    position: Position_2;
    rows: number;
    // (undocumented)
    type: 'insertTable';
}

// @public
export interface InsertTextCommand extends BaseCommand {
    formatting?: TextFormatting;
    position: Position_2;
    text: string;
    // (undocumented)
    type: 'insertText';
}

// @public
export function isAutoSaveSupported(): boolean;

// @public
export function isBlack(color: ColorValue | undefined | null, theme: Theme | null | undefined): boolean;

// @public
export function isBreakContent(content: RunContent): content is BreakContent;

// @public
export function isColumnBreak(content: RunContent): boolean;

// @public
export function isFontLoaded(fontFamily: string): boolean;

// @public
export function isFontsLoading(): boolean;

// @public
export function isGoogleFontsEnabled(): boolean;

// @public
export function isLineBreak(content: RunContent): boolean;

// @public
export function isPageBreak(content: RunContent): boolean;

// @public
export function isValidVariableName(name: string): boolean;

// @public
export function isWhite(color: ColorValue | undefined | null, theme: Theme | null | undefined): boolean;

// @public
export type Layout = {
    pageSize: {
        w: number;
        h: number;
    };
    pages: Page[];
    columns?: ColumnLayout;
    headers?: Record<string, HeaderFooterLayout>;
    footers?: Record<string, HeaderFooterLayout>;
    pageGap?: number;
};

// @public (undocumented)
export class LayoutCoordinator extends Subscribable<LayoutCoordinatorSnapshot> {
    constructor();
    clearSelectedImage(): void;
    endColumnResize(): void;
    endDrag(): void;
    getColumnResize(): ColumnResizeState;
    getDragAnchor(): number | null;
    setFocused(focused: boolean): void;
    setImageInteracting(interacting: boolean): void;
    setLayoutReady(hasLayout: boolean): void;
    setSelectedImage(imageInfo: ImageSelectionInfo | null): void;
    startColumnResize(tablePmStart: number, columnIndex: number, startX: number, originalWidths: {
        left: number;
        right: number;
    }): void;
    startDrag(anchor: number): void;
    updateSelection(selectionRects: SelectionRect[], caretPosition: CaretPosition_2 | null): void;
}

// @public
export interface LayoutCoordinatorSnapshot {
    caretPosition: CaretPosition_2 | null;
    hasLayout: boolean;
    isDragging: boolean;
    isFocused: boolean;
    isImageInteracting: boolean;
    isResizingColumn: boolean;
    selectedImageInfo: ImageSelectionInfo | null;
    selectionRects: SelectionRect[];
    version: number;
}

// @public
export function lightenColor(color: ColorValue | undefined | null, theme: Theme | null | undefined, percent: number): string;

// @public
export interface ListLevel {
    ilvl: number;
    isLgl?: boolean;
    legacy?: {
        legacy?: boolean;
        legacySpace?: number;
        legacyIndent?: number;
    };
    lvlJc?: 'left' | 'center' | 'right';
    lvlRestart?: number;
    lvlText: string;
    numFmt: NumberFormat;
    pPr?: ParagraphFormatting;
    rPr?: TextFormatting;
    start?: number;
    suffix?: LevelSuffix;
}

// @public
export function loadFont(fontFamily: string, options?: {
    weights?: number[];
    styles?: ('normal' | 'italic')[];
}): Promise<boolean>;

// @public
export function loadFontFromBuffer(fontFamily: string, buffer: ArrayBuffer, options?: {
    weight?: number | string;
}): Promise<boolean>;

// @public
export function loadFonts(families: string[], options?: {
    weights?: number[];
    styles?: ('normal' | 'italic')[];
}): Promise<void>;

// @public
export function mapFootnotesToPages(pages: Page[], footnoteRefs: Array<{
    footnoteId: number;
    pmPos: number;
}>): Map<number, number[]>;

// @public
export const MAX_FOOTNOTE_LAYOUT_PASSES = 6;

// @public
export interface McpSession {
    data: Map<string, unknown>;
    documents: Map<string, LoadedDocument>;
    id: string;
}

// @public
export interface McpToolDefinition {
    annotations?: McpToolAnnotations;
    description: string;
    handler: McpToolHandler;
    inputSchema: JsonSchema | ZodSchemaLike;
    name: string;
}

// @public
export type McpToolHandler = (input: unknown, context: McpToolContext) => Promise<McpToolResult> | McpToolResult;

// @public
export interface McpToolResult {
    content: McpToolContent[];
    isError?: boolean;
}

// @public
export type Measure = ParagraphMeasure | ImageMeasure | TableMeasure | TextBoxMeasure | SectionBreakMeasure | PageBreakMeasure | ColumnBreakMeasure;

// @public
export type MeasureBlocksFn = (blocks: FlowBlock[], contentWidth: number) => Measure[];

// @public
export interface MoveFrom {
    content: (Run | Hyperlink)[];
    info: TrackedChangeInfo;
    // (undocumented)
    type: 'moveFrom';
}

// @public
export interface MoveTo {
    content: (Run | Hyperlink)[];
    info: TrackedChangeInfo;
    // (undocumented)
    type: 'moveTo';
}

// @public
export interface NumberingDefinitions {
    abstractNums: AbstractNumbering[];
    nums: NumberingInstance[];
}

// @public
export function onFontsLoaded(callback: (fonts: string[]) => void): () => void;

// @public
export type Page = {
    number: number;
    fragments: Fragment[];
    margins: PageMargins;
    size: {
        w: number;
        h: number;
    };
    orientation?: 'portrait' | 'landscape';
    sectionIndex?: number;
    headerFooterRefs?: {
        headerDefault?: string;
        headerFirst?: string;
        headerEven?: string;
        footerDefault?: string;
        footerFirst?: string;
        footerEven?: string;
    };
    footnoteIds?: number[];
    footnoteReservedHeight?: number;
    columns?: ColumnLayout;
};

// @public
export interface PanelConfig {
    collapsible?: boolean;
    defaultCollapsed?: boolean;
    defaultSize: number;
    maxSize?: number;
    minSize?: number;
    position: 'left' | 'right' | 'bottom';
    resizable?: boolean;
}

// @public
export interface Paragraph {
    content: ParagraphContent[];
    formatting?: ParagraphFormatting;
    listRendering?: ListRendering;
    paraId?: string;
    pPrDel?: TrackedChangeInfo;
    pPrIns?: TrackedChangeInfo;
    propertyChanges?: ParagraphPropertyChange[];
    renderedPageBreakBefore?: boolean;
    sectionProperties?: SectionProperties;
    textId?: string;
    // (undocumented)
    type: 'paragraph';
}

// @public
export type ParagraphContent = Run | Hyperlink | BookmarkStart | BookmarkEnd | SimpleField | ComplexField | InlineSdt | CommentRangeStart | CommentRangeEnd | Insertion | Deletion | MoveFrom | MoveTo | MoveFromRangeStart | MoveFromRangeEnd | MoveToRangeStart | MoveToRangeEnd | MathEquation;

// @public
export interface ParagraphContext {
    fullText: string;
    index: number;
    style?: string;
    wordCount: number;
}

// @public
export interface ParagraphFormatting {
    afterAutospacing?: boolean;
    alignment?: ParagraphAlignment;
    beforeAutospacing?: boolean;
    bidi?: boolean;
    borders?: {
        top?: BorderSpec;
        bottom?: BorderSpec;
        left?: BorderSpec;
        right?: BorderSpec;
        between?: BorderSpec;
        bar?: BorderSpec;
    };
    contextualSpacing?: boolean;
    frame?: {
        width?: number;
        height?: number;
        hAnchor?: 'text' | 'margin' | 'page';
        vAnchor?: 'text' | 'margin' | 'page';
        x?: number;
        y?: number;
        xAlign?: 'left' | 'center' | 'right' | 'inside' | 'outside';
        yAlign?: 'top' | 'center' | 'bottom' | 'inside' | 'outside' | 'inline';
        wrap?: 'around' | 'auto' | 'none' | 'notBeside' | 'through' | 'tight';
    };
    hangingIndent?: boolean;
    indentFirstLine?: number;
    indentLeft?: number;
    indentRight?: number;
    keepLines?: boolean;
    keepNext?: boolean;
    lineSpacing?: number;
    lineSpacingRule?: LineSpacingRule;
    numPr?: {
        numId?: number;
        ilvl?: number;
    };
    numPrFromStyle?: {
        numId?: number;
        ilvl?: number;
    };
    outlineLevel?: number;
    pageBreakBefore?: boolean;
    runProperties?: TextFormatting;
    shading?: ShadingProperties;
    spaceAfter?: number;
    spaceBefore?: number;
    spacingExplicit?: SpacingExplicit;
    styleId?: string;
    suppressAutoHyphens?: boolean;
    suppressLineNumbers?: boolean;
    tabs?: TabStop[];
    widowControl?: boolean;
}

// @public
export function parseColorString(colorString: string | undefined): ColorValue | undefined;

// @public
export function parseDocx(input: DocxInput, options?: ParseOptions): Promise<Document_2>;

// @public
export function parseVariable(variable: string): string | null;

// @public
export function pixelsToEmu(px: number): number;

// @public
export function pixelsToTwips(px: number): number;

// @public
export interface PluginLifecycleConfig {
    // (undocumented)
    destroy?: () => void;
    // (undocumented)
    id: string;
    // (undocumented)
    initialize?: (editorView: EditorView) => unknown;
    // (undocumented)
    onStateChange?: (editorView: EditorView) => unknown;
    // (undocumented)
    styles?: string;
}

// @public (undocumented)
export class PluginLifecycleManager extends Subscribable<PluginLifecycleSnapshot> {
    constructor();
    destroy(): void;
    getPluginState<T>(pluginId: string): T | undefined;
    initialize(plugins: PluginLifecycleConfig[], editorView: EditorView): void;
    setPluginState<T>(pluginId: string, state: T): void;
    updateStates(editorView: EditorView): boolean;
}

// @public
export interface PluginLifecycleSnapshot {
    states: Map<string, unknown>;
    version: number;
}

// @public
export interface PluginPanelProps<TState = unknown> {
    doc: Node_2 | null;
    editorView: EditorView | null;
    panelWidth: number;
    pluginState: TState;
    renderedDomContext: RenderedDomContext | null;
    scrollToPosition: (pos: number) => void;
    selectRange: (from: number, to: number) => void;
}

// @public
export class PluginRegistry {
    addEventListener(listener: PluginEventListener): void;
    clear(): void;
    get(id: string): CorePlugin | undefined;
    getAll(): CorePlugin[];
    getCommandHandler(commandType: string): CommandHandler | undefined;
    getCommandTypes(): string[];
    getDebugInfo(): {
        plugins: string[];
        commandTypes: string[];
        mcpTools: string[];
        initialized: string[];
    };
    getMcpTool(toolName: string): McpToolDefinition | undefined;
    getMcpTools(): McpToolDefinition[];
    getMcpToolsForPlugin(pluginId: string): McpToolDefinition[];
    has(id: string): boolean;
    hasCommandHandler(commandType: string): boolean;
    register(plugin: CorePlugin, options?: PluginOptions): PluginRegistrationResult;
    removeEventListener(listener: PluginEventListener): void;
    get size(): number;
    unregister(pluginId: string): boolean;
}

// @public
export const pluginRegistry: PluginRegistry;

// @public
export function pointsToPixels(points: number): number;

// @public
interface Position_2 {
    contentIndex?: number;
    offset: number;
    paragraphIndex: number;
    sectionIndex?: number;
}
export { Position_2 as Position }

// @public
export interface PositionCoordinates {
    // (undocumented)
    height: number;
    // (undocumented)
    x: number;
    // (undocumented)
    y: number;
}

// @public
export function preloadCommonFonts(): Promise<void>;

// @public
export function processTemplate(buffer: ArrayBuffer, variables: Record<string, string>, options?: ProcessTemplateOptions): ArrayBuffer;

// @public
export function processTemplateAsBlob(buffer: ArrayBuffer, variables: Record<string, string>, options?: ProcessTemplateOptions): Blob;

// @public
export function processTemplateDetailed(buffer: ArrayBuffer, variables: Record<string, string>, options?: ProcessTemplateOptions): ProcessTemplateResult;

// @public
export interface ProcessTemplateOptions {
    delimiters?: {
        start?: string;
        end?: string;
    };
    linebreaks?: boolean;
    nullGetter?: 'keep' | 'empty' | 'error';
    parser?: (tag: string) => {
        get: (scope: Record<string, unknown>) => unknown;
    };
}

// @public
export interface ProcessTemplateResult {
    buffer: ArrayBuffer;
    replacedVariables: string[];
    unreplacedVariables: string[];
    warnings: string[];
}

// @public
interface Range_2 {
    collapsed?: boolean;
    end: Position_2;
    start: Position_2;
}
export { Range_2 as Range }

// @public
export function registerPlugins(plugins: CorePlugin[], options?: PluginOptions): PluginRegistrationResult[];

// @public
export interface Relationship {
    id: string;
    target: string;
    targetMode?: 'External' | 'Internal';
    type: RelationshipType;
}

// @public
export function removePageBreak(doc: Document_2, position: InsertPosition_2): Document_2;

// @public
export function removeVariables(text: string, placeholder?: string): string;

// @public
export interface RenderedDomContext {
    findElementsForRange(from: number, to: number): Element[];
    getContainerOffset(): {
        x: number;
        y: number;
    };
    getCoordinatesForPosition(pmPos: number): PositionCoordinates | null;
    getRectsForRange(from: number, to: number): Array<{
        x: number;
        y: number;
        width: number;
        height: number;
    }>;
    pagesContainer: HTMLElement;
    zoom: number;
}

// @public
export function repackDocx(doc: Document_2, options?: RepackOptions): Promise<ArrayBuffer>;

// @public
export interface ReplaceTextCommand extends BaseCommand {
    formatting?: TextFormatting;
    range: Range_2;
    text: string;
    // (undocumented)
    type: 'replaceText';
}

// @public
export function replaceVariables(text: string, values: Record<string, string>): string;

// @public
export function resolveColor(color: ColorValue | undefined | null, theme: Theme | null | undefined, defaultColor?: string): string;

// @public
export function resolveHighlightColor(highlight: string | undefined): string;

// @public
export function resolveHighlightToCss(value: string): string;

// @public
export function resolveShadingColor(color: ColorValue | undefined | null, theme: Theme | null | undefined): string;

// @public (undocumented)
export const rgbToHex: typeof cssColorToHex;

// @public
export interface Run {
    content: RunContent[];
    formatting?: TextFormatting;
    propertyChanges?: RunPropertyChange[];
    // (undocumented)
    type: 'run';
}

// @public
export type RunContent = TextContent | TabContent | BreakContent | SymbolContent | NoteReferenceContent | NoteRefMarkContent | SeparatorContent | FieldCharContent | InstrTextContent | SoftHyphenContent | NoBreakHyphenContent | DrawingContent | ShapeContent;

// @public
export function sanitizeVariableName(name: string): string;

// @public
export interface SavedDocumentData {
    document: Document_2;
    documentId?: string;
    savedAt: string;
    version: number;
}

// @public
export interface SectionProperties {
    background?: {
        color?: ColorValue;
        themeColor?: ThemeColorSlot;
        themeTint?: string;
        themeShade?: string;
    };
    bidi?: boolean;
    columnCount?: number;
    columns?: Column[];
    columnSpace?: number;
    docGrid?: {
        type?: 'default' | 'lines' | 'linesAndChars' | 'snapToChars';
        linePitch?: number;
        charSpace?: number;
    };
    endnotePr?: EndnoteProperties;
    equalWidth?: boolean;
    evenAndOddHeaders?: boolean;
    footerDistance?: number;
    footerReferences?: FooterReference[];
    footnotePr?: FootnoteProperties;
    gutter?: number;
    headerDistance?: number;
    headerReferences?: HeaderReference[];
    lineNumbers?: {
        start?: number;
        countBy?: number;
        distance?: number;
        restart?: LineNumberRestart;
    };
    marginBottom?: number;
    marginLeft?: number;
    marginRight?: number;
    marginTop?: number;
    orientation?: PageOrientation;
    pageBorders?: {
        top?: BorderSpec;
        bottom?: BorderSpec;
        left?: BorderSpec;
        right?: BorderSpec;
        display?: 'allPages' | 'firstPage' | 'notFirstPage';
        offsetFrom?: 'page' | 'text';
        zOrder?: 'front' | 'back';
    };
    pageHeight?: number;
    pageWidth?: number;
    paperSrcFirst?: number;
    paperSrcOther?: number;
    sectionStart?: SectionStart;
    separator?: boolean;
    titlePg?: boolean;
    verticalAlign?: VerticalAlign;
}

// @public
export interface SelectionContext {
    formatting: Partial<TextFormatting>;
    inHyperlink?: boolean;
    inTable?: boolean;
    paragraph: ParagraphContext;
    paragraphFormatting: Partial<ParagraphFormatting>;
    range: Range_2;
    selectedText: string;
    suggestedActions?: SuggestedAction[];
    textAfter: string;
    textBefore: string;
}

// @public
export interface SelectionContextOptions {
    contextCharsAfter?: number;
    contextCharsBefore?: number;
    includeDocumentSummary?: boolean;
    includeSuggestions?: boolean;
    maxSuggestions?: number;
}

// @public
export interface SelectionRect {
    // (undocumented)
    height: number;
    // (undocumented)
    pageIndex: number;
    // (undocumented)
    width: number;
    // (undocumented)
    x: number;
    // (undocumented)
    y: number;
}

// @public
export function serializeDocumentBody(body: DocumentBody): string;

// @public
export function serializeDocx(doc: Document_2): string;

// @public
export function serializeSectionProperties(props: SectionProperties | undefined): string;

// @public
export function setGoogleFontsEnabled(enabled: boolean): void;

// @public
export interface SetVariableCommand extends BaseCommand {
    name: string;
    // (undocumented)
    type: 'setVariable';
    value: string;
}

// @public
export interface Shape {
    customGeometry?: string;
    fill?: ShapeFill;
    id?: string;
    name?: string;
    outline?: ShapeOutline;
    position?: ImagePosition;
    shapeType: ShapeType;
    size: ImageSize;
    textBody?: ShapeTextBody;
    transform?: ImageTransform;
    // (undocumented)
    type: 'shape';
    wrap?: ImageWrap;
}

// @public
export function stabilizeFootnoteLayout(args: StabilizeFootnoteLayoutArgs): StabilizeFootnoteLayoutResult;

// @public (undocumented)
export interface StabilizeFootnoteLayoutArgs {
    // (undocumented)
    blocks: FlowBlock[];
    // (undocumented)
    footnoteContentMap: Map<number, FootnoteContent>;
    // (undocumented)
    footnoteRefs: Array<{
        footnoteId: number;
        pmPos: number;
    }>;
    initialLayout: Layout;
    // (undocumented)
    layoutOpts: LayoutOptions;
    // (undocumented)
    measures: Measure[];
}

// @public (undocumented)
export interface StabilizeFootnoteLayoutResult {
    converged: boolean;
    // (undocumented)
    layout: Layout;
    // (undocumented)
    pageFootnoteMap: Map<number, number[]>;
}

// @public
export interface Style {
    basedOn?: string;
    default?: boolean;
    hidden?: boolean;
    link?: string;
    name?: string;
    next?: string;
    personal?: boolean;
    pPr?: ParagraphFormatting;
    qFormat?: boolean;
    rPr?: TextFormatting;
    semiHidden?: boolean;
    styleId: string;
    tblPr?: TableFormatting;
    tblStylePr?: Array<{
        type: 'band1Horz' | 'band1Vert' | 'band2Horz' | 'band2Vert' | 'firstCol' | 'firstRow' | 'lastCol' | 'lastRow' | 'neCell' | 'nwCell' | 'seCell' | 'swCell';
        pPr?: ParagraphFormatting;
        rPr?: TextFormatting;
        tblPr?: TableFormatting;
        trPr?: TableRowFormatting;
        tcPr?: TableCellFormatting;
    }>;
    tcPr?: TableCellFormatting;
    trPr?: TableRowFormatting;
    type: StyleType;
    uiPriority?: number;
    unhideWhenUsed?: boolean;
}

// @public
export interface StyleDefinitions {
    docDefaults?: DocDefaults;
    latentStyles?: {
        defLockedState?: boolean;
        defUIPriority?: number;
        defSemiHidden?: boolean;
        defUnhideWhenUsed?: boolean;
        defQFormat?: boolean;
        count?: number;
    };
    styles: Style[];
}

// @public
export abstract class Subscribable<TSnapshot> {
    constructor(initialSnapshot: TSnapshot);
    getSnapshot: () => TSnapshot;
    protected setSnapshot(snapshot: TSnapshot): void;
    subscribe: (listener: () => void) => (() => void);
}

// @public
export interface SuggestedAction {
    description?: string;
    icon?: string;
    id: string;
    label: string;
    priority?: number;
}

// @public
export interface Table {
    columnWidths?: number[];
    formatting?: TableFormatting;
    propertyChanges?: TablePropertyChange[];
    rows: TableRow[];
    // (undocumented)
    type: 'table';
}

// @internal
export const TABLE_DATA_ATTRIBUTES: {
    readonly TABLE_INDEX: "data-table-index";
    readonly ROW_INDEX: "data-row";
    readonly COLUMN_INDEX: "data-col";
    readonly TABLE_CELL: "data-table-cell";
};

// @public
export interface TableCell {
    content: (Paragraph | Table)[];
    formatting?: TableCellFormatting;
    propertyChanges?: TableCellPropertyChange[];
    structuralChange?: TableStructuralChangeInfo;
    // (undocumented)
    type: 'tableCell';
}

// @public
export interface TableRow {
    cells: TableCell[];
    formatting?: TableRowFormatting;
    propertyChanges?: TableRowPropertyChange[];
    structuralChange?: TableStructuralChangeInfo;
    // (undocumented)
    type: 'tableRow';
}

// @internal (undocumented)
export class TableSelectionManager extends Subscribable<TableSelectionSnapshot> {
    constructor();
    clearSelection(): void;
    getSelectedCell(): CellCoordinates | null;
    isCellSelected(tableIndex: number, rowIndex: number, columnIndex: number): boolean;
    selectCell(coords: CellCoordinates): void;
}

// @public
export interface TableSelectionSnapshot {
    selectedCell: CellCoordinates | null;
}

// @public
export interface TextBox {
    content: Paragraph[];
    fill?: ShapeFill;
    id?: string;
    margins?: {
        top?: number;
        bottom?: number;
        left?: number;
        right?: number;
    };
    outline?: ShapeOutline;
    position?: ImagePosition;
    size: ImageSize;
    // (undocumented)
    type: 'textBox';
    wrap?: ImageWrap;
}

// @public
export interface TextContent {
    preserveSpace?: boolean;
    text: string;
    // (undocumented)
    type: 'text';
}

// @public
export interface TextFormatting {
    allCaps?: boolean;
    bold?: boolean;
    boldCs?: boolean;
    color?: ColorValue;
    cs?: boolean;
    doubleStrike?: boolean;
    effect?: TextEffect;
    emboss?: boolean;
    emphasisMark?: EmphasisMark;
    fontFamily?: {
        ascii?: string;
        hAnsi?: string;
        eastAsia?: string;
        cs?: string;
        asciiTheme?: 'majorAscii' | 'majorHAnsi' | 'majorEastAsia' | 'majorBidi' | 'minorAscii' | 'minorHAnsi' | 'minorEastAsia' | 'minorBidi';
        hAnsiTheme?: string;
        eastAsiaTheme?: string;
        csTheme?: string;
    };
    fontSize?: number;
    fontSizeCs?: number;
    hidden?: boolean;
    highlight?: 'black' | 'blue' | 'cyan' | 'darkBlue' | 'darkCyan' | 'darkGray' | 'darkGreen' | 'darkMagenta' | 'darkRed' | 'darkYellow' | 'green' | 'lightGray' | 'magenta' | 'none' | 'red' | 'white' | 'yellow';
    imprint?: boolean;
    italic?: boolean;
    italicCs?: boolean;
    kerning?: number;
    outline?: boolean;
    position?: number;
    rtl?: boolean;
    scale?: number;
    shading?: ShadingProperties;
    shadow?: boolean;
    smallCaps?: boolean;
    spacing?: number;
    strike?: boolean;
    styleId?: string;
    underline?: {
        style: UnderlineStyle;
        color?: ColorValue;
    };
    vertAlign?: 'baseline' | 'superscript' | 'subscript';
}

// @public
export interface Theme {
    colorScheme?: ThemeColorScheme;
    fontScheme?: ThemeFontScheme;
    formatScheme?: {
        name?: string;
    };
    name?: string;
}

// @public
export interface ThemeColorScheme {
    accent1?: string;
    // (undocumented)
    accent2?: string;
    // (undocumented)
    accent3?: string;
    // (undocumented)
    accent4?: string;
    // (undocumented)
    accent5?: string;
    // (undocumented)
    accent6?: string;
    dk1?: string;
    dk2?: string;
    folHlink?: string;
    hlink?: string;
    lt1?: string;
    lt2?: string;
}

// @public
export interface ThemeFont {
    cs?: string;
    ea?: string;
    fonts?: Record<string, string>;
    latin?: string;
}

// @public
export interface ThemeFontScheme {
    majorFont?: ThemeFont;
    minorFont?: ThemeFont;
}

// @public
export interface ThemeMatrixCell {
    hex: string;
    label: string;
    shade?: string;
    themeSlot: ThemeColorSlot;
    tint?: string;
}

// @public
export function toArrayBuffer(input: DocxInput): Promise<ArrayBuffer>;

// @public
export interface TrackedChangeInfo {
    author: string;
    date?: string;
    id: number;
}

// @public
export type TrackedRunChange = Insertion | Deletion | MoveFrom | MoveTo;

// @public
export function twipsToEmu(twips: number): number;

// @public
export function twipsToPixels(twips: number): number;

// @public
export function updateMultipleFiles(originalBuffer: ArrayBuffer, updates: Map<string, string | ArrayBuffer>, options?: RepackOptions): Promise<ArrayBuffer>;

// @internal
export function updateTableInDocument(doc: Document_2, tableIndex: number, newTable: Table): Document_2;

// @public
export function validatePatchSafety(originalXml: string, serializedXml: string, changedIds: Set<string>): PatchValidationResult;

// @public
export function validateTemplate(buffer: ArrayBuffer): {
    valid: boolean;
    errors: TemplateError[];
    tags: string[];
};

// @public
export interface VariableDetectionResult {
    byLocation: {
        body: string[];
        headers: string[];
        footers: string[];
        footnotes: string[];
        endnotes: string[];
        textBoxes: string[];
    };
    occurrences: VariableOccurrence[];
    totalOccurrences: number;
    variables: string[];
}

// @public
export interface VariableOccurrence {
    location: 'body' | 'header' | 'footer' | 'footnote' | 'endnote' | 'textBox';
    name: string;
    paragraphIndex?: number;
    sectionIndex?: number;
}

// @public
export const VERSION = "0.0.2";

```
