@officesdk/web/index.d.ts

Web JS SDK for the Office SDK

import { RPCMap } from '@officesdk/rpc';
import { RPCReturnMapProxy } from '@officesdk/rpc';
import { RPCReturnMethods } from '@officesdk/rpc';
import { RPCReturnValueProxy } from '@officesdk/rpc';

/**
 * 初始化 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 type BaseMenuItemName = 
/** 查看/展开记录 */
'view'
/** 复制记录 */
| 'copy'
/** 删除记录 */
| 'remove'
/** 添加评论 */
| 'comment'
/** 获取记录链接 */
| 'link';

/**
 * 日历视图菜单项
 */
export declare type CalendarMenuItemName = 
/** 查看/展开记录 */
'view'
/** 复制记录 */
| 'copy'
/** 删除记录 */
| 'remove';

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

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

/**
 * create Office SDK instance
 */
export declare function createSDK(options: DocumentCreateOptions): OfficeDocumentSDK;

export declare function createSDK(options: SpreadsheetCreateOptions): OfficeSpreadSheetSDK;

export declare function createSDK(options: PresentationCreateOptions): OfficePresentationSDK;

export declare function createSDK(options: PdfCreateOptions): OfficePdfSDK;

export declare function createSDK(options: DBTableCreateOptions): OfficeDBTableSDK;

export declare function createSDK(options: LiteDocCreateOptions): OfficeLiteDocSDK;

/**
 * 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 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 DatabaseTableFieldContextMenuFeatureButtonName = TableFieldContextMenuFeatureButtonName;

export declare type DatabaseTableFieldContextMenuOptions = TableFieldContextMenuOptions;

export declare type DatabaseTableListBarButtonName = TableListBarButtonName;

export declare type DatabaseTableListBarCustomButtonConfig = TableListBarCustomButtonConfig;

export declare type DatabaseTableListBarOptions = TableListBarOptions;

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

export declare interface DatabaseTableSettings {
    fieldContextMenu?: DatabaseTableSDKOptions['fieldContextMenu'];
    viewContextMenu?: DatabaseTableSDKOptions['viewContextMenu'];
    toolbar?: DatabaseTableSDKOptions['toolbar'];
    listBar?: DatabaseTableSDKOptions['listBar'];
}

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

export declare type DatabaseTableToolbarFeatureButtonName = TableToolbarFeatureButtonName;

export declare type DatabaseTableToolbarOptions = TableToolbarOptions;

export declare type DatabaseTableViewContextMenuFeatureButtonName = TableViewContextMenuFeatureButtonName;

export declare type DatabaseTableViewContextMenuOptions = TableViewContextMenuOptions;

export declare interface DBTableCreateOptions extends BaseCreateOptions {
    fileType: FileType.DBTable;
    settings?: DatabaseTableSettings;
}

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

/**
 * 文档编辑器实例接口
 */
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 enum DocumentExportType {
    Docx = "docx",
    Pdf = "pdf",
    Image = "image"
}

export declare interface DocumentFacade {
    /**
     * 导出文档
     */
    readonly export: (type: DocumentExportType) => Promise<void>;
    /**
     * 选区实例
     */
    readonly selection: RPCReturnMapProxy<DocumentSelection>;
    /**
     * 主动保存内容
     */
    readonly content: RPCReturnMapProxy<EditorContent>;
    /**
     * 缩放实例
     */
    readonly zoom: RPCReturnMapProxy<DocumentZoom>;
    /**
     * 目录实例
     */
    readonly TOCs: RPCReturnMapProxy<DocumentTOCs>;
    /**
     * 目录实例
     */
    readonly outline: RPCReturnMapProxy<DocumentOutline>;
    /**
     * 窗口实例
     */
    readonly window: RPCReturnMapProxy<DocumentWindow>;
    /**
     * 段落实例
     */
    readonly paragraphs: RPCReturnMapProxy<DocumentParagraphs>;
}

export declare type DocumentMenuEntryConfig = DocxMenuEntryConfig;

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 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 settings
     */
    menu?: {
        disabled?: boolean;
        hidden?: boolean;
        custom?: DocxMenuOptions['custom'];
        features?: DocxMenuOptions['features'];
    };
    /**
     * toolbar settings
     */
    toolbar?: {
        disabled?: boolean;
        hidden?: boolean;
        features?: DocxToolbarOptions['features'];
    };
}

/**
 * 通用目录项条目
 * @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 DocumentToolbarFeatureButtonName = DocxToolbarFeatureButtonName;

export declare type DocumentWindow = DocxWindow;

export declare type DocumentWindowScrollIntoViewOptions = DocxWindowScrollIntoViewOptions;

export declare type DocumentWindowScrollParams = DocxWindowScrollParams;

/**
 * 文档缩放接口
 */
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;
};

/**
 * 传统文档菜单栏一级菜单
 * 可以通过指定泛型T来指定一级菜单的类型，例如DocxMenuEntryConfig<'button'>，不指定则默认为所有类型都有可能
 */
export declare type DocxMenuEntryConfig<T extends EditorMenuItemType = EditorMenuItemType> = EditorMenuEntryConfig<DocxMenuFeatureButtonName> & {
    type: T;
};

/**
 * 传统文档菜单栏内置功能按钮
 */
export declare type DocxMenuFeatureButtonName = 'file' | 'edit' | 'view' | 'insert' | 'format' | 'design' | 'transform-file' | 'plugins' | 'undo' | 'redo' | 'cut' | 'copy' | 'paste' | 'selectAll' | 'export' | 'saveTemplate' | 'viewHistory' | 'saveHistory' | 'exportWord' | 'exportImage' | 'exportPDF' | 'exportWPS' | 'exportImagePDF' | 'print' | 'viewFileInfo' | 'insertAttachment' | 'insertFilesFromDrive' | 'insertSignature' | 'insertImage' | 'insertImageFromLocal' | 'insertImageFromUrl' | 'enableEditingRestriction';

/**
 * 传统文档菜单栏相关配置，目前菜单栏不是所有套件都支持，
 */
export declare type DocxMenuOptions = EditorMenuOptions<DocxMenuFeatureButtonName>;

export declare interface DocxParagraphItem {
    /**
     * 获取段落范围(Range)
     * @returns 段落范围
     */
    getRange: () => Promise<DocxRange>;
}

export declare interface DocxParagraphs {
    /**
     * 获取所有段落列表
     * @returns 段落列表
     */
    getAll: () => Promise<DocxParagraphItem[]>;
    /**
     * 获取某个段落对象
     * @param index 段落对象索引
     * @returns 段落对象
     */
    getOne: (index: number) => Promise<DocxParagraphItem | null>;
    /**
     * 获取段落数量
     * @returns 段落数量
     */
    count: () => Promise<number>;
}

/**
 * 区域（Range）
 * 区域对象，表示文档中的一个连续区域，每个 Range 对象包含起始字符位置和终止字符位置。
 */
/**
 * 文档区域对象，
 * 用于表示文档中的一个连续区域，
 * 每个选区值包含了起始位置和结束位置信息的字符串。
 */
export declare interface DocxRange {
    /**
     * 区域的开始位置，
     * 当文档发生变化后，区域的标识可能会失效。
     */
    readonly start: string;
    /**
     * 区域的结束位置，
     * 当文档发生变化后，区域的标识可能会失效。
     */
    readonly end: string;
    /**
     * 是否为光标。
     */
    readonly isCaret: boolean;
    /**
     * 获取该区域对应的纯文本信息。
     * @returns
     */
    getText: () => string;
    /**
     * 将区域中的内容以 HTML 格式返回。
     * @returns
     */
    getHtml: () => string;
    /**
     * 将区域内的文本设置为指定的文本，
     * 如果文本为空，则清空区域内的文本。
     * 如果区域为
     * @param text
     */
    setText: (text: string) => void;
    /**
     * 将区域内的文本设置为指定的 HTML 内容，
     * 如果内容为空，则清空区域内的内容。
     * 如果区域为光标，则会将光标位置的文本替换为指定的 HTML 格式。
     * @param html
     */
    setHtml: (html: string) => void;
    /**
     * 获取选区在当前屏幕上的位置信息
     * @returns
     */
    getBounding: () => DocxRangeBounding | null;
}

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

/**
 * 区域值，
 * 包含了区域的开始位置和结束位置。
 */
export declare interface DocxRangeValue {
    /**
     * 开始位置
     */
    start: string;
    /**
     * 结束位置
     */
    end: string;
}

/**
 * Docx 工具栏按钮名称类型
 */
export declare type DocxToolbarFeatureButtonName = 
/** 撤销 */
'undo'
/** 重做 */
| 'redo'
/** 格式刷 */
| 'formatPainter'
/** 清除格式 */
| 'clearFormat'
/** 缩放 */
| 'zoom'
/** 样式 */
| 'styles'
/** 字体 */
| 'font'
/** 字号 */
| 'fontSize'
/** 增加字号 */
| 'increaseFontSize'
/** 减少字号 */
| 'decreaseFontSize'
/** 粗体 */
| 'bold'
/** 斜体 */
| 'italic'
/** 下划线 */
| 'underline'
/** 删除线 */
| 'strikeThrough'
/** 文字颜色 */
| 'textColor'
/** 高亮颜色 */
| 'highlightColor'
/** 上标 */
| 'superScript'
/** 下标 */
| 'subScript'
/** 左对齐 */
| 'leftAlign'
/** 居中 */
| 'center'
/** 右对齐 */
| 'rightAlign'
/** 两端对齐 */
| 'justify'
/** 编号列表 */
| 'numberedList'
/** 项目符号列表 */
| 'bulletedList'
/** 增加缩进 */
| 'increaseIndent'
/** 减少缩进 */
| 'decreaseIndent'
/** 行距 */
| 'lineSpacing'
/** 插入图片 */
| 'insertImage'
/** 插入图片-从本地 */
| 'insertImageFromLocal'
/** 插入图片-来自链接 */
| 'insertImageFromURL'
/** 插入表格 */
| 'insertTable'
/** 链接 */
| 'insertLink'
/** 开启限制编辑 */
| 'enableEditingRestriction'
/** 添加评论 */
| 'addComments';

/**
 * 传统文档工具栏配置
 */
export declare type DocxToolbarOptions = EditorToolbarOptions<DocxToolbarFeatureButtonName>;

/**
 * 文档窗口接口
 */
export declare interface DocxWindow {
    /**
     * 获取当前文档滚动位置，
     * 返回值为当前文档滚动位置的偏移量，
     * 这个偏移量是基于文档的左上角为原点，向右向下为正方向
     * @returns
     */
    getScrollPosition: () => {
        x: number;
        y: number;
    };
    /**
     * 滚动到指定位置
     * @param params 滚动参数
     */
    scrollTo: (params: DocxWindowScrollParams) => void;
    /**
     * 滚动到指定页面
     * @param page
     */
    scrollToPage: (page: number) => void;
    /**
     * 将传入的区域滚动到可视区域
     * @param range
     */
    scrollIntoView: (range: DocxRangeValue, options?: DocxWindowScrollIntoViewOptions) => void;
    /**
     * 添加滚动监听器
     * @param listener
     */
    addScrollListener: (listener: (offset: {
        x: number;
        y: number;
    }) => void) => () => void;
}

/**
 * 滚动到指定区域的选项
 */
export declare interface DocxWindowScrollIntoViewOptions {
    /**
     * 滚动到指定区域的位置，默认是start
     */
    position?: 'start' | 'end';
    /**
     * 是否将滚动到的区域置于文档可见范围的顶部。默认为bottom
     */
    alignment?: 'top' | 'bottom';
}

export declare type DocxWindowScrollParams = {
    /**
     * 区域，跳转到对应区域位置
     */
    type: 'range';
    /**
     * 区域值，这个值可以通过 DocxSelection 的 getRange 方法拿到，取start或者end
     */
    range: string;
} | {
    /**
     * 页码，跳转到对应页码位置
     */
    type: 'page';
    /**
     * 页码
     */
    page: number;
} | {
    /**
     * 顶部，跳转到文档顶部
     */
    type: 'top';
} | {
    /**
     * 滚动到某个位置，
     * 这个位置是基于文档的左上角为原点，向右向下为正方向
     */
    type: 'position';
    /**
     * 位置
     */
    position: {
        x: number;
        y: number;
    };
} | {
    /**
     * 偏移量，跳转到对应偏移量位置
     */
    type: 'offset';
    /**
     * 偏移量
     */
    offset: {
        x: number;
        y: number;
    };
} | {
    /**
     * 跳转到某个评论
     */
    type: 'comment';
    /**
     * 评论 ID
     */
    commentId: string;
};

/**
 * 编辑器内容接口
 */
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 EditorFeatureConfig {
    /**
     * 功能是否被禁用（入口还在）
     */
    disabled?: boolean;
    /**
     * 功能入口是否被隐藏
     */
    hidden?: boolean;
}

/**
 * 基础菜单项配置，所有菜单项类型都包含这些属性
 */
export declare interface EditorMenuBaseMenuItemConfig<TName extends string> {
    /**
     * 菜单项的唯一标识，用以确定配置的是哪个菜单
     */
    name: TName;
    /**
     * 菜单项类型
     */
    type: EditorMenuItemType;
}

/**
 * 按钮菜单项配置
 */
export declare interface EditorMenuButtonMenuItemConfig<TName extends string> extends EditorMenuBaseMenuItemConfig<TName> {
    type: 'button';
    /**
     * 是否禁用菜单项，禁用后菜单项依旧显示不过变为灰色，不可点击
     */
    disabled?: boolean;
    /**
     * 菜单项显示文本，修改该值可以替换此菜单项默认显示文案
     */
    label?: string;
    /**
     * 菜单项图标，可以是 base64 的图片信息，也可以是图片 url
     * 配置为空字符串则可以隐藏菜单项默认的图标
     */
    icon?: string;
    /**
     * 菜单项点击事件，接受一个函数，可以自定义点击事件
     */
    callback?: () => void;
}

/**
 * 菜单栏自定义按钮配置
 */
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;
};

/**
 * 编辑器菜单配置类型
 * 根据 TName 类型的不同返回不同的菜单配置类型:
 * 1. 当 TName 是对象类型时（如 {pasteMenu: [...]})，会自动提取对象的键作为菜单名称
 * 2. 当 TName 是字符串时，返回普通菜单项配置
 */
export declare type EditorMenuEntryConfig<TName extends EditorMenuName> = TName extends Record<string, EditorMenuName[]> ? EditorMenuEntryMenuItemConfig<string & keyof TName, TName[keyof TName]> : TName extends string ? EditorMenuHiddenMenuItemConfig<TName> | EditorMenuButtonMenuItemConfig<TName> | EditorMenuLinkMenuItemConfig<TName> | EditorMenuEntryMenuItemConfig<TName, never> : never;

/**
 * 子菜单入口配置
 * TName: 菜单项名称（字符串类型）
 * TChildName: 子菜单项名称数组类型，用于配置下一级菜单项
 */
export declare interface EditorMenuEntryMenuItemConfig<TName extends string, TChildName extends EditorMenuName[]> extends EditorMenuBaseMenuItemConfig<TName> {
    type: 'entry';
    /**
     * 是否禁用菜单项，禁用后菜单项依旧显示不过变为灰色，不可点击
     */
    disabled?: boolean;
    /**
     * 菜单项显示文本，修改该值可以替换此菜单项默认显示文案
     */
    label?: string;
    /**
     * 菜单项图标，可以是 base64 的图片信息，也可以是图片 url
     * 配置为空字符串则可以隐藏菜单项默认的图标
     */
    icon?: string;
    /**
     * 下一级菜单配置，下一级菜单配置项和上一级相同
     * 如果下一级仍然是 entry 类型，可以无限向下扩展
     * 只有当 TName 是对象类型时才应有子菜单
     */
    children?: TChildName extends EditorMenuName[] ? EditorMenuEntryConfig<TChildName[number]>[] : never;
}

/**
 * 菜单栏功能按钮配置
 */
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 interface EditorMenuFeatureConfig extends EditorFeatureConfig {
    /**
     * 按钮标签（显示文本）一般工具栏上的按钮不会显示文本，如果需要显示文本，配置此项。
     */
    label?: string;
    /**
     * 按钮图标，可以是 base64 的图片信息，也可以是图片 url
     */
    icon?: string;
    /**
     * 按钮点击事件.接受一个函数，可以自定义点击事件。
     */
    callback?: () => void;
    /**
     * 按钮提示文本,鼠标悬浮到按钮上时显示的tooltip文字
     */
    tooltip?: string;
    /**
     * 按钮在工具栏中位置，不设置则按照默认位置
     */
    index?: number;
}

/**
 * 隐藏菜单项配置
 */
export declare interface EditorMenuHiddenMenuItemConfig<TName extends string> extends EditorMenuBaseMenuItemConfig<TName> {
    type: 'hidden';
}

/**
 * 菜单项类型
 */
export declare type EditorMenuItemType = 'hidden' | 'button' | 'link' | 'entry';

/**
 * 链接菜单项配置
 */
export declare interface EditorMenuLinkMenuItemConfig<TName extends string> extends EditorMenuBaseMenuItemConfig<TName> {
    type: 'link';
    /**
     * 是否禁用菜单项，禁用后菜单项依旧显示不过变为灰色，不可点击
     */
    disabled?: boolean;
    /**
     * 菜单项显示文本，修改该值可以替换此菜单项默认显示文案
     */
    text?: string;
    /**
     * 菜单项图标，可以是 base64 的图片信息，也可以是图片 url
     * 配置为空字符串则可以隐藏菜单项默认的图标
     */
    icon?: string;
    /**
     * 跳转链接地址
     */
    url?: string;
}

/**
 * 菜单项名称类型
 * 可以是字符串或包含子菜单数组的对象
 * 如: 'copy' 或 { pasteMenu: ['pasteAll', 'pasteHead', 'pasteValueOnly'] }
 */
export declare type EditorMenuName = string | Record<string, EditorMenuName[]>;

/**
 * 菜单栏相关配置，目前菜单栏不是所有套件都支持，
 * 菜单栏是指的编辑器最上放可以展开二级菜单的那一栏。
 */
export declare interface EditorMenuOptions<TName extends EditorMenuName> {
    /**
     * 菜单栏是否隐藏，设置为true, 则整个菜单栏不显示
     */
    hidden?: boolean;
    /**
     * 是否禁用菜单栏所有功能。设置为true，菜单栏依旧显示，但所有菜单项为灰色不可点击
     */
    disabled?: boolean;
    /**
     * 菜单栏一级菜单配置，指显示在菜单栏上的菜单项。
     * 支持普通菜单项和嵌套菜单项
     */
    entries?: EditorMenuEntryConfig<TName>[];
    /**
     * 菜单栏功能按钮配置
     * 更加间接的配置项
     * 仅在 TName 为字符串类型时有效
     */
    features?: [TName] extends [string] ? Partial<Record<TName, EditorMenuFeatureConfig>> : never;
    /**
     * 自定义按钮配置
     */
    custom?: (EditorMenuButtonMenuItemConfig<string> | EditorMenuLinkMenuItemConfig<string>)[];
}

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

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

/**
 * 大纲目录项条目
 */
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"
}

/**
 * 工具栏功能按钮配置(包括内置按钮和自定义按钮)
 */
export declare interface EditorToolbarFeatureButton<TName extends string> extends EditorFeatureConfig {
    /**
     * 按钮的唯一标识，用以确定配置的是哪个按钮。
     */
    name?: TName;
    /**
     * 按钮标签（显示文本）一般工具栏上的按钮不会显示文本，如果需要显示文本，配置此项。
     */
    label?: string;
    /**
     * 按钮图标，可以是 base64 的图片信息，也可以是图片 url
     */
    icon?: string;
    /**
     * 按钮点击事件.接受一个函数，可以自定义点击事件。
     */
    callback?: () => void;
    /**
     * 按钮提示文本,鼠标悬浮到按钮上时显示的tooltip文字
     */
    tooltip?: string;
    /**
     * 按钮在工具栏中位置，不设置则按照默认位置
     */
    index?: number;
}

/**
 * 工具栏内置功能按钮配置
 */
export declare type EditorToolbarFeatureButtonConfig<TName extends string> = {
    [key in TName]?: EditorToolbarFeatureButton<key>;
};

/**
 * 工具栏相关设置，可以控制工具栏的显示内容
 */
export declare interface EditorToolbarOptions<TName extends string> {
    /**
     * 控制工具栏显隐状态
     */
    hidden?: boolean;
    /**
     * 是否禁用工具栏所有功能
     */
    disabled?: boolean;
    /**
     * 现有按钮的功能配置
     */
    features?: EditorToolbarFeatureButtonConfig<TName>;
    /**
     * 自定义按钮
     */
    custom?: EditorToolbarFeatureButtonConfig<string>;
    /**
     * 工具栏挂载的容器dom，配置后则挂载到指定的容器上
     *
     * 如果不配置则按照套件的默认方式挂载。
     */
    container?: HTMLElement;
}

/**
 * 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 GalleryMenuItemName = BaseMenuItemName | 'insert';

/**
 * 甘特图视图菜单项
 */
export declare type GanttMenuItemName = GridMenuItemName
/** 设置为里程碑 */
| 'milestone'
/** 取消里程碑 */
| 'cancelMilestone'
/** 清除内容 */
| 'clear';

/**
 * 网格视图菜单项
 */
export declare type GridMenuItemName = BaseMenuItemName
/** 粘贴 */
| 'pasteValue'
/** 选择性粘贴 - 含子菜单 */
| {
    pasteMenu: [
    /** 粘贴内容及表头 */
    'pasteAll',
    /** 仅粘贴表头 */
    'pasteHead',
    /** 仅粘贴内容 */
    'pasteValueOnly'
    ];
}
/** 向上插入记录 */
| 'insertBefore'
/** 向下插入记录 */
| 'insertAfter'
/** 新增子任务 */
| 'newSubRecord'
/** 展开父任务 */
| 'parentRecord';

/**
 * 看板视图菜单项
 */
export declare type KanbanMenuItemName = BaseMenuItemName
/** 编辑分组 */
| 'editGroup'
/** 移除分组 */
| 'removeGroup';

/**
 * 列表视图菜单项
 */
export declare type ListMenuItemName = BaseMenuItemName
/** 向上插入记录 */
| 'insertBefore'
/** 向下插入记录 */
| 'insertAfter'
/** 新增子任务 */
| 'newSubRecord'
/** 展开父任务 */
| 'parentRecord'
/** 获取指向此记录的链接 */
| 'copyRecordLink';

export declare interface LiteDocCreateOptions extends BaseCreateOptions {
    fileType: FileType.LiteDoc;
    settings?: unknown;
}

export declare interface LTDocFacade {
}

/**
 * dbtable sdk
 */
export declare type OfficeDBTableSDK = OfficeSDK<FileType.DBTable>;

/**
 * document sdk
 */
export declare type OfficeDocumentSDK = OfficeSDK<FileType.Document>;

/**
 * liteDoc sdk
 */
export declare type OfficeLiteDocSDK = OfficeSDK<FileType.LiteDoc>;

/**
 * pdf sdk
 */
export declare type OfficePdfSDK = OfficeSDK<FileType.Pdf>;

/**
 * presentation sdk
 */
export declare type OfficePresentationSDK = OfficeSDK<FileType.Presentation>;

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

/**
 * spreadsheet sdk
 */
export declare type OfficeSpreadSheetSDK = OfficeSDK<FileType.Spreadsheet>;

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 = Omit<EditorOutline<{
    text: string;
}>, 'setVisible'>;

/**
 * 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 enum PresentationExportType {
    Pptx = "pptx",
    ImagePdf = "imagePdf",
    Image = "image"
}

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

/**
 * 幻灯片工具栏内置功能按钮
 */
export declare type PresentationMenuFeatureButtonName = 'edit' | 'insert' | 'format' | 'animation' | 'arrange' | 'design' | 'slide' | 'view' | 'slideshow' | 'review' | 'exportConverter';

export declare type PresentationMenuOptions = EditorMenuOptions<PresentationMenuFeatureButtonName>;

/**
 * 幻灯片选区接口
 */
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?: {
        disabled?: boolean;
        hidden?: boolean;
        custom?: PresentationMenuOptions['custom'];
        features?: PresentationMenuOptions['features'];
    };
    /**
     * Toolbar related settings
     */
    toolbar?: {
        disabled?: boolean;
        hidden?: boolean;
        features?: PresentationToolbarFeatureButtonConfig;
    };
}

/**
 * 幻灯片形状接口
 */
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 PresentationToolbarFeatureButtonConfig = EditorToolbarFeatureButtonConfig<PresentationToolbarFeatureButtonName>;

/**
 * 幻灯片工具栏按钮名称
 */
export declare type PresentationToolbarFeatureButtonName = 'insertImage' | 'insertShape' | 'insertChart' | 'insertTable' | 'insertTextbox' | 'insertSymbol' | 'insertDiagram' | 'insertAudio' | 'insertAttachment' | 'insertVideo' | 'insertLink' | 'changeTheme' | 'presentationSize' | 'backgroundSetting' | 'pageTransitionAnimation' | 'elementAnimation' | 'searchAndReplace' | 'addComment';

/**
 * 幻灯片工具栏
 */
export declare type PresentationToolbarOptions = EditorToolbarOptions<PresentationToolbarFeatureButtonName>;

/**
 * 幻灯片缩放接口
 */
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 { RPCMap }

export { RPCReturnMapProxy }

export { RPCReturnMethods }

export { RPCReturnValueProxy }

export declare type SDKSettings = {
    [FileType.Document]: DocumentSettings;
    [FileType.Presentation]: PresentationSettings;
    [FileType.Spreadsheet]: SpreadsheetSettings;
};

/**
 * 专业表格工具栏一级菜单
 */
export declare type SheetMenuEntryConfig = EditorMenuEntryConfig<SheetMenuFeatureButtonName>;

/**
 * 专业表格工具栏内置功能按钮
 */
export declare type SheetMenuFeatureButtonName = 'edit' | 'insert' | 'format' | 'formula' | 'data' | 'view' | 'form' | 'tools' | 'plugins' | 'help';

export declare type SheetMenuOptions = EditorMenuOptions<SheetMenuFeatureButtonName>;

/**
 * 专业表格工具栏按钮名称
 */
export declare type SheetToolbarFeatureButtonName = 'undo' | 'redo' | 'print' | 'optionalPaste' | 'brush' | 'clear' | 'dataFormat' | 'percentage' | 'thousandsSeparator' | 'increasePrecision' | 'decreasePrecision' | 'fontFamily' | 'fontSize' | 'increaseFontSize' | 'decreaseFontSize' | 'fontColor' | 'bold' | 'italic' | 'underline' | 'strike' | 'border' | 'backgroundColor' | 'align' | 'alignLeft' | 'alignCenter' | 'alignRight' | 'textWrap' | 'vertical' | 'verticalTop' | 'verticalMiddle' | 'verticalBottom' | 'mergeCell' | 'sheetLtr' | 'sheetRtl' | 'cellLtr' | 'cellRtl' | 'textRotation' | 'increaseIndent' | 'decreaseIndent' | 'frozen' | 'sort' | 'filter' | 'conditionalFormat' | 'dataValidation' | 'formula' | 'importRange' | 'checkbox' | 'link' | 'chart' | 'image' | 'quickTools' | 'searchReplace' | 'revision' | 'comment';

/**
 * 专业表格工具栏
 */
export declare type SheetToolbarOptions = EditorToolbarOptions<SheetToolbarFeatureButtonName>;

/**
 * 表格单元格对象
 */
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 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 SpreadsheetExportType = 'image' | 'pdf' | 'xlsx';

export declare interface SpreadsheetFacade {
    /**
     * export file
     */
    readonly export: (type: SpreadsheetExportType) => Promise<void>;
    /**
     * 工作簿实例
     */
    readonly workbook: RPCReturnMapProxy<SpreadsheetWorkbook>;
    /**
     * 当前活跃工作表
     */
    readonly activeSheet: Promise<RPCReturnMapProxy<SpreadsheetWorksheet>>;
    /**
     * 当前活动单元格
     */