@univerjs-pro/boards-ui 1.0.0-alpha.3

package/lib/types/locale/es-ES.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/fa-IR.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/fr-FR.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/id-ID.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/it-IT.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/ja-JP.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/ko-KR.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/pl-PL.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/pt-BR.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/ru-RU.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/shared/shape-preset-labels.d.ts

@@ -0,0 +1,153 @@
+export declare const BOARD_EXTRA_SHAPE_PRESET_LABELS: {
+    readonly snip1Rect: "Single snip corner rectangle";
+    readonly snip2SameRect: "Same-side snip corner rectangle";
+    readonly snip2DiagRect: "Diagonal snip corner rectangle";
+    readonly snipRoundRect: "Snip and round corner rectangle";
+    readonly round1Rect: "Single round corner rectangle";
+    readonly round2SameRect: "Same-side round corner rectangle";
+    readonly round2DiagRect: "Diagonal round corner rectangle";
+    readonly heptagon: "Heptagon";
+    readonly decagon: "Decagon";
+    readonly dodecagon: "Dodecagon";
+    readonly pie: "Pie";
+    readonly chord: "Chord";
+    readonly teardrop: "Teardrop";
+    readonly frame: "Frame";
+    readonly halfFrame: "Half frame";
+    readonly corner: "Corner";
+    readonly diagStripe: "Diagonal stripe";
+    readonly plaque: "Plaque";
+    readonly cube: "Cube";
+    readonly bevel: "Bevel";
+    readonly donut: "Donut";
+    readonly noSmoking: "No symbol";
+    readonly blockArc: "Block arc";
+    readonly foldedCorner: "Folded corner";
+    readonly smileyFace: "Smiley face";
+    readonly heart: "Heart";
+    readonly lightningBolt: "Lightning bolt";
+    readonly sun: "Sun";
+    readonly moon: "Moon";
+    readonly arc: "Arc";
+    readonly bracketPair: "Bracket pair";
+    readonly bracePair: "Brace pair";
+    readonly leftBracket: "Left bracket";
+    readonly rightBracket: "Right bracket";
+    readonly upArrow: "Up arrow";
+    readonly downArrow: "Down arrow";
+    readonly upDownArrow: "Up-down arrow";
+    readonly quadArrow: "Four-way arrow";
+    readonly leftRightUpArrow: "Left-right-up arrow";
+    readonly bentArrow: "Bent arrow";
+    readonly uturnArrow: "U-turn arrow";
+    readonly leftUpArrow: "Left-up arrow";
+    readonly bentUpArrow: "Bent-up arrow";
+    readonly curvedRightArrow: "Curved right arrow";
+    readonly curvedLeftArrow: "Curved left arrow";
+    readonly curvedUpArrow: "Curved up arrow";
+    readonly curvedDownArrow: "Curved down arrow";
+    readonly stripedRightArrow: "Striped right arrow";
+    readonly notchedRightArrow: "Notched right arrow";
+    readonly rightArrowCallout: "Right arrow callout";
+    readonly downArrowCallout: "Down arrow callout";
+    readonly leftArrowCallout: "Left arrow callout";
+    readonly upArrowCallout: "Up arrow callout";
+    readonly leftRightArrowCallout: "Left-right arrow callout";
+    readonly quadArrowCallout: "Four-way arrow callout";
+    readonly circularArrow: "Circular arrow";
+    readonly mathMinus: "Minus";
+    readonly mathMultiply: "Multiply";
+    readonly mathDivide: "Divide";
+    readonly mathEqual: "Equal";
+    readonly mathNotEqual: "Not equal";
+    readonly flowChartProcess: "Process";
+    readonly flowChartAlternateProcess: "Alternate process";
+    readonly flowChartDecision: "Decision";
+    readonly flowChartInputOutput: "Input/output";
+    readonly flowChartPredefinedProcess: "Predefined process";
+    readonly flowChartInternalStorage: "Internal storage";
+    readonly flowChartDocument: "Document";
+    readonly flowChartMultidocument: "Multiple documents";
+    readonly flowChartTerminator: "Terminator";
+    readonly flowChartPreparation: "Preparation";
+    readonly flowChartManualInput: "Manual input";
+    readonly flowChartManualOperation: "Manual operation";
+    readonly flowChartConnector: "Connector";
+    readonly flowChartOffpageConnector: "Off-page connector";
+    readonly flowChartPunchedCard: "Punched card";
+    readonly flowChartPunchedTape: "Punched tape";
+    readonly flowChartSummingJunction: "Summing junction";
+    readonly flowChartOr: "Or";
+    readonly flowChartCollate: "Collate";
+    readonly flowChartSort: "Sort";
+    readonly flowChartExtract: "Extract";
+    readonly flowChartMerge: "Merge";
+    readonly flowChartOnlineStorage: "Online storage";
+    readonly flowChartDelay: "Delay";
+    readonly flowChartMagneticTape: "Magnetic tape";
+    readonly flowChartMagneticDisk: "Magnetic disk";
+    readonly flowChartMagneticDrum: "Magnetic drum";
+    readonly flowChartDisplay: "Display";
+    readonly irregularSeal1: "Explosion 1";
+    readonly irregularSeal2: "Explosion 2";
+    readonly star4: "4-point star";
+    readonly star6: "6-point star";
+    readonly star7: "7-point star";
+    readonly star8: "8-point star";
+    readonly star10: "10-point star";
+    readonly star12: "12-point star";
+    readonly star16: "16-point star";
+    readonly star24: "24-point star";
+    readonly star32: "32-point star";
+    readonly ribbon2: "Ribbon 2";
+    readonly ribbon: "Ribbon";
+    readonly ellipseRibbon2: "Ellipse ribbon 2";
+    readonly ellipseRibbon: "Ellipse ribbon";
+    readonly verticalScroll: "Vertical scroll";
+    readonly horizontalScroll: "Horizontal scroll";
+    readonly wave: "Wave";
+    readonly doubleWave: "Double wave";
+    readonly wedgeRectCallout: "Rectangular callout";
+    readonly cloudCallout: "Cloud callout";
+    readonly borderCallout1: "Border callout 1";
+    readonly borderCallout2: "Border callout 2";
+    readonly borderCallout3: "Border callout 3";
+    readonly accentCallout1: "Accent callout 1";
+    readonly accentCallout2: "Accent callout 2";
+    readonly accentCallout3: "Accent callout 3";
+    readonly callout1: "Callout 1";
+    readonly callout2: "Callout 2";
+    readonly callout3: "Callout 3";
+    readonly accentBorderCallout1: "Accent border callout 1";
+    readonly accentBorderCallout2: "Accent border callout 2";
+    readonly accentBorderCallout3: "Accent border callout 3";
+    readonly leftCircularArrow: "Left circular arrow";
+    readonly leftRightCircularArrow: "Left-right circular arrow";
+    readonly swooshArrow: "Swoosh arrow";
+    readonly leftRightRibbon: "Left-right ribbon";
+    readonly pieWedge: "Pie wedge";
+    readonly funnel: "Funnel";
+    readonly gear6: "Gear 6";
+    readonly gear9: "Gear 9";
+    readonly cornerTabs: "Corner tabs";
+    readonly actionButtonBackPrevious: "Back or previous button";
+    readonly actionButtonForwardNext: "Forward or next button";
+    readonly actionButtonBeginning: "Beginning button";
+    readonly actionButtonEnd: "End button";
+    readonly actionButtonHome: "Home button";
+    readonly actionButtonInformation: "Information button";
+    readonly actionButtonReturn: "Return button";
+    readonly actionButtonMovie: "Movie button";
+    readonly actionButtonDocument: "Document button";
+    readonly actionButtonSound: "Sound button";
+    readonly actionButtonHelp: "Help button";
+    readonly actionButtonBlank: "Blank button";
+    readonly chartPlus: "Chart plus";
+    readonly chartStar: "Chart star";
+    readonly chartX: "Chart X";
+    readonly flowChartOfflineStorage: "Offline storage";
+    readonly lineInv: "Inverse line";
+    readonly plaqueTabs: "Plaque tabs";
+    readonly squareTabs: "Square tabs";
+    readonly upDownArrowCallout: "Up-down arrow callout";
+};

package/lib/types/locale/sk-SK.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/types.d.ts

@@ -0,0 +1,3 @@
+import type { LocaleLeafKeys } from '@univerjs/core';
+import type enUS from './en-US';
+export type LocaleKey = LocaleLeafKeys<typeof enUS>;

package/lib/types/locale/vi-VN.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/zh-CN.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/zh-HK.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/zh-TW.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/menu/board-container-child-contextmenu.menu.d.ts

@@ -0,0 +1,5 @@
+import type { IAccessor } from '@univerjs/core';
+import type { IMenuButtonItem } from '@univerjs/ui';
+export declare function BoardContainerChildContextMenuMoveOutFactory(accessor?: IAccessor): IMenuButtonItem;
+export declare function BoardContainerChildContextMenuSelectParentFactory(accessor?: IAccessor): IMenuButtonItem;
+export declare function BoardContainerChildContextMenuFitParentFactory(accessor?: IAccessor): IMenuButtonItem;

package/lib/types/menu/board-container-child-contextmenu.schema.d.ts

@@ -0,0 +1,2 @@
+import type { MenuSchemaType } from '@univerjs/ui';
+export declare const boardContainerChildContextMenuSchema: MenuSchemaType;

package/lib/types/menu/board-container-contextmenu.menu.d.ts

@@ -0,0 +1,9 @@
+import type { IAccessor } from '@univerjs/core';
+import type { IMenuButtonItem } from '@univerjs/ui';
+export declare function BoardContainerContextMenuRenameFactory(accessor?: IAccessor): IMenuButtonItem;
+export declare function BoardContainerContextMenuFitFactory(accessor?: IAccessor): IMenuButtonItem;
+export declare function BoardContainerContextMenuSelectContentsFactory(accessor?: IAccessor): IMenuButtonItem;
+export declare function BoardContainerContextMenuToggleMembershipLockFactory(accessor?: IAccessor): IMenuButtonItem;
+export declare function BoardContainerContextMenuToggleAutoResizeFactory(accessor?: IAccessor): IMenuButtonItem;
+export declare function BoardContainerContextMenuDisbandFactory(accessor?: IAccessor): IMenuButtonItem;
+export declare function BoardContainerContextMenuDeleteFactory(accessor?: IAccessor): IMenuButtonItem;

package/lib/types/menu/board-container-contextmenu.schema.d.ts

@@ -0,0 +1,2 @@
+import type { MenuSchemaType } from '@univerjs/ui';
+export declare const boardContainerContextMenuSchema: MenuSchemaType;

package/lib/types/menu/board-contextmenu.d.ts

@@ -0,0 +1,7 @@
+export declare enum BoardContainerContextMenuPosition {
+    CONTAINER = "board.contextMenu.container",
+    CHILD = "board.contextMenu.container-child"
+}
+export declare enum BoardSwimlaneLaneContextMenuPosition {
+    LANE = "board.contextMenu.swimlane-lane"
+}

package/lib/types/menu/board-swimlane-contextmenu.menu.d.ts

@@ -0,0 +1,8 @@
+import type { IAccessor } from '@univerjs/core';
+import type { IMenuButtonItem } from '@univerjs/ui';
+export declare function BoardSwimlaneLaneAddFactory(accessor?: IAccessor): IMenuButtonItem;
+export declare function BoardSwimlaneLaneRemoveFactory(accessor?: IAccessor): IMenuButtonItem;
+export declare function BoardSwimlaneLaneRenameFactory(accessor?: IAccessor): IMenuButtonItem;
+export declare function BoardSwimlaneLaneMovePreviousFactory(accessor?: IAccessor): IMenuButtonItem;
+export declare function BoardSwimlaneLaneMoveNextFactory(accessor?: IAccessor): IMenuButtonItem;
+export declare function BoardSwimlaneLaneCollapseFactory(accessor?: IAccessor): IMenuButtonItem;

package/lib/types/menu/board-swimlane-contextmenu.schema.d.ts

@@ -0,0 +1,2 @@
+import type { MenuSchemaType } from '@univerjs/ui';
+export declare const boardSwimlaneLaneContextMenuSchema: MenuSchemaType;

package/lib/types/plugin.d.ts

@@ -0,0 +1,21 @@
+import type { IUniverBoardsUIConfig } from './config/config';
+import { ICommandService, IConfigService, Injector, Plugin, UniverInstanceType } from '@univerjs/core';
+import { IRenderManagerService } from '@univerjs/engine-render';
+import { IMenuManagerService, IUIPartsService } from '@univerjs/ui';
+export declare const BOARDS_UI_PLUGIN_NAME = "UNIVER_BOARDS_UI_PLUGIN";
+export declare class UniverBoardsUIPlugin extends Plugin {
+    private readonly _config;
+    protected readonly _injector: Injector;
+    private readonly _renderManagerService;
+    private readonly _uiPartsService;
+    private readonly _commandService;
+    private readonly _menuManagerService;
+    private readonly _configService;
+    static pluginName: string;
+    static packageName: string;
+    static version: string;
+    static type: UniverInstanceType;
+    constructor(_config: Partial<IUniverBoardsUIConfig> | undefined, _injector: Injector, _renderManagerService: IRenderManagerService, _uiPartsService: IUIPartsService, _commandService: ICommandService, _menuManagerService: IMenuManagerService, _configService: IConfigService);
+    onStarting(): void;
+    onReady(): void;
+}

package/lib/types/render-adapters/board-element-render-adapter.d.ts

@@ -0,0 +1,63 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+import type { IImageIoService, LocaleService } from '@univerjs/core';
+import type { BaseObject } from '@univerjs/engine-render';
+import type { IBoardFocusedSwimlaneLane } from '../services/board-element-state.service';
+export declare const BOARD_ELEMENT_OBJECT_PREFIX = "board-element";
+export interface IBoardElementRenderObjectKey {
+    unitId: string;
+    elementId: string;
+}
+export interface IBoardElementRenderBounds {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    angle: number;
+    flipX?: boolean;
+    flipY?: boolean;
+}
+export interface ICreateBoardElementRenderObjectOptions {
+    unitId: string;
+    elementDataItem: IBoardElementData;
+    elementData?: Record<string, IBoardElementData>;
+    zIndex?: number;
+    imageIoService?: IImageIoService;
+    localeService?: LocaleService;
+    adapters?: readonly IBoardElementRenderAdapter[];
+    focusedSwimlaneLane?: IBoardFocusedSwimlaneLane | null;
+}
+export interface ISyncBoardElementRenderObjectOptions {
+    adapters?: readonly IBoardElementRenderAdapter[];
+    preserveTransform?: boolean;
+    elementData?: Record<string, IBoardElementData>;
+    unitId?: string;
+    zIndex?: number;
+    focusedSwimlaneLane?: IBoardFocusedSwimlaneLane | null;
+}
+export interface IBoardElementRenderAdapterContext {
+    unitId: string;
+    elementDataItem: IBoardElementData;
+    elementData?: Record<string, IBoardElementData>;
+    key: string;
+    bounds: IBoardElementRenderBounds;
+    zIndex?: number;
+    imageIoService?: IImageIoService;
+    localeService?: LocaleService;
+    focusedSwimlaneLane?: IBoardFocusedSwimlaneLane | null;
+}
+export interface IBoardElementRenderAdapter {
+    name: string;
+    createObject: (context: IBoardElementRenderAdapterContext) => BaseObject | null;
+    syncObject?: (object: BaseObject, context: IBoardElementRenderAdapterContext & {
+        preserveTransform?: boolean;
+    }) => boolean;
+}
+export declare function getBoardElementRenderObjectKey(unitId: string, elementId: string): string;
+export declare function parseBoardElementRenderObjectKey(oKey: string): IBoardElementRenderObjectKey | null;
+export declare function getBoardElementRenderBounds(elementDataItem: IBoardElementData, elementData?: Record<string, IBoardElementData>): IBoardElementRenderBounds;
+export declare const BOARD_CONNECTOR_ELEMENT_RENDER_ADAPTER: IBoardElementRenderAdapter;
+export declare const BOARD_SHAPE_ELEMENT_RENDER_ADAPTER: IBoardElementRenderAdapter;
+export declare const BOARD_IMAGE_ELEMENT_RENDER_ADAPTER: IBoardElementRenderAdapter;
+export declare const BOARD_ELEMENT_RENDER_ADAPTERS: readonly IBoardElementRenderAdapter[];
+export declare function createBoardElementRenderObject({ unitId, elementDataItem, elementData, zIndex, imageIoService, localeService, adapters, focusedSwimlaneLane, }: ICreateBoardElementRenderObjectOptions): BaseObject | null;
+export declare function syncBoardElementRenderObject(object: BaseObject, elementDataItem: IBoardElementData, options?: ISyncBoardElementRenderObjectOptions): boolean;

package/lib/types/render-objects/board-adjust-point-object.d.ts

@@ -0,0 +1,27 @@
+import type { IObjectFullState, IViewportInfo, UniverRenderingContext } from '@univerjs/engine-render';
+import { Rect } from '@univerjs/engine-render';
+export declare const BOARD_ADJ_HANDLE_SIZE = 4;
+export interface IBoardAdjustPointObjectProps extends IObjectFullState {
+    adjName: string;
+    fill?: string;
+    handleShape?: 'diamond' | 'circle';
+    stroke?: string;
+    strokeWidth?: number;
+}
+export declare class BoardAdjustPointObject extends Rect {
+    readonly adjName: string;
+    private readonly _handleShape;
+    private _handleStyle;
+    constructor(key: string, props: IBoardAdjustPointObjectProps);
+    updateStyle(style: {
+        fill?: string;
+        stroke?: string;
+        strokeWidth?: number;
+    }): void;
+    getHandleStyle(): {
+        fill?: string;
+        stroke?: string;
+        strokeWidth?: number;
+    };
+    render(ctx: UniverRenderingContext, bounds: IViewportInfo): this;
+}

package/lib/types/render-objects/board-connector-affordance-object.d.ts

@@ -0,0 +1,21 @@
+import type { IBoardConnectorPoint, IBoardThemeData } from '@univerjs-pro/boards';
+import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import type { IBoardConnectorAffordanceHandle } from '../utils/board-connector-affordance.util';
+import { BaseObject } from '@univerjs/engine-render';
+export interface IBoardConnectorAffordanceObjectState {
+    handles: IBoardConnectorAffordanceHandle[];
+    hoveredHandle?: IBoardConnectorAffordanceHandle | null;
+    zoomRatio: number;
+    themeData?: IBoardThemeData;
+}
+export declare const BOARD_CONNECTOR_AFFORDANCE_OBJECT_KEY = "board-connector-affordance-object";
+export declare const BOARD_CONNECTOR_AFFORDANCE_OBJECT_LAYER_INDEX: 5;
+export declare class BoardConnectorAffordanceObject extends BaseObject {
+    private _state;
+    constructor(key?: string, state?: Partial<IBoardConnectorAffordanceObjectState>);
+    updateState(state?: Partial<IBoardConnectorAffordanceObjectState>): void;
+    setHoveredHandle(handle: IBoardConnectorAffordanceHandle | null): void;
+    getHitHandle(point: IBoardConnectorPoint): IBoardConnectorAffordanceHandle | null;
+    isHit(coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+}

package/lib/types/render-objects/board-connector-endpoint-object.d.ts

@@ -0,0 +1,29 @@
+import type { IBoardConnectorEndpoint, IBoardConnectorPoint, IBoardThemeData } from '@univerjs-pro/boards';
+import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import type { IBoardConnectorLabelRect } from '../utils/board-connector-label.util';
+import { BaseObject } from '@univerjs/engine-render';
+export type BoardConnectorEndpointHandleSide = 'start' | 'end';
+export interface IBoardConnectorEndpointHandle {
+    connectorId: string;
+    endpoint: IBoardConnectorEndpoint;
+    point: IBoardConnectorPoint;
+    normal?: IBoardConnectorPoint;
+    side: BoardConnectorEndpointHandleSide;
+}
+export interface IBoardConnectorEndpointObjectState {
+    handles: IBoardConnectorEndpointHandle[];
+    labelObstacles: IBoardConnectorLabelRect[];
+    zoomRatio: number;
+    themeData?: IBoardThemeData;
+}
+export declare const BOARD_CONNECTOR_ENDPOINT_OBJECT_KEY = "board-connector-endpoint-object";
+export declare const BOARD_CONNECTOR_ENDPOINT_OBJECT_LAYER_INDEX: 6;
+export declare class BoardConnectorEndpointObject extends BaseObject {
+    private _state;
+    constructor(key?: string, state?: Partial<IBoardConnectorEndpointObjectState>);
+    updateState(state?: Partial<IBoardConnectorEndpointObjectState>): void;
+    private _isHandleBlocked;
+    getHitHandle(point: IBoardConnectorPoint): IBoardConnectorEndpointHandle | null;
+    isHit(coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+}

package/lib/types/render-objects/board-connector-object.d.ts

@@ -0,0 +1,58 @@
+import type { IBoardConnectorElement, IBoardConnectorPoint, IBoardElementData } from '@univerjs-pro/boards';
+import type { LocaleService } from '@univerjs/core';
+import type { IObjectFullState, IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import type { IBoardConnectorLabelRect } from '../utils/board-connector-label.util';
+import { BaseObject } from '@univerjs/engine-render';
+import { resolveBoardConnectorPathBounds, resolveBoardConnectorPathCommands, resolveBoardConnectorRoutePoints } from '../utils/board-connector-routing.util';
+export interface IBoardConnectorObjectProps {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    angle?: number;
+    zIndex?: number;
+    visible?: boolean;
+    evented?: boolean;
+    element: IBoardConnectorElement;
+    elementData?: Record<string, IBoardElementData>;
+    localeService?: LocaleService;
+}
+export interface IBoardConnectorRouteCache {
+    routePoints: ReturnType<typeof resolveBoardConnectorRoutePoints>;
+    pathCommands: ReturnType<typeof resolveBoardConnectorPathCommands>;
+    bounds: ReturnType<typeof resolveBoardConnectorPathBounds>;
+}
+export declare class BoardConnectorObject extends BaseObject {
+    private _element;
+    private _elementData?;
+    private readonly _localeService?;
+    private readonly _documentTextRenderCache;
+    private _routeCache;
+    private _routeStabilityHint;
+    private _isEditingLabel;
+    isDrawingObject: boolean;
+    constructor(key: string, props: IBoardConnectorObjectProps);
+    updateElement(element: IBoardConnectorElement, elementData?: Record<string, IBoardElementData>): void;
+    getElement(): IBoardConnectorElement;
+    setEditing(isEditing: boolean): void;
+    getRoutePoints(): IBoardConnectorPoint[];
+    getPathCommands(): import("../utils/board-connector-routing.util").BoardConnectorPathCommand[];
+    getLabelPathPoints(): IBoardConnectorPoint[];
+    getLabelRect(): IBoardConnectorLabelRect | null;
+    isLabelHit(point: IBoardConnectorPoint): boolean;
+    private _getRouteCache;
+    private _getRenderBounds;
+    private _getCurrentRouteStabilityHint;
+    private _shouldUseRouteStabilityHint;
+    transformByState(option: IObjectFullState): this;
+    isHit(coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+    private _drawRoute;
+    private _drawRoundedOrthogonalRoute;
+    private _drawRouteWithLineJumps;
+    private _resolveLineJumpsForSegment;
+    private _drawPathCommands;
+    private _drawMarkers;
+    private _resolveEndpointVisualGap;
+    private _drawLabel;
+}

package/lib/types/render-objects/board-connector-quick-connect-preview-object.d.ts

@@ -0,0 +1,22 @@
+import type { IBoardShapeElement, IBoardThemeData } from '@univerjs-pro/boards';
+import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import { BaseObject } from '@univerjs/engine-render';
+export interface IBoardConnectorQuickConnectShapePreviewObjectState {
+    element: IBoardShapeElement | null;
+    previewAlpha: number;
+    themeData?: IBoardThemeData;
+}
+export declare const BOARD_CONNECTOR_QUICK_CONNECT_SHAPE_PREVIEW_OBJECT_KEY = "board-connector-quick-connect-shape-preview-object";
+export declare const BOARD_CONNECTOR_QUICK_CONNECT_PREVIEW_LAYER_INDEX: 3;
+export declare const BOARD_CONNECTOR_QUICK_CONNECT_PREVIEW_ALPHA = 0.18;
+export declare class BoardConnectorQuickConnectShapePreviewObject extends BaseObject {
+    private _state;
+    private _shapeModel;
+    private _shapeElementId;
+    constructor(key?: string, state?: Partial<IBoardConnectorQuickConnectShapePreviewObjectState>);
+    updateState(state?: Partial<IBoardConnectorQuickConnectShapePreviewObjectState>): void;
+    isHit(_coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+    private _resolveShapeModel;
+    private _resolvePreviewAlpha;
+}

package/lib/types/render-objects/board-connector-snap-object.d.ts

@@ -0,0 +1,16 @@
+import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import type { IBoardConnectorSnapHighlight } from '../utils/board-connector-snap-highlight.util';
+import { BaseObject } from '@univerjs/engine-render';
+export interface IBoardConnectorSnapObjectState {
+    highlight: IBoardConnectorSnapHighlight | null;
+    zoomRatio: number;
+}
+export declare const BOARD_CONNECTOR_SNAP_OBJECT_KEY = "board-connector-snap-object";
+export declare const BOARD_CONNECTOR_SNAP_OBJECT_LAYER_INDEX: 7;
+export declare class BoardConnectorSnapObject extends BaseObject {
+    private _state;
+    constructor(key?: string, state?: Partial<IBoardConnectorSnapObjectState>);
+    updateState(state?: Partial<IBoardConnectorSnapObjectState>): void;
+    isHit(_coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+}

package/lib/types/render-objects/board-connector-waypoint-object.d.ts

@@ -0,0 +1,51 @@
+import type { IBoardConnectorPoint } from '@univerjs-pro/boards';
+import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import type { IBoardConnectorLabelRect } from '../utils/board-connector-label.util';
+import type { IBoardConnectorCurveAnchorHandle, IBoardConnectorEditableSegment, IBoardConnectorManualWaypointHandle } from '../utils/board-connector-waypoint.util';
+import { BaseObject } from '@univerjs/engine-render';
+export interface IBoardConnectorLabelSelection {
+    connectorId: string;
+    rect: IBoardConnectorLabelRect;
+}
+export interface IBoardConnectorLabelResizeHandle {
+    connectorId: string;
+    side: 'left' | 'right';
+    point: IBoardConnectorPoint;
+    rect: IBoardConnectorLabelRect;
+}
+export interface IBoardConnectorWaypointObjectState {
+    segments: IBoardConnectorEditableSegment[];
+    waypoints: IBoardConnectorManualWaypointHandle[];
+    curveAnchors: IBoardConnectorCurveAnchorHandle[];
+    labelObstacles: IBoardConnectorLabelRect[];
+    labelSelections: IBoardConnectorLabelSelection[];
+    focusedWaypoint: {
+        connectorId: string;
+        waypointId: string;
+    } | null;
+    focusedCurveAnchor: {
+        connectorId: string;
+        anchorId: string;
+    } | null;
+    zoomRatio: number;
+}
+export declare const BOARD_CONNECTOR_WAYPOINT_OBJECT_KEY = "board-connector-waypoint-object";
+export declare const BOARD_CONNECTOR_WAYPOINT_OBJECT_LAYER_INDEX: 6;
+export declare class BoardConnectorWaypointObject extends BaseObject {
+    private _state;
+    constructor(key?: string, state?: Partial<IBoardConnectorWaypointObjectState>);
+    updateState(state?: Partial<IBoardConnectorWaypointObjectState>): void;
+    private _getSegmentHandleRect;
+    private _isSegmentHandlePointBlocked;
+    private _isPointBlockedByLabel;
+    private _isWaypointHandleBlocked;
+    private _isCurveAnchorBlocked;
+    private _resolveSegmentHandlePoint;
+    private _getVisibleSegment;
+    getHitSegment(point: IBoardConnectorPoint): IBoardConnectorEditableSegment | null;
+    getHitCurveAnchor(point: IBoardConnectorPoint): IBoardConnectorCurveAnchorHandle | null;
+    getHitLabelResizeHandle(point: IBoardConnectorPoint): IBoardConnectorLabelResizeHandle | null;
+    getHitWaypoint(point: IBoardConnectorPoint): IBoardConnectorManualWaypointHandle | null;
+    isHit(coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+}

package/lib/types/render-objects/board-container-membership-object.d.ts

@@ -0,0 +1,19 @@
+import type { IBoardThemeData } from '@univerjs-pro/boards';
+import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import type { IBoardContainerMembershipOverlayItem } from '../utils/board-container-membership-overlay.util';
+import { BaseObject } from '@univerjs/engine-render';
+export interface IBoardContainerMembershipObjectState {
+    items: IBoardContainerMembershipOverlayItem[];
+    themeData?: IBoardThemeData;
+    zoomRatio?: number;
+}
+export declare const BOARD_CONTAINER_MEMBERSHIP_OBJECT_KEY = "board-container-membership-object";
+export declare const BOARD_CONTAINER_MEMBERSHIP_OBJECT_LAYER_INDEX: 4;
+export declare class BoardContainerMembershipObject extends BaseObject {
+    private _state;
+    constructor(key?: string, state?: Partial<IBoardContainerMembershipObjectState>);
+    updateState(state?: Partial<IBoardContainerMembershipObjectState>): void;
+    getOverlayState(): IBoardContainerMembershipObjectState;
+    isHit(_coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+}