@officesdk/web/esm/server/index.d.ts

Web JS SDK for the Office SDK

import type { DocxMenuFeatureButtonName } from '@officesdk/editor-sdk-core/combine';
import type { DocxMenuOptions } from '@officesdk/editor-sdk-core/combine';
import type { DocxParagraphs } from '@officesdk/editor-sdk-core/combine';
import type { DocxRangeValue } from '@officesdk/editor-sdk-core/combine';
import type { DocxToolbarOptions } from '@officesdk/editor-sdk-core/combine';
import type { DocxWindow } from '@officesdk/editor-sdk-core/combine';
import type { EditorOutline } from '@officesdk/editor-sdk-core/combine';
import type { EditorOutlineItem } from '@officesdk/editor-sdk-core/combine';
import type { PresentationMenuOptions } from '@officesdk/editor-sdk-core/combine';
import type { PresentationToolbarOptions } from '@officesdk/editor-sdk-core/combine';
import type { Server } from '@officesdk/rpc';
import type { SheetMenuEntryConfig } from '@officesdk/editor-sdk-core/combine';
import type { SheetMenuOptions } from '@officesdk/editor-sdk-core/combine';
import type { SheetToolbarOptions } from '@officesdk/editor-sdk-core/combine';
import type { TableFieldContextMenuOptions } from '@officesdk/editor-sdk-core/combine';
import type { TableListBarOptions } from '@officesdk/editor-sdk-core/combine';
import type { TableToolbarOptions } from '@officesdk/editor-sdk-core/combine';
import type { TableViewContextMenuOptions } from '@officesdk/editor-sdk-core/combine';

export declare type DatabaseTableContextFactory = (editor: DatabaseTableEditor) => Promise<EditorContext>;

/**
 * Represents the editor interface for database tables
 */
export declare interface DatabaseTableEditor {
    /**
     * The currently active database table sheet
     */
    readonly activeDBTable: DatabaseTableSheet;
    /**
     * The current selection in the database table
     */
    readonly selection: DatabaseTableSelection;
    /**
     * Related content changes
     */
    readonly content: EditorContent;
}

export declare type DatabaseTableEditorFactory = (options: DatabaseTableSDKOptions | null) => Promise<DatabaseTableEditor>;

export declare type DatabaseTableMethods = {
    /**
     * Returns the active database table sheet
     */
    getActiveDBSheet: () => DatabaseTableSheet;
    /**
     * Returns the current database table selection
     */
    getDBTableSelection: () => DatabaseTableSelection;
    /**
     * Returns the editor content
     */
    getContent: () => EditorContent;
};

/**
 * Configuration options for the database table SDK
 */
export declare interface DatabaseTableSDKOptions {
    /**
     * Options for customizing the field context menu in database table
     * Controls the visibility, behavior and available actions in the context menu for table fields
     */
    fieldContextMenu?: TableFieldContextMenuOptions;
    /**
     * Options for customizing the view context menu in database table
     * Controls the visibility, behavior and available actions in the view context menu
     */
    viewContextMenu?: TableViewContextMenuOptions;
    /**
     * Options for customizing the toolbar in database table
     * Controls the visibility, behavior and available buttons in the main toolbar
     */
    toolbar?: TableToolbarOptions;
    /**
     * Options for customizing the list bar in database table
     * Controls the visibility, behavior and available actions in the list bar
     */
    listBar?: TableListBarOptions;
}

/**
 * Provides methods to get and manipulate the current selection in a database table
 */
export declare type DatabaseTableSelection = {
    /**
     * Returns the type of the current selection
     */
    getSelectionType: () => DatabaseTableSelectionType | null;
    /**
     * Returns the current selection value or null if nothing is selected
     */
    getSelection: () => DatabaseTableSelectionValue | null;
    /**
     * Selects a rectangular range of cells
     * @param range - The range to select, or null to clear selection
     */
    selectRange: (range: {
        /**
         * Starting zero-based row index in the current view
         */
        row: number;
        /**
         * Starting zero-based column index in the current view
         */
        column: number;
        /**
         * Number of rows in the selection
         */
        rowCount: number;
        /**
         * Number of columns in the selection
         */
        columnCount: number;
    } | null) => void;
    /**
     * Selects a single row
     * @param row - Zero-based row index in the current view
     */
    selectRow: (row: number) => void;
    /**
     * Selects a single column
     * @param column - Zero-based column index in the current view
     */
    selectColumn: (column: number) => void;
    /**
     * Selects a single cell
     * @param row - Zero-based row index in the current view
     * @param column - Zero-based column index in the current view
     */
    selectCell: (row: number, column: number) => void;
    /**
     * Selects multiple non-contiguous rows
     * @param rows - Array of zero-based row indices in the current view
     */
    selectMultipleRows: (rows: number[]) => void;
    /**
     * Selects multiple contiguous columns
     * @param column - Starting zero-based column index in the current view
     * @param columnCount - Number of columns to select
     */
    selectMultipleColumns: (column: number, columnCount: number) => void;
    /**
     /**
     * Selects all cells
     *
     */
    selectAll: () => void;
};

/**
 * Defines the types of selections that can be made in a database table
 */
export declare enum DatabaseTableSelectionType {
    /**
     * Single cell selection
     */
    Cell = "Cell",
    /**
     * Row selection
     */
    Row = "Row",
    /**
     * Column selection
     */
    Column = "Column",
    /**
     * Entire table selection
     */
    All = "All",
    /**
     * Multiple non-contiguous rows selection
     */
    MultipleRows = "MultipleRows",
    /**
     * Rectangular range selection (multiple cells)
     */
    Range = "Range",
    /**
     * Multiple contiguous columns selection
     */
    MultipleColumns = "MultipleColumns"
}

/**
 * Represents the value of a database table selection based on its type
 */
export declare type DatabaseTableSelectionValue = {
    /**
     * Single cell selection
     */
    type: DatabaseTableSelectionType.Cell;
    /**
     * Zero-based row index in the current view
     */
    row: number;
    /**
     * Zero-based column index in the current view
     */
    column: number;
} | {
    /**
     * Single row selection
     */
    type: DatabaseTableSelectionType.Row;
    /**
     * Zero-based row index in the current view
     */
    row: number;
} | {
    /**
     * Single column selection
     */
    type: DatabaseTableSelectionType.Column;
    /**
     * Zero-based column index in the current view
     */
    column: number;
} | {
    /**
     * Entire database table selection
     */
    type: DatabaseTableSelectionType.All;
} | {
    /**
     * Multiple non-contiguous rows selection
     */
    type: DatabaseTableSelectionType.MultipleRows;
    /**
     * Array of zero-based row indices in the current view
     */
    rows: number[];
} | {
    /**
     * Multiple contiguous columns selection
     */
    type: DatabaseTableSelectionType.MultipleColumns;
    /**
     * Starting zero-based column index in the current view
     */
    column: number;
    /**
     * Number of columns selected
     */
    columnCount: number;
} | {
    /**
     * Rectangular range selection
     */
    type: DatabaseTableSelectionType.Range;
    /**
     * Starting zero-based row index in the current view
     */
    row: number;
    /**
     * Starting zero-based column index in the current view
     */
    column: number;
    /**
     * Number of rows in the selection
     */
    rowCount: number;
    /**
     * Number of columns in the selection
     */
    columnCount: number;
};

/**
 * Represents a sheet in a database table
 */
export declare interface DatabaseTableSheet {
    /**
     * The current selection in this sheet
     */
    readonly selection: DatabaseTableSelection | null;
}

export declare type DocumentContextFactory = (editor: DocumentEditor) => Promise<EditorContext>;

/**
 * 文档编辑器实例接口
 */
export declare interface DocumentEditor {
    readonly ready: () => Promise<void>;
    readonly export: (type: DocumentExportType) => Promise<void>;
    readonly selection: DocumentSelection;
    readonly zoom: DocumentZoom;
    readonly TOCs: DocumentTOCs;
    readonly outline: DocumentOutline;
    readonly window: DocumentWindow;
    readonly paragraphs: DocumentParagraphs;
}

export declare type DocumentEditorFactory = (options: DocumentSDKOptions | null) => Promise<DocumentEditor>;

export declare enum DocumentExportType {
    Docx = "docx",
    Pdf = "pdf",
    Image = "image"
}

export declare type DocumentMenuFeatureButtonName = DocxMenuFeatureButtonName;

export declare type DocumentMenuOptions = DocxMenuOptions;

/**
 * 传统文档目录大纲项接口
 */
export declare type DocumentOutline = Omit<EditorOutline<{
    text: string;
}>, 'setVisible'>;

/**
 * 传统文档目录大纲项信息，用于描述传统文档中的目录项信息。
 */
export declare type DocumentOutlineItem = EditorOutlineItem<{
    text: string;
}>;

export declare type DocumentParagraphs = DocxParagraphs;

/**
 * 文档区域接口
 */
export declare interface DocumentRange {
    /**
     * 区域的开始位置，
     * 当文档发生变化后，区域的标识可能会失效。
     */
    readonly start: string;
    /**
     * 区域的结束位置，
     * 当文档发生变化后，区域的标识可能会失效。
     */
    readonly end: string;
    /**
     * 是否为光标。
     */
    readonly isCaret: boolean;
    /**
     * 获取该区域对应的纯文本信息。
     * @returns 返回纯文本字符串
     */
    getText: () => string;
    /**
     * 将区域内的文本设置为指定的文本，
     * 如果文本为空，则清空区域内的文本。
     * 如果区域为
     * @param text
     */
    setText: (text: string) => void;
    /**
     * 将区域中的内容以 HTML 格式返回。
     * @returns 返回 HTML 字符串
     */
    getHtml: () => string;
    /**
     * 将区域内的文本设置为指定的 HTML 内容，
     * 如果内容为空，则清空区域内的内容。
     * 如果区域为光标，则会将光标位置的文本替换为指定的 HTML 格式。
     * @param html 指定的 HTML 内容
     */
    setHtml: (html: string) => void;
    /**
     * 获取选区在当前屏幕上的位置信息
     * @returns
     */
    getBounding: () => DocumentRangeBounding | null;
}

/**
 * 记录区域在屏幕上的位置信息，
 * 包含了区域的四个边界值，以及开始和结束位置。
 * 因为选区是由多个矩形区域组成的，
 * 所以这里的位置信息是一个矩形区域的边界值。
 */
export declare interface DocumentRangeBounding {
    /**
     * 区域的左边界值，
     * 代表区域的最左边的 X 坐标，
     * 也就是区域的最左边的矩形区域的左边界值。
     */
    top: number;
    /**
     * 区域的上边界值，
     * 代表区域的最上边的 Y 坐标，
     * 也就是区域的最上边的矩形区域的上边界值。
     */
    right: number;
    /**
     * 区域的右边界值，
     * 代表区域的最右边的 X 坐标，
     * 也就是区域的最右边的矩形区域的右边界值。
     */
    bottom: number;
    /**
     * 区域的下边界值，
     * 代表区域的最下边的 Y 坐标，
     * 也就是区域的最下边的矩形区域的下边界值。
     */
    left: number;
    /**
     * 第一行的开始 X 坐标，
     */
    start: number;
    /**
     * 最后一行的结束 X 坐标，
     */
    end: number;
}

export declare type DocumentRangeValue = DocxRangeValue;

export declare interface DocumentSDKOptions {
    /**
     * menu settings
     */
    menu?: {
        hidden?: boolean;
        disabled?: boolean;
        custom?: DocxMenuOptions['custom'];
        features?: DocxMenuOptions['features'];
    };
    /**
     * toolbar settings
     */
    toolbar?: {
        disabled?: boolean;
        hidden?: boolean;
        features?: DocxToolbarOptions['features'];
    };
}

export declare type DocumentSelection = {
    /**
     * 获取选区的区域范围，
     * 如果选区不存在，则返回 null。
     * @returns
     */
    getRange: (range?: DocumentRangeValue) => DocumentRange | null;
    /**
     * 设置选区的区域范围，
     * 设置后，选区会自动选中指定范围。
     * 如果设置为 null，则清空选区。
     * @param value 选区的区域范围
     */
    setRange: (range: DocumentRangeValue | null) => void;
    /**
     * 添加选区变化监听器，当选区发生变化时，会触发回调。
     * @param listener
     * @returns
     */
    addRangeListener: (listener: (range: DocumentRangeValue | null) => void) => void;
    /**
     * 获取文档全部选区范围。
     * @returns
     */
    getWholeRange: () => DocumentRange;
};

/**
 * 通用目录项条目
 * @field id 目录项 ID
 * @field level 目录项层级
 * @field content 目录项内容
 */
export declare interface DocumentTocContentItem {
    /**
     * 目录项 ID
     */
    id: string;
    /**
     * 目录项层级
     */
    level: number;
    /**
     * 目录项内容
     */
    content: {
        /**
         * 目录项内容
         */
        text: string;
    };
}

/**
 * 传统文档目录操作接口，
 * 可以调用接口更新目录和页码，
 * 也可以设置目录级别、页码等样式。
 */
export declare interface DocumentTocItem {
    /**
     * 获取目录信息
     * @returns 目录信息
     */
    getContent: () => Promise<DocumentTocContentItem[]>;
    /**
     * 添加目录信息改变时的监听器
     * @param listener 监听器
     * @returns 取消监听器的函数
     */
    addContentChangedListener: (listener: (content: DocumentTocContentItem[]) => void) => () => void;
    /**
     * 跳转到指定条目对应的正文位置
     * @param id 条目id
     * @returns 跳转是否成功
     */
    goto: (id: string) => Promise<boolean>;
    /**
     * 更新整个目录
     * @returns 是否更新成功
     */
    update: () => Promise<boolean>;
    /**
     * 仅更新页码
     * @returns 是否更新成功
     */
    updatePageNumbers: () => Promise<boolean>;
    /**
     * 设置目录层级
     * @param level 目录层级
     * @returns 是否设置成功
     */
    setLevel: (level: number) => Promise<boolean>;
}

/**
 * 传统文档目录接口，
 * 表示文档中的所有目录，
 * 需要注意的是，DocumentTOCs 和 DocumentTocItem 是两个不同的对象，前者代表代表目录集合（一个文档可以插入多个目录），后者单个目录。
 */
export declare interface DocumentTOCs {
    /**
     * 获取所有目录列表
     * @returns 目录列表
     */
    getAll: () => Promise<DocumentTocItem[]>;
    /**
     * 获取某个目录
     * @param index 目录索引
     * @returns 目录
     */
    getOne: (index: number) => Promise<DocumentTocItem | null>;
    /**
     * 删除所有目录
     * @returns 删除结果
     */
    deleteAll: () => Promise<boolean>;
    /**
     * 删除某个目录
     * @param index
     * @returns 删除结果
     */
    deleteOne: (index: number) => Promise<boolean>;
    /**
     * 添加目录
     * @param options 目录选项
     * @returns 添加结果
     */
    add: (options: {
        /**
         * 添加目录的位置，
         * 默认为当前选区位置。
         * 如果添加失败，如：当前选区信息不正确，会返回 false。
         * 如果添加成功，会返回 true。
         */
        range?: string;
    }) => Promise<boolean>;
}

export declare type DocumentWindow = DocxWindow;

/**
 * 文档缩放接口
 */
export declare type DocumentZoom = {
    /**
     * 获取当前缩放比例。
     * @returns
     */
    getPercentage: () => number;
    /**
     * 设置缩放比例，
     * 有效范围 10 ~ 500。
     * @param percentage
     */
    setPercentage: (percentage: number) => void;
    /**
     * 设置自动缩放模式，
     * none: 不自动缩放，默认值。
     * window: 根据窗口宽度自动缩放，页面宽度随着窗口宽度变化而变化
     * page: 根据页面尺寸自动缩放，将页面缩放到可以完整显示的大小
     * @param mode 缩放模式，可以是 'window' 或 'page'
     */
    setFitMode: (mode: 'none' | 'window' | 'page') => void;
    /**
     * 获取当前缩放模式。
     * @returns
     */
    getFitMode: () => 'none' | 'window' | 'page';
    /**
     * 放大。
     */
    zoomIn: () => void;
    /**
     * 缩小。
     */
    zoomOut: () => void;
};

/**
 * 编辑器内容接口
 */
export declare type EditorContent = {
    /**
     * 主动保存内容
     */
    save: () => void;
    /**
     * 文件内容发生变化时触发回调
     * @param listener
     * @returns
     */
    addContentListener: (listener: (record: EditorContentRecord) => void) => () => void;
};

export declare type EditorContentMethods = {
    getContent: () => EditorContent;
};

/**
 * 每次内容发生变化时，会生成一个当前页面唯一的记录。
 */
export declare interface EditorContentRecord {
    /**
     * 生成内容的时间戳
     */
    timestamp: number;
    /**
     * 内容标识
     */
    id: string;
}

/**
 * 编辑器上下文，包括除编辑器实例外的其他信息
 */
export declare interface EditorContext {
    /**
     * 编辑器内容接口
     */
    content?: EditorContent;
}

export declare type EditorContextFactoryMap = {
    [FileType.Document]: DocumentContextFactory;
    [FileType.Spreadsheet]: SpreadsheetContextFactory;
    [FileType.Presentation]: PresentationContextFactory;
    [FileType.LiteDoc]: LiteDocContextFactory;
    [FileType.DBTable]: DatabaseTableContextFactory;
    [FileType.Pdf]: PdfContextFactory;
};

export declare type EditorFactoryMap = {
    [FileType.Document]: DocumentEditorFactory;
    [FileType.Spreadsheet]: SpreadsheetEditorFactory;
    [FileType.Presentation]: PresentationEditorFactory;
    [FileType.LiteDoc]: LiteDocEditorFactory;
    [FileType.DBTable]: DatabaseTableEditorFactory;
    [FileType.Pdf]: PdfEditorFactory;
};

/**
 * 菜单栏自定义按钮配置
 */
export declare type EditorMenuCustomButton = {
    /**
     * 按钮名称
     */
    name: string;
    /**
     * 链接
     */
    type: 'link';
    /**
     * 按钮文本
     */
    text: string;
    /**
     * 链接地址
     */
    url: string;
} | {
    /**
     * 按钮名称
     */
    name: string;
    /**
     * 按钮，点击后触发 callback 回调
     */
    type: 'button';
    /**
     * 按钮文本
     */
    label: string;
    /**
     * 按钮图标，可以是 base64 的图片信息，也可以是图片 url
     */
    icon?: string;
    /**
     * 按钮点击事件
     */
    callback: () => void;
};

/**
 * 菜单栏二级以下的菜单入口
 */
export declare type EditorMenuEntryButton = {
    type: 'entry';
    /**
     * 菜单名称
     */
    name: string;
    /**
     * 菜单图标
     */
    icon?: string;
};

/**
 * 菜单栏功能按钮配置
 */
export declare type EditorMenuFeatureButton<TName extends string> = {
    /**
     * 隐藏按钮，用作在需要隐藏菜单栏时定义
     */
    type: 'hidden';
    /**
     * 按钮名称
     */
    name: TName;
} | {
    type: 'button';
    /**
     * 按钮名称
     */
    name: TName;
    /**
     * 按钮标签（显示文本）
     */
    label: string;
    /**
     * 按钮图标，可以是 base64 的图片信息，也可以是图片 url
     */
    icon?: string;
};

/**
 * 菜单栏按钮配置
 */
export declare type EditorMenuFeatureButtonConfig<TName extends string> = Record<TName, EditorMenuFeatureButton<TName>>;

/**
 * Supported file types for the Office SDK.
 */
export declare enum FileType {
    Document = 0,// Document file, like .doc, .docx
    Spreadsheet = 1,// Spreadsheet file, like .xls, .xlsx
    Presentation = 2,// Presentation file, like .ppt, .pptx
    LiteDoc = 3,// Lite document.
    DBTable = 4,// Database table.
    Pdf = 5
}

export declare type LiteDocContextFactory = (editor: LiteDocEditor) => Promise<EditorContext>;

export declare interface LiteDocEditor {
}

export declare type LiteDocEditorFactory = (options: LiteDocSDKOptions | null) => Promise<LiteDocEditor>;

export declare interface LiteDocSDKOptions {
}

export declare type PdfContextFactory = (editor: PdfEditor) => Promise<EditorContext>;

/**
 * PDF 编辑器实例接口
 */
export declare interface PdfEditor {
    readonly pages: PdfPages;
    readonly selection: PdfSelection;
    readonly outline: PdfOutline;
}

export declare type PdfEditorFactory = (options: PdfSDKOptions | null) => Promise<PdfEditor>;

/**
 * PDF 编辑器目录项接口，用于访问 pdf 文件中目录信息。
 */
export declare type PdfOutline = Omit<EditorOutline<{
    text: string;
}>, 'setVisible'>;

/**
 * PDF 编辑器目录项信息，用于描述 PDF 编辑器中的目录项信息。
 */
export declare type PdfOutlineItem = EditorOutlineItem<{
    text: string;
}>;

/**
 * PDF 页面实例
 */
export declare interface PdfPage {
    /**
     * 获取当前页码
     */
    readonly pageNumber: number;
    /**
     * 获取当前页面的大小
     * @returns
     */
    getPageSize: () => {
        width: number;
        height: number;
    };
}

/**
 * PDF 页面集合操作接口
 */
export declare interface PdfPages {
    /**
     * 获取当前页码
     * @returns
     */
    getCurrentPageNumber: () => number;
    /**
     * 设置当前页码并跳转至对应页面
     * @param page
     */
    setCurrentPage: (page: number) => void;
    /**
     * 获取总页数
     * @returns
     */
    getPagesCount: () => number;
    /**
     * 获取指定页面
     */
    getPage: (page: number) => Promise<PdfPage | null>;
}

/**
 * PDF 区域对象
 */
export declare interface PdfRange {
    /**
     * 区域的开始位置
     */
    readonly start: string;
    /**
     * 区域的结束位置
     */
    readonly end: string;
    /**
     * 获取该区域对应的纯文本信息。
     * @returns
     */
    getText: () => string;
    /**
     * 将区域中的内容以 HTML 格式返回。
     * @returns
     */
    getHtml: () => string;
    /**
     * 获取选区在当前屏幕上的位置信息
     * @returns
     */
    getBounding: () => PdfRangeBounding | null;
}

/**
 * 记录选区在屏幕上的矩形位置信息，
 * 包含整个选区包围盒的四个边界值（top, right, bottom, left），
 * 以及第一行开始和最后一行结束的横向坐标。
 * 这些信息是选区中所有 ClientRects 的集合范围。
 */
export declare interface PdfRangeBounding {
    /**
     * 区域的上边界值，
     * 表示所有选区中最上方的 Y 坐标。
     */
    top: number;
    /**
     * 区域的右边界值，
     * 表示所有选区中最右侧的 X 坐标。
     */
    right: number;
    /**
     * 区域的下边界值，
     * 表示所有选区中最下方的 Y 坐标。
     */
    bottom: number;
    /**
     * 区域的左边界值，
     * 表示所有选区中最左侧的 X 坐标。
     */
    left: number;
    /**
     * 第一行选区的起始 X 坐标。
     */
    start: number;
    /**
     * 最后一行选区的结束 X 坐标。
     */
    end: number;
}

/**
 * 可用于描述一个 PDF 区域的信息。
 */
export declare interface PdfRangeValue {
    start: string;
    end: string;
}

export declare interface PdfSDKOptions {
}

/**
 * PDF 选区接口
 */
export declare interface PdfSelection {
    /**
     * 获取选区的区域范围，
     * 如果没有指定范围，则返回当前选区的范围。
     * 如果指定了范围，则返回指定范围的选区。
     * 如果选区不存在，则返回 null。
     * @returns
     */
    getRange: (value?: PdfRangeValue) => PdfRange | null;
    /**
     * 设置选区的区域范围，
     * 设置后，选区会自动选中指定范围。
     * 如果设置为 null，则清空选区。
     * @param value
     */
    setRange: (value: PdfRangeValue | null) => void;
    /**
     * 添加选区变化监听器，当选区发生变化时，会触发回调。
     * @param listener
     * @returns
     */
    addRangeListener: (listener: (value: PdfRangeValue | null) => void) => void;
    /**
     * 获取 pdf 全部选区范围。
     * @returns
     */
    getWholeRange: () => PdfRange;
}

export declare type PresentationContextFactory = (editor: PresentationEditor) => Promise<EditorContext>;

/**
 * 幻灯片编辑器实例接口
 */
export declare interface PresentationEditor {
    readonly ready: () => Promise<void>;
    readonly export: (type: PresentationExportType) => Promise<void>;
    readonly selection: PresentationSelection;
    readonly zoom: PresentationZoom;
    readonly slides: PresentationSlides;
}

export declare type PresentationEditorFactory = (options: PresentationSDKOptions | null) => Promise<PresentationEditor>;

export declare enum PresentationExportType {
    Pptx = "pptx",
    ImagePdf = "imagePdf",
    Image = "image"
}

export declare interface PresentationSDKOptions {
    /**
     * 自定义菜单
     */
    menu?: {
        disabled?: boolean;
        hidden?: boolean;
        custom?: PresentationMenuOptions['custom'];
        features?: PresentationMenuOptions['features'];
    };
    /**
     * 工具栏设置
     */
    toolbar?: {
        disabled?: boolean;
        hidden?: boolean;
        features?: PresentationToolbarOptions['features'];
    };
}

/**
 * 幻灯片选区接口
 */
export declare type PresentationSelection = {
    /**
     * 获取选区的文本区域范围，
     * 如果选区不存在，则返回 null。
     * @returns
     */
    getTextRange: () => PresentationTextRange | null;
    /**
     * 设置选区的文本区域范围，
     * 设置后，选区会自动选中指定范围。
     * 如果设置为 null，则清空选区。
     * @param value 选区的区域范围
     */
    setTextRange: (range: PresentationTextRangeValue | null) => void;
    /**
     * 获取当前选中的形状，
     * 如果没有选中形状，则返回 null。
     */
    getSelectedShapes: () => PresentationShape[] | null;
    /**
     * 选中指定的形状，选中形状后会清空文字选区。
     * 如果 value 为 null，则清空选中的形状。
     * @param ids 指定的形状 id
     */
    setSelectedShapes: (ids: string[] | null) => void;
    /**
     * 添加选区变化监听器，当选区发生变化时，会触发回调。
     * @param listener
     * @returns
     */
    addRangeListener: (listener: (range: PresentationTextRangeValue | null) => void) => void;
};

/**
 * 幻灯片形状接口
 */
export declare interface PresentationShape {
    /**
     * 获取形状的 id
     */
    readonly id: string;
}

/**
 * 幻灯片页面接口
 */
export declare interface PresentationSlide {
    /**
     * 当前幻灯片的 id
     */
    readonly id: string;
    /**
     * 获取当前幻灯片在所有幻灯片中的索引
     * @returns
     */
    getIndex: () => number;
    /**
     * 获取当前页面所有的形状
     * @returns
     */
    getShapes: () => PresentationShape[];
}

/**
 * 幻灯片集合接口
 */
export declare interface PresentationSlides {
    /**
     * 获取当前幻灯片
     */
    getCurrentSlide: () => PresentationSlide;
    /**
     * 切换当前幻灯片
     * @param slideId
     */
    setCurrentSlideIndex: (slideId: string) => void;
    /**
     * 获取幻灯片索引
     * @param slideId
     * @returns
     */
    getSlideIndex: (slideId: string) => number;
    /**
     * 获取幻灯片总数
     */
    getSlidesCount: () => number;
    /**
     * 获取所有幻灯片
     * @returns
     */
    getSlides: () => PresentationSlide[];
    /**
     * 获取指定幻灯片
     * @param slideId
     */
    getSlideById: (slideId: string) => PresentationSlide;
    /**
     * 获取当前选中的幻灯片。
     * 至少存在一个选中的幻灯片。
     * @returns
     */
    getSelectedSlides: () => PresentationSlide[];
    /**
     * 设置选中的幻灯片
     * @param ids
     * @returns
     */
    setSelectedSlides: (ids: string[]) => void;
}

/**
 * 幻灯片文本区域接口
 */
export declare interface PresentationTextRange {
    /**
     * 区域的开始位置，
     * 当内容发生变化后，区域的标识可能会失效。
     */
    readonly start: string;
    /**
     * 区域的结束位置，
     * 当内容发生变化后，区域的标识可能会失效。
     */
    readonly end: string;
    /**
     * 获取该区域对应的纯文本信息。
     * @returns 返回纯文本字符串
     */
    getText: () => string;
    /**
     * 设置该区域的内容
     * @param text 内容
     */
    setText: (text: string) => void;
    /**
     * 将区域中的内容以 HTML 格式返回。
     * @returns 返回 HTML 字符串
     */
    getHtml: () => string;
    /**
     * 设置该区域的内容为 HTML 格式
     * @param html 内容
     */
    setHtml: (html: string) => void;
}

/**
 * 可用于描述一个幻灯片文本区域的信息。
 */
export declare interface PresentationTextRangeValue {
    start: string;
    end: string;
}

/**
 * 幻灯片缩放接口
 */
export declare type PresentationZoom = {
    /**
     * 获取当前缩放比例。
     * @returns
     */
    getPercentage: () => number;
    /**
     * 设置缩放比例，
     * 有效范围 10 ~ 500。
     * @param percentage
     */
    setPercentage: (percentage: number) => void;
    /**
     * 设置自动缩放模式，
     * none: 不自动缩放，默认值。
     * window: 根据窗口宽度自动缩放，页面宽度随着窗口宽度变化而变化
     * @param mode 缩放模式
     */
    setFitMode: (mode: 'none' | 'window') => void;
    /**
     * 获取当前缩放模式。
     * @returns
     */
    getFitMode: () => 'none' | 'window';
    /**
     * 放大。
     */
    zoomIn: () => void;
    /**
     * 缩小。
     */
    zoomOut: () => void;
};

export declare interface ServeOptions<T extends FileType> {
    /**
     * 文件类型
     */
    fileType: T;
    /**
     * 编辑器实例
     */
    createEditor: EditorFactoryMap[T];
    /**
     * 编辑器上下文
     */
    createContext?: EditorContextFactoryMap[T];
}

export declare function serveSDK<T extends FileType>(options: ServeOptions<T>): Promise<Server>;

/**
 * 表格单元格对象
 */
export declare type SpreadsheetCell = {
    /**
     * 单元格所在的行号
     */
    readonly row: number;
    /**
     * 单元格所在的列号
     */
    readonly column: number;
    /**
     * 单元格所在的工作表 ID
     */
    readonly sheetId: string;
    /**
     * 获取单元格的文本
     */
    getCellText: () => string;
    /**
     * 获取单元格的值
     */
    getCellValue: () => SpreadsheetCellValue | null;
};

/**
 * 单元格值类型
 */
export declare type SpreadsheetCellValue = {
    type: 'primitive';
    value: string | number | boolean;
} | {
    type: 'date';
    value: number;
} | {
    type: 'calcError';
    value: {
        error: string;
    };
};

export declare type SpreadsheetContextFactory = (editor: SpreadsheetEditor) => Promise<EditorContext>;

/**
 * 电子表格编辑器实例接口
 */
export declare interface SpreadsheetEditor {
    readonly export: (type: SpreadsheetExportType) => Promise<void>;
    readonly ready: () => Promise<void>;
    readonly workbook: SpreadsheetWorkbook;
    readonly activeSheet: SpreadsheetWorksheet;
    readonly activeCell: SpreadsheetCell | null;
    readonly selections: SpreadsheetSelection[] | null;
}

export declare type SpreadsheetEditorFactory = (options: SpreadsheetSDKOptions | null) => Promise<SpreadsheetEditor>;

export declare type SpreadsheetExportType = 'image' | 'pdf' | 'xlsx';

export declare type SpreadsheetMenuEntryConfig = SheetMenuEntryConfig;

export declare type SpreadsheetMenuOptions = SheetMenuOptions;

/**
 * 表格区域对象
 */
export declare interface SpreadsheetRange {
    /**
     * 区域类型
     */
    readonly type: `${SpreadsheetRangeType}`;
    /**
     * 区域的行开始位置
     */
    readonly row: number;
    /**
     * 区域的列开始位置
     */
    readonly column: number;
    /**
     * 区域的行数
     */
    readonly rowCount: number;
    /**
     * 区域的列数
     */
    readonly columnCount: number;
    /**
     * 获取该区域对应的纯文本信息
     */
    getText: () => string;
    /**
     * 设置该区域的内容
     * @param text 内容
     */
    setText: (text: string) => void;
    /**
     * 将区域中的内容以 HTML 格式返回
     */
    getHtml: () => string;
    /**
     * 设置该区域的内容为 HTML 格式
     * @param html 内容
     */
    setHtml: (html: string) => void;
}

/**
 * 选区类型
 */
export declare enum SpreadsheetRangeType {
    /**
     * 选中一个或多个单元格
     */
    Cells = "cells",
    /**
     * 选中一行或多行
     */
    Rows = "rows",
    /**
     * 选中一列或多列
     */
    Columns = "columns",
    /**
     * 选中整个工作表
     */
    Sheet = "sheet"
}

/**
 * 可用于描述一个表格选区的信息
 */
export declare type SpreadsheetRangeValue = {
    /**
     * 单个或多个单元格
     */
    type: `${SpreadsheetRangeType.Cells}`;
    /**
     * 起始单元格的行号
     */
    row: number;
    /**
     * 总计行数
     */
    rowCount: number;
    /**
     * 起始单元格的列号
     */
    column: number;
    /**
     * 总计列数
     */
    columnCount: number;
} | {
    /**
     * 一列或多列
     */
    type: `${SpreadsheetRangeType.Rows}`;
    /**
     * 起始行号
     */
    row: number;
    /**
     * 总计行数
     */
    rowCount: number;
} | {
    /**
     * 一行或多行
     */
    type: `${SpreadsheetRangeType.Columns}`;
    /**
     * 起始列号
     */
    column: number;
    /**
     * 总计列数
     */
    columnCount: number;
} | {
    /**
     * 整个工作表
     */
    type: `${SpreadsheetRangeType.Sheet}`;
};

export declare interface SpreadsheetSDKOptions {
    /**
     * 菜单栏相关设置
     */
    menu?: {
        disabled?: boolean;
        hidden?: boolean;
        custom?: SpreadsheetMenuOptions['custom'];
        features?: SpreadsheetMenuOptions['features'];
    };
    /**
     * Toolbar related settings
     */
    toolbar?: {
        disabled?: boolean;
        hidden?: boolean;
        features?: SheetToolbarOptions['features'];
    };
}

/**
 * 表格选区接口
 */
export declare type SpreadsheetSelection = {
    /**
     * 获取选区的区域范围
     * @param value 可选的选区值
     */
    getRange: (value?: SpreadsheetRangeValue) => SpreadsheetRange | null;
    /**
     * 设置选区的区域范围
     * @param value 选区的区域范围或null
     */
    setRange: (value: SpreadsheetRangeValue | null) => void;
};

/**
 * 工作簿接口
 */
export declare type SpreadsheetWorkbook = {
    /**
     * 获取所有工作表
     */
    getWorksheets: () => SpreadsheetWorksheet[];
    /**
     * 获取指定的工作表
     * @param sheetId 工作表ID
     */
    getWorksheetById: (sheetId: string) => SpreadsheetWorksheet | null;
    /**
     * 获取当前活动的工作表
     */
    getActiveWorksheet: () => SpreadsheetWorksheet;
    /**
     * 激活指定的工作表
     * @param sheetId 工作表ID
     */
    setActiveWorksheet: (sheetId: string) => void;
};

/**
 * 工作表对象
 */
export declare type SpreadsheetWorksheet = {
    /**
     * 工作表对应编号
     */
    readonly id: string;
    /**
     * 工作表名称
     */
    readonly name: string;
    /**
     * 是否为当前活动的工作表
     */
    readonly isActive: boolean;
    /**
     * 获取工作表的所有选区
     */
    getSelections: () => SpreadsheetSelection[] | null;
    /**
     * 获取选区的物理位置（相对于浏览器窗口）
     * @param range 选区范围
     */
    getPhysicalPosition: (range: SpreadsheetRangeValue) => {
        left: number;
        top: number;
        width: number;
        height: number;
    } | null;
    /**
     * 添加选区变化监听器
     * @param listener 监听函数
     */
    addRangeListener: (listener: (range: {
        sheet: string;
        ranges: SpreadsheetRangeValue[] | null;
    }) => void) => () => void;
    /**
     * 获取工作表中指定区域的单元格对象
     * @param row 行号
     * @param column 列号
     */
    getCell: (row: number, column: number) => SpreadsheetCell | null;
    /**
     * 获取工作表中选中的单元格对象
     */
    getActiveCell: () => SpreadsheetCell | null;
    /**
     * 激活工作表中某个单元格
     * @param cell 单元格位置信息
     */
    setActiveCell: (cell: {
        row: number;
        column: number;
    }) => void;
    /**
     * 定位到单元格所在位置
     * @param row 单元格所在行
     * @param column 单元格所在列
     */
    locateCell: (row: number, column: number) => void;
};

export { }