@officesdk/web/index.d.ts

Web JS SDK for the Office SDK

import { DocxWindow } from '@officesdk/editor-sdk-core/docx';
import type { PresentationToolbarOptions } from '@officesdk/editor-sdk-core/presentation';
import type { RPCReturnMapProxy } from '@officesdk/rpc';
import type { RPCReturnMethods } from '@officesdk/rpc';
import type { SheetToolbarOptions } from '@officesdk/editor-sdk-core/sheet';

/**
 * 初始化 Office SDK 的基础配置项，
 * 需要传入 endpoint、 token、 fileId 用于连接服务端并鉴权，
 * 以及指定 fileType 用于初始化 SDK 操作接口。
 */
export declare interface BaseCreateOptions {
    /**
     * 连接的 endpoint
     */
    endpoint: string;
    /**
     * 鉴权 token
     */
    token: string;
    /**
     * 文件 ID
     */
    fileId: string;
    /**
     * 自定义页面路径
     */
    path?: string;
    /**
     * 加载 SDK iframe 的根节点，这个是个可选配置，
     * 也可以在创建实例后再将 sdk.iframe 加载到页面任意位置。
     */
    root?: HTMLElement;
    /**
     * 用户自定义参数
     */
    userQuery?: Record<string, string>;
    /**
     * 已加载 SDK 环境的 iframe 实例
     */
    iframe?: HTMLIFrameElement;
    /**
     * 语言
     */
    lang?: 'zh-CN' | 'en-US';
    /**
     * 编辑器模式
     */
    mode?: EditorModeType;
    /**
     *  编辑器在 `standard` 模式下的权限模式
     */
    role?: EditorStandardRole;
}

export declare function createContentFacade(methods: RPCReturnMethods<EditorContentMethods>): RPCReturnMapProxy<EditorContent>;

/**
 * 初始化 Office SDK 的配置项
 */
export declare type CreateOptions = DocumentCreateOptions | PresentationCreateOptions | SpreadsheetCreateOptions | DBTableCreateOptions | PdfCreateOptions | LiteDocCreateOptions;

/**
 * 创建 Office SDK 实例
 */
export declare function createSDK<T extends FileType>(options: CreateOptions): OfficeSDK<T>;

/**
 * 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;
    /**
     * Saves all pending changes to the database table
     */
    saveChanges: () => Promise<void>;
}

export declare interface DatabaseTableFacade {
    /**
     * Current activeDBSheet
     */
    readonly activeDBSheet: Promise<RPCReturnMapProxy<DatabaseTableSheet>>;
    /**
     * Current selection
     */
    readonly selection: RPCReturnMapProxy<DatabaseTableSelection>;
    /**
     * Get content
     */
    readonly content: ReturnType<typeof createContentFacade>;
}

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 {
}

/**
 * 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;
};

/**
 * 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 interface DBTableCreateOptions extends BaseCreateOptions {
    fileType: FileType.DBTable;
    settings?: unknown;
}

export declare interface DocumentCreateOptions extends BaseCreateOptions {
    fileType: FileType.Document;
    settings?: DocumentSettings;
}

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

export declare interface DocumentFacade {
    /**
     * 选区实例
     */
    readonly selection: RPCReturnMapProxy<DocumentSelection>;
    /**
     * 主动保存内容
     */
    readonly content: RPCReturnMapProxy<EditorContent>;
    /**
     * 缩放实例
     */
    readonly zoom: RPCReturnMapProxy<DocumentZoom>;
    /**
     * 目录实例
     */
    readonly TOCs: RPCReturnMapProxy<DocumentTOCs>;
    /**
     * 目录实例
     */
    readonly outline: RPCReturnMapProxy<DocumentOutline>;
    /**
     * 窗口实例
     */
    readonly window: RPCReturnMapProxy<DocxWindow>;
}

/**
 * 传统文档工具栏一级菜单
 */
export declare type DocumentMenuEntryConfig = EditorMenuEntryConfig<DocumentMenuFeatureButtonName>;

/**
 * 传统文档工具栏功能按钮
 */
export declare type DocumentMenuFeatureButtonConfig = EditorMenuFeatureButtonConfig<DocumentMenuFeatureButtonName>;

/**
 * 传统文档工具栏内置功能按钮
 */
export declare type DocumentMenuFeatureButtonName = 'undo' | 'redo' | 'cut' | 'copy' | 'paste' | 'selectAll';

export declare type DocumentMenuOptions = EditorMenuOptions<DocumentMenuFeatureButtonName>;

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

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

/**
 * 文档区域接口
 */
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 interface DocumentRangeValue {
    start: string;
    end: string;
}

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;
};

export declare interface DocumentSettings {
    /**
     * 自定义菜单
     */
    menu?: {
        custom?: EditorMenuCustomButton[];
    };
}

/**
 * 通用目录项条目
 * @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 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 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 EditorMenuEntryConfig<TName extends string> = {
    /**
     * 一级菜单名称
     */
    name: string;
    /**
     * 二级菜单定义，定一个二维数组，用于定义二级菜单的结构，
     * 将第一层数组中的所有按钮放到一个区域内用分隔符隔开，
     * 第二层数组为按钮的定义，可以是功能按钮也可以是一个下拉入口。
     */
    children: Array<EditorMenuFeatureButton<TName> | EditorMenuEntryButton>[];
};

/**
 * 菜单栏功能按钮配置
 */
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>>;

/**
 * 菜单栏相关配置，目前菜单栏不是所有套件都支持，
 * 菜单栏是指的编辑器最上放可以展开二级菜单的那一栏。
 */
export declare type EditorMenuOptions<TName extends string> = {
    /**
     * 菜单栏是否显示
     */
    visible?: boolean;
    /**
     * 是否禁用菜单栏所有功能
     */
    disabled?: boolean;
    /**
     * 菜单栏一级菜单配置
     */
    entries?: EditorMenuEntryConfig<TName>[];
    /**
     * 菜单栏功能按钮配置
     */
    features?: Partial<EditorMenuFeatureButtonConfig<TName>>;
    /**
     * 自定义按钮配置
     */
    custom?: EditorMenuCustomButton[];
};

/**
 * 编辑器模式
 * - `standard` 标准模式，会根据用户权限配置不同的功能
 * - `preview` 预览模式，只能查看内容
 */
export declare enum EditorModeType {
    Standard = "standard",
    Preview = "preview"
}

/**
 * 通用目录接口
 * @method getContent 获取目录信息
 * @method addContentChangedListener 添加目录信息改变时的监听器
 */
export declare interface EditorOutline<Content = unknown> {
    /**
     * 获取目录信息
     * @returns 目录信息
     */
    getContent: () => Promise<EditorOutlineItem<Content>[]>;
    /**
     * 添加目录信息改变时的监听器
     * @param listener 监听器
     * @returns 取消监听器的函数
     */
    addChangedListener: (listener: (content: EditorOutlineItem<Content>[]) => void) => () => void;
    /**
     * 跳转到指定条目对应的正文位置
     * @param id 条目id
     * @returns 跳转是否成功
     */
    goto: (id: string) => Promise<boolean>;
}

/**
 * 通用目录项条目
 * @field id 目录项 ID
 * @field level 目录项层级
 * @field content 目录项内容
 */
export declare interface EditorOutlineItem<Content = unknown> {
    /**
     * 目录项 ID
     */
    id: string;
    /**
     * 目录项层级
     */
    level: number;
    /**
     * 目录项内容
     */
    content: Content;
}

/**
 * 编辑器在 `standard` 模式下的权限模式
 * - `editor` 编辑模式
 * - `viewer` 阅读模式
 * - `reviewer` 评论模式
 */
export declare enum EditorStandardRole {
    Editor = "editor",
    Viewer = "viewer",
    Reviewer = "reviewer"
}

/**
 * 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 interface LiteDocCreateOptions extends BaseCreateOptions {
    fileType: FileType.LiteDoc;
    settings?: unknown;
}

export declare interface LTDocFacade {
}

/**
 * Office SDK 实例对象，调用 connect 方法初始化后返回的可操作对象。
 * 实例内封装了一些常用的属性和函数供开发者使用。
 */
export declare interface OfficeSDK<T extends FileType> {
    /**
     * 连接 Office SDK，
     * 连接成功返回 Office SDK 实例，
     * 如果失败会抛出对应错误。
     * @returns 返回 Office SDK 实例
     */
    connect: () => Promise<OfficeSDKMap[T]>;
    /**
     * 当前 SDK iframe 加载的 URL
     */
    readonly url: string;
    /**
     * 当前 SDK iframe 的实例
     */
    readonly iframe: HTMLIFrameElement;
    /**
     * 销毁当前 SDK 实例
     */
    destroy(): void;
}

export declare type OfficeSDKMap = {
    [FileType.Document]: DocumentFacade;
    [FileType.Spreadsheet]: SpreadsheetFacade;
    [FileType.Presentation]: PresentationFacade;
    [FileType.LiteDoc]: LTDocFacade;
    [FileType.DBTable]: DatabaseTableFacade;
    [FileType.Pdf]: PdfFacade;
};

export declare interface PdfCreateOptions extends BaseCreateOptions {
    fileType: FileType.Pdf;
    settings?: unknown;
}

export declare interface PdfFacade {
    /**
     * 页面操作实例
     */
    readonly pages: RPCReturnMapProxy<PdfPages>;
    /**
     * 选区实例
     */
    readonly selection: RPCReturnMapProxy<PdfSelection>;
    /**
     * 目录实例
     */
    readonly outline: RPCReturnMapProxy<PdfOutline>;
}

/**
 * PDF 编辑器目录项接口，用于访问 pdf 文件中目录信息。
 */
export declare type PdfOutline = EditorOutline<{
    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;
}

/**
 * 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 interface PresentationCreateOptions extends BaseCreateOptions {
    fileType: FileType.Presentation;
    settings?: PresentationSettings;
}

export declare interface PresentationFacade {
    /**
     * 选区实例
     */
    readonly selection: RPCReturnMapProxy<PresentationSelection>;
    /**
     * 内容实例
     */
    readonly content: RPCReturnMapProxy<EditorContent>;
    /**
     * 缩放实例
     */
    readonly zoom: RPCReturnMapProxy<PresentationZoom>;
    /**
     * 幻灯片集合实例
     */
    readonly slides: RPCReturnMapProxy<PresentationSlides>;
}

/**
 * 幻灯片选区接口
 */
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 PresentationSettings {
    /**
     * 自定义菜单
     */
    menu?: {
        custom?: EditorMenuCustomButton[];
    };
    /**
     * Toolbar related settings
     */
    toolbar?: {
        features?: PresentationToolbarOptions['features'];
    };
}

/**
 * 幻灯片形状接口
 */
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 type SDKSettings = {
    [FileType.Document]: DocumentSettings;
    [FileType.Presentation]: PresentationSettings;
    [FileType.Spreadsheet]: SpreadsheetSettings;
};

/**
 * 表格单元格对象
 */
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 interface SpreadsheetCreateOptions extends BaseCreateOptions {
    fileType: FileType.Spreadsheet;
    settings?: SpreadsheetSettings;
}

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

export declare interface SpreadsheetFacade {
    /**
     * 工作簿实例
     */
    readonly workbook: RPCReturnMapProxy<SpreadsheetWorkbook>;
    /**
     * 当前活跃工作表
     */
    readonly activeSheet: Promise<RPCReturnMapProxy<SpreadsheetWorksheet>>;
    /**
     * 当前活动单元格
     */
    readonly activeCell: Promise<RPCReturnMapProxy<SpreadsheetCell> | null>;
    /**
     * 当前选区
     */
    readonly selections: Promise<RPCReturnMapProxy<SpreadsheetSelection>[] | null>;
    /**
     * 内容接口
     */
    readonly content: ReturnType<typeof createContentFacade>;
}

/**
 * 表格区域对象
 */
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 type SpreadsheetSelection = {
    /**
     * 获取选区的区域范围
     * @param value 可选的选区值
     */
    getRange: (value?: SpreadsheetRangeValue) => SpreadsheetRange | null;
    /**
     * 设置选区的区域范围
     * @param value 选区的区域范围或null
     */
    setRange: (value: SpreadsheetRangeValue | null) => void;
};

export declare interface SpreadsheetSettings {
    /**
     * 自定义菜单
     */
    menu?: {
        custom?: EditorMenuCustomButton[];
    };
    /**
     * Toolbar related settings
     */
    toolbar?: {
        features?: SheetToolbarOptions['features'];
    };
}

/**
 * 工作簿接口
 */
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 { }