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

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/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/plugin.d.ts

@@ -0,0 +1,21 @@
+import type { BoardToolbarToolConfig } from '@univerjs-pro/boards-ui';
+import type { IUniverBoardsMindUIConfig } from './config/config';
+import { IConfigService, Injector, Plugin, UniverInstanceType } from '@univerjs/core';
+import { IRenderManagerService } from '@univerjs/engine-render';
+export declare const BOARDS_MIND_UI_PLUGIN_NAME = "UNIVER_BOARDS_MIND_UI_PLUGIN";
+export declare class UniverBoardsMindUIPlugin extends Plugin {
+    private readonly _config;
+    protected readonly _injector: Injector;
+    private readonly _configService;
+    private readonly _renderManagerService;
+    static pluginName: string;
+    static packageName: string;
+    static version: string;
+    static type: UniverInstanceType;
+    constructor(_config: Partial<IUniverBoardsMindUIConfig> | undefined, _injector: Injector, _configService: IConfigService, _renderManagerService: IRenderManagerService);
+    onStarting(): void;
+    onReady(): void;
+    private _enableMindMapToolbarTool;
+    private _getBoardsUIConfig;
+}
+export declare function enableMindMapTool(config: BoardToolbarToolConfig | undefined): BoardToolbarToolConfig;

package/lib/types/render-objects/board-mind-map-drag-preview-object.d.ts

@@ -0,0 +1,36 @@
+import type { MindMapNodeSide } from '@univerjs-pro/boards-mind';
+import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import { BaseObject } from '@univerjs/engine-render';
+export interface IBoardMindMapDragPreviewBounds {
+    left?: number;
+    top?: number;
+    width?: number;
+    height?: number;
+}
+export interface IBoardMindMapDragPreviewObjectState {
+    ghostBounds: IBoardMindMapDragPreviewBounds | null;
+    sourceBounds?: IBoardMindMapDragPreviewBounds | null;
+    parentBounds?: IBoardMindMapDragPreviewBounds | null;
+    side?: MindMapNodeSide;
+    zoomRatio?: number;
+    textStyle?: IBoardMindMapDragPreviewTextStyle;
+    renderGhostNode?: boolean;
+}
+export interface IBoardMindMapDragPreviewTextStyle {
+    text?: string;
+    fontSize?: number;
+    color?: string;
+    horizontalAlign?: number;
+}
+export declare const BOARD_MIND_MAP_DRAG_PREVIEW_OBJECT_KEY = "board-mind-map-drag-preview-object";
+export declare const BOARD_MIND_MAP_DRAG_PREVIEW_OBJECT_LAYER_INDEX: 3;
+export declare class BoardMindMapDragPreviewObject extends BaseObject {
+    private _state;
+    constructor(key?: string, state?: Partial<IBoardMindMapDragPreviewObjectState>);
+    updateState(state?: Partial<IBoardMindMapDragPreviewObjectState>): void;
+    isHit(_coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+    private _resolveDirtyBounds;
+    private _drawSourceHighlight;
+    private _drawConnectorPreview;
+}

package/lib/types/render-objects/board-mind-map-node-controls-object.d.ts

@@ -0,0 +1,22 @@
+import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import type { IMindMapNodeControl } from '../utils/mind-map-node-controls.util';
+import { BaseObject } from '@univerjs/engine-render';
+export interface IBoardMindMapNodeControlsObjectState {
+    controls: IMindMapNodeControl[];
+    hoveredControl?: IMindMapNodeControl | null;
+    zoomRatio: number;
+}
+export declare const BOARD_MIND_MAP_NODE_CONTROLS_OBJECT_KEY = "board-mind-map-node-controls-object";
+export declare const BOARD_MIND_MAP_NODE_CONTROLS_OBJECT_LAYER_INDEX: 5;
+export declare class BoardMindMapNodeControlsObject extends BaseObject {
+    private _state;
+    constructor(key?: string, state?: Partial<IBoardMindMapNodeControlsObjectState>);
+    updateState(state?: Partial<IBoardMindMapNodeControlsObjectState>): void;
+    setHoveredControl(control: IMindMapNodeControl | null): void;
+    getHitControl(point: {
+        x: number;
+        y: number;
+    }): IMindMapNodeControl | null;
+    isHit(coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+}

package/lib/types/render-objects/board-mind-map-pending-insert-object.d.ts

@@ -0,0 +1,22 @@
+import type { IMindMapChildBlueprint, IMindMapTreeBlueprint, MindMapStructureKind } from '@univerjs-pro/boards-mind';
+import type { IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import { BaseObject } from '@univerjs/engine-render';
+export interface IBoardMindMapPendingInsertObjectState {
+    point: {
+        x: number;
+        y: number;
+    } | null;
+    structureKind?: MindMapStructureKind;
+    children?: IMindMapChildBlueprint[];
+    blueprint?: IMindMapTreeBlueprint;
+    zoomRatio?: number;
+}
+export declare const BOARD_MIND_MAP_PENDING_INSERT_OBJECT_KEY = "board-mind-map-pending-insert-object";
+export declare const BOARD_MIND_MAP_PENDING_INSERT_OBJECT_LAYER_INDEX: 3;
+export declare class BoardMindMapPendingInsertObject extends BaseObject {
+    private _state;
+    constructor(key?: string, state?: Partial<IBoardMindMapPendingInsertObjectState>);
+    updateState(state?: Partial<IBoardMindMapPendingInsertObjectState>): void;
+    isHit(_coord: Vector2): boolean;
+    render(ctx: UniverRenderingContext, _bounds: IViewportInfo): this;
+}

package/lib/types/services/board-mind-map-insert-state.service.d.ts

@@ -0,0 +1,19 @@
+import type { IMindMapChildBlueprint, IMindMapTreeBlueprint, MindMapBranchLineType, MindMapStructureKind } from '@univerjs-pro/boards-mind';
+import { Disposable } from '@univerjs/core';
+export interface IBoardMindMapInsertTemplate {
+    rootText?: string;
+    structureKind?: MindMapStructureKind;
+    branchLineType?: MindMapBranchLineType;
+    children?: IMindMapChildBlueprint[];
+    blueprint?: IMindMapTreeBlueprint;
+}
+export declare const DEFAULT_BOARD_MIND_MAP_INSERT_TEMPLATE: IBoardMindMapInsertTemplate;
+export declare class BoardMindMapInsertStateService extends Disposable {
+    private _template;
+    setTemplate(template?: IBoardMindMapInsertTemplate): void;
+    getTemplate(): IBoardMindMapInsertTemplate;
+    private _cloneBlueprint;
+    private _cloneBlueprintNode;
+    private _normalizeChildren;
+    private _resolveChildSide;
+}

package/lib/types/services/board-mind-map-preview-refresh.service.d.ts

@@ -0,0 +1,13 @@
+import { Disposable } from '@univerjs/core';
+export interface IBoardMindMapPreviewRefreshEvent {
+    nodeId: string;
+    scopeId: string;
+    subUnitId: string;
+    unitId: string;
+}
+export declare class BoardMindMapPreviewRefreshService extends Disposable {
+    private readonly _refresh$;
+    readonly refresh$: import("rxjs").Observable<IBoardMindMapPreviewRefreshEvent>;
+    notify(event: IBoardMindMapPreviewRefreshEvent): void;
+    dispose(): void;
+}

package/lib/types/services/board-mind-map-ui-adapter.service.d.ts

@@ -0,0 +1,9 @@
+import type { IBeginBoardMindMapOperationParams, IBoardMindMapAdapter } from '@univerjs-pro/boards';
+import { IBoardUIStateService } from '@univerjs-pro/boards-ui';
+import { BoardMindMapInsertStateService } from './board-mind-map-insert-state.service';
+export declare class BoardMindMapUIAdapter implements IBoardMindMapAdapter {
+    private readonly _stateService;
+    private readonly _insertStateService;
+    constructor(_stateService: IBoardUIStateService, _insertStateService: BoardMindMapInsertStateService);
+    beginMindMapMode(params: IBeginBoardMindMapOperationParams): boolean;
+}

package/lib/types/utils/mind-map-canvas-tokens.util.d.ts

@@ -0,0 +1,6 @@
+export declare const BOARD_MIND_MAP_CANVAS_TOKENS: {
+    readonly primaryColor: "#2563EB";
+    readonly surfaceColor: "#ffffff";
+    readonly textColor: "#111827";
+    readonly fontFamily: string;
+};

package/lib/types/utils/mind-map-drag-topology.util.d.ts

@@ -0,0 +1,26 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+import type { MindMapNodeSide } from '@univerjs-pro/boards-mind';
+export type MindMapDragTopologyAction = {
+    kind: 'none';
+} | {
+    kind: 'detach';
+    left?: number;
+    top?: number;
+} | {
+    kind: 'reparent';
+    newParentNodeId: string;
+    side: MindMapNodeSide;
+    referenceNodeId?: string;
+    placement?: 'before' | 'after';
+};
+export interface IMindMapDragTopologyBounds {
+    left?: number;
+    top?: number;
+    width?: number;
+    height?: number;
+}
+export declare function resolveMindMapDragTopologyAction(elementData: Record<string, IBoardElementData>, nodeId: string, options?: {
+    boundsByElementId?: Readonly<Record<string, IMindMapDragTopologyBounds | undefined>>;
+    detachWhenNoSnap?: boolean;
+    allowRootReparent?: boolean;
+}): MindMapDragTopologyAction;

package/lib/types/utils/mind-map-node-controls.util.d.ts

@@ -0,0 +1,46 @@
+export type MindMapNodeControlKind = 'add-child-left' | 'add-child-right' | 'add-child-top' | 'add-child-bottom' | 'add-sibling-before' | 'add-sibling-after' | 'toggle-collapse';
+export interface IMindMapNodeControlBounds {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface IResolveMindMapNodeControlLayoutOptions {
+    bounds: IMindMapNodeControlBounds;
+    isRoot: boolean;
+    side: 'left' | 'right' | 'top' | 'bottom';
+    rootChildSides?: Array<'left' | 'right' | 'top' | 'bottom'>;
+    hasChildren: boolean;
+    collapsedDescendantCount: number;
+    zoomRatio: number;
+}
+export interface IMindMapNodeControl {
+    kind: MindMapNodeControlKind;
+    x: number;
+    y: number;
+    radius: number;
+    visualRadius?: number;
+    placement?: 'before' | 'after';
+    badgeCount?: number;
+}
+export declare const BOARD_MIND_MAP_NODE_CONTROL_TOKENS: {
+    readonly radiusScreen: 18;
+    readonly addChildRadiusScreen: 14;
+    readonly siblingHoverRadiusScreen: 10;
+    readonly siblingDotRadiusScreen: 5;
+    readonly siblingDotGapScreen: 3;
+    readonly gapScreen: 10;
+    readonly collapsePlusMinDistanceScreen: 44;
+    readonly primaryColor: "#2563EB";
+    readonly surfaceColor: "#ffffff";
+    readonly borderWidthScreen: 2;
+    readonly glyphSizeScreen: 8;
+    readonly addChildGlyphSizeScreen: 6;
+    readonly siblingGlyphSizeScreen: 5.5;
+    readonly glyphWidthScreen: 2.4;
+    readonly glyphHoverWidthScreen: 3;
+    readonly badgeFontWeight: 600;
+    readonly badgeFontSizeScreen: 18;
+    readonly fontFamily: string;
+};
+export declare function resolveMindMapNodeControlLayout(options: IResolveMindMapNodeControlLayoutOptions): IMindMapNodeControl[];

package/lib/types/utils/mind-map-preview-tokens.util.d.ts

@@ -0,0 +1,29 @@
+import type { UniverRenderingContext } from '@univerjs/engine-render';
+export declare function resolveMindMapPreviewTokenAlpha(color: string, alpha: number): string;
+export declare const BOARD_MIND_MAP_PREVIEW_TOKENS: {
+    readonly primaryColor: "#2563EB";
+    readonly ghostFillColor: string;
+    readonly ghostTextColor: string;
+    readonly rootTextColor: string;
+    readonly sourceHighlightFillColor: string;
+    readonly sourceHighlightStrokeColor: string;
+    readonly objectAlpha: 0.72;
+    readonly dragObjectAlpha: 0.78;
+    readonly connectorAlpha: 0.64;
+    readonly lineWidthScreen: 2;
+    readonly fallbackNodeWidth: 160;
+    readonly fallbackNodeHeight: 48;
+    readonly branchGap: 40;
+    readonly sourceHaloScreen: 4;
+    readonly ghostRadius: 8;
+    readonly rootRadius: 10;
+    readonly fontFamily: string;
+    readonly ghostFontWeight: 500;
+    readonly rootFontWeight: 600;
+    readonly rootFontSize: 18;
+    readonly textPaddingScreen: 12;
+    readonly dirtyPaddingScreen: 24;
+    readonly sourceDashScreen: readonly [6, 4];
+};
+export declare function drawMindMapPreviewRoundedRect(ctx: UniverRenderingContext, left: number, top: number, width: number, height: number, radius: number): void;
+export declare function resolveMindMapPreviewFont(weight: number, fontSize: number, zoomRatio: number): string;

package/lib/types/utils/mind-map-scope-preview.util.d.ts

@@ -0,0 +1,29 @@
+import type { IBoardConnectorElement, IBoardElementData } from '@univerjs-pro/boards';
+import { resolveBoardElementWorldBounds } from '@univerjs-pro/boards';
+export interface IMindMapRootScopePreviewBounds {
+    left: number;
+    top: number;
+}
+export interface IResolveMindMapRootScopePreviewOptions {
+    elementData: Record<string, IBoardElementData>;
+    scopeId: string;
+    rootNodeId: string;
+    rootStartBounds: IMindMapRootScopePreviewBounds;
+    liveRootBounds: IMindMapRootScopePreviewBounds;
+}
+export type MindMapRootScopePreviewItem = {
+    kind: 'bounds';
+    elementId: string;
+    bounds: NonNullable<ReturnType<typeof resolveBoardElementWorldBounds>>;
+} | {
+    kind: 'connector';
+    elementId: string;
+    element: IBoardConnectorElement;
+};
+export interface IMindMapRootScopePreview {
+    deltaX: number;
+    deltaY: number;
+    elementData: Record<string, IBoardElementData>;
+    items: MindMapRootScopePreviewItem[];
+}
+export declare function resolveMindMapRootScopePreview(options: IResolveMindMapRootScopePreviewOptions): IMindMapRootScopePreview | null;

package/lib/types/views/BoardMindMapDescriptionDialog.d.ts

@@ -0,0 +1,10 @@
+export declare const BOARD_MIND_MAP_DESCRIPTION_DIALOG_KEY = "board.mind-map.description-dialog";
+export declare const BOARD_MIND_MAP_DESCRIPTION_DIALOG_ID = "board-mind-map-description-dialog";
+export declare const BOARD_MIND_MAP_DESCRIPTION_DIALOG_WIDTH = 420;
+export interface IBoardMindMapDescriptionDialogProps {
+    unitId: string;
+    subUnitId: string;
+    nodeId: string;
+    initialDescription?: string;
+}
+export declare function BoardMindMapDescriptionDialog(props: IBoardMindMapDescriptionDialogProps): import("react").JSX.Element;

package/lib/types/views/BoardMindMapFloatingToolbar.d.ts

@@ -0,0 +1,147 @@
+import type { IBoardConnectorStyle } from '@univerjs-pro/boards';
+import type { IMindMapContainerData, IUpdateMindMapNodeOperationParams, MindMapBranchLineType, MindMapStructureKind } from '@univerjs-pro/boards-mind';
+import type { IShapeData } from '@univerjs-pro/engine-shape';
+import type { IShapeTextUpdateOptions } from '@univerjs-pro/shape-editor-ui';
+import type { ITextStyle } from '@univerjs/core';
+import type { MindMapKeyboardShortcutAction } from '../controllers/board-mind-map-keyboard-shortcut.controller';
+import type { LocaleKey } from '../locale/types';
+import { HorizontalAlign, ICommandService, VerticalAlign } from '@univerjs/core';
+import { IShortcutService } from '@univerjs/ui';
+export declare const BOARD_MIND_MAP_FLOATING_TOOLBAR_KEY = "board.mind-map.floating-toolbar";
+export declare const BOARD_MIND_MAP_LINE_WIDTH_RANGE: {
+    min: number;
+    max: number;
+    defaultValue: number;
+};
+export declare const BOARD_MIND_MAP_LINE_OPACITY_RANGE: {
+    min: number;
+    max: number;
+    defaultValue: number;
+};
+export type BoardMindMapLineType = 'solid' | 'dash' | 'dot';
+export type BoardMindMapFloatingToolbarPanel = 'line' | 'more';
+export type BoardMindMapFloatingToolbarPrimaryItem = {
+    kind: 'dropdown';
+    titleKey: LocaleKey;
+    panel: BoardMindMapFloatingToolbarPanel;
+    dividerBefore?: boolean;
+} | {
+    kind: 'fontColor';
+    titleKey: LocaleKey;
+    dividerBefore?: boolean;
+} | {
+    kind: 'typography';
+    titleKey: LocaleKey;
+    dividerBefore?: boolean;
+};
+export declare const BOARD_MIND_MAP_FLOATING_TOOLBAR_PRIMARY_ITEMS: BoardMindMapFloatingToolbarPrimaryItem[];
+export declare const BOARD_MIND_MAP_FLOATING_TOOLBAR_PANELS: {
+    line: {
+        sections: readonly ["type", "width", "color", "opacity"];
+    };
+    more: {
+        actionKeys: readonly ["addSibling", "addChild", "copy", "paste", "delete"];
+    };
+};
+export declare const BOARD_MIND_MAP_MORE_ACTION_SHORTCUTS: {
+    readonly addSibling: "add-sibling-or-child";
+    readonly addChild: "add-child";
+    readonly copy: "copy";
+    readonly paste: "paste";
+    readonly delete: "delete";
+};
+export type BoardMindMapFloatingToolbarLayoutIcon = MindMapStructureKind | 'branch-curve' | 'branch-rounded-orthogonal' | 'branch-orthogonal';
+export declare const BOARD_MIND_MAP_FLOATING_TOOLBAR_LAYOUT_GROUPS: readonly [{
+    readonly key: "mind-map";
+    readonly title: "Mind map";
+    readonly items: readonly [{
+        readonly value: "mindmap-horizontal";
+        readonly icon: "mindmap-horizontal";
+    }, {
+        readonly value: "mindmap-vertical";
+        readonly icon: "mindmap-vertical";
+    }];
+}, {
+    readonly key: "tree-diagram";
+    readonly title: "Tree diagram";
+    readonly items: readonly [{
+        readonly value: "tree-right";
+        readonly icon: "tree-right";
+    }, {
+        readonly value: "tree-left";
+        readonly icon: "tree-left";
+    }, {
+        readonly value: "tree-alternate";
+        readonly icon: "tree-alternate";
+    }];
+}, {
+    readonly key: "timeline";
+    readonly title: "Timeline";
+    readonly items: readonly [{
+        readonly value: "timeline-horizontal";
+        readonly icon: "timeline-horizontal";
+    }, {
+        readonly value: "timeline-vertical";
+        readonly icon: "timeline-vertical";
+    }];
+}];
+export declare const BOARD_MIND_MAP_FLOATING_TOOLBAR_BRANCH_GROUP: {
+    readonly key: "branch";
+    readonly title: "Branch";
+    readonly items: readonly [{
+        readonly value: "curve";
+        readonly icon: "branch-curve";
+    }, {
+        readonly value: "rounded-orthogonal";
+        readonly icon: "branch-rounded-orthogonal";
+    }, {
+        readonly value: "orthogonal";
+        readonly icon: "branch-orthogonal";
+    }];
+};
+interface IBoardMindMapFloatingToolbarExtraProps {
+    unitId: string;
+    subUnitId: string;
+    elementId: string;
+    scopeId: string;
+    isRootNode?: boolean;
+    left?: number;
+    top?: number;
+    shapeData?: IShapeData;
+    incomingConnectorStyle?: IBoardConnectorStyle;
+    layout?: IMindMapContainerData['layout'];
+}
+interface IBoardMindMapFloatingToolbarProps {
+    popup: {
+        extraProps?: IBoardMindMapFloatingToolbarExtraProps;
+    };
+}
+export declare function executeMindMapToolbarShortcut(commandService: ICommandService, action: MindMapKeyboardShortcutAction): void;
+export declare function resolveMindMapToolbarTextState(shapeData: IShapeData | undefined): {
+    color: string;
+    fontSize: number;
+    horizontalAlign: HorizontalAlign;
+    textFill?: ITextStyle['textFill'];
+    verticalAlign: VerticalAlign;
+};
+export declare function resolveMindMapShortcutDisplay(shortcutService: Pick<IShortcutService, 'getShortcutDisplay'>, action?: MindMapKeyboardShortcutAction): string | undefined;
+export declare function handleMindMapToolbarStructureKindChange(commandService: ICommandService, params: {
+    unitId: string;
+    subUnitId: string;
+    scopeId: string;
+    structureKind: MindMapStructureKind;
+    branchLineType?: MindMapBranchLineType;
+}): Promise<boolean>;
+export declare function handleMindMapToolbarBranchLineTypeChange(commandService: ICommandService, params: {
+    unitId: string;
+    subUnitId: string;
+    scopeId: string;
+    branchLineType: MindMapBranchLineType;
+}): Promise<boolean>;
+export declare function handleMindMapToolbarTextUpdate(params: IShapeTextUpdateOptions, updateNode: (params: {
+    textStyle: NonNullable<IUpdateMindMapNodeOperationParams['textStyle']>;
+}) => void): void;
+export declare function handleMindMapToolbarLineUpdate(shapeData: IShapeData | undefined, updateLine: (style: Record<string, unknown>) => void): void;
+export declare function resolveMindMapLineShapeData(incomingConnectorStyle: IBoardConnectorStyle | undefined): IShapeData;
+export declare function BoardMindMapFloatingToolbar(props: IBoardMindMapFloatingToolbarProps): import("react").JSX.Element | null;
+export {};

package/lib/types/views/BoardMindMapPanel.d.ts

@@ -0,0 +1,127 @@
+import type { IBoardElementData } from '@univerjs-pro/boards';
+import type { IMindMapContainerData, MindMapBranchLineType, MindMapLayoutDirection, MindMapStructureKind } from '@univerjs-pro/boards-mind';
+import type { CSSProperties, ReactNode } from 'react';
+import type { LocaleKey } from '../locale/types';
+import { ICommandService } from '@univerjs/core';
+export declare const BOARD_MIND_MAP_PANEL_KEY = "board.mind-map.panel";
+export declare const BOARD_MIND_MAP_PANEL_SIDEBAR_WIDTH = 388;
+export declare const BOARD_MIND_MAP_PANEL_TABS: readonly ["structure", "layout", "importExport"];
+export type BoardMindMapPanelTab = typeof BOARD_MIND_MAP_PANEL_TABS[number];
+export type BoardMindMapPanelSpacingKey = 'horizontalGap' | 'siblingGap' | 'branchGap';
+export declare const BOARD_MIND_MAP_PANEL_DEFAULT_SPACING: Record<BoardMindMapPanelSpacingKey, number>;
+export declare const BOARD_MIND_MAP_PANEL_SPACING_CONTROLS: Array<{
+    labelKey: LocaleKey;
+    key: BoardMindMapPanelSpacingKey;
+    min: number;
+    max: number;
+}>;
+export declare const BOARD_MIND_MAP_PANEL_LAYOUT_DIRECTION_ITEMS: Array<{
+    labelKey: LocaleKey;
+    value: MindMapLayoutDirection;
+}>;
+export declare const BOARD_MIND_MAP_PANEL_STRUCTURE_ITEMS: Array<{
+    labelKey: LocaleKey;
+    value: MindMapStructureKind;
+}>;
+export declare const BOARD_MIND_MAP_PANEL_BRANCH_LINE_ITEMS: Array<{
+    labelKey: LocaleKey;
+    value: MindMapBranchLineType;
+}>;
+export interface IBoardMindMapPanelOutlineItem {
+    nodeId: string;
+    depth: number;
+    text: string;
+}
+export interface IBoardMindMapPanelProps {
+    unitId: string;
+    subUnitId: string;
+    scopeId: string;
+    nodeId?: string;
+    outlineItems?: IBoardMindMapPanelOutlineItem[];
+    layout?: IMindMapContainerData['layout'];
+}
+export declare function resolveMindMapPanelLayoutState(layout?: IMindMapContainerData['layout']): {
+    spacing: {
+        horizontalGap: number;
+        siblingGap: number;
+        branchGap: number;
+    };
+    direction: MindMapLayoutDirection;
+    structureKind: MindMapStructureKind;
+    branchLineType: MindMapBranchLineType;
+};
+export declare function handleMindMapPanelLayoutChange(commandService: ICommandService, params: {
+    unitId: string;
+    subUnitId: string;
+    scopeId: string;
+    direction?: MindMapLayoutDirection;
+    structureKind?: MindMapStructureKind;
+    branchLineType?: MindMapBranchLineType;
+}): Promise<boolean>;
+export declare function handleMindMapPanelLineTypeChange(commandService: ICommandService, params: {
+    unitId: string;
+    subUnitId: string;
+    scopeId: string;
+    branchLineType: MindMapBranchLineType;
+}): Promise<boolean>;
+export declare function handleMindMapPanelSpacingChange(commandService: ICommandService, params: {
+    unitId: string;
+    subUnitId: string;
+    scopeId: string;
+    horizontalGap?: number;
+    siblingGap?: number;
+    branchGap?: number;
+}): Promise<boolean>;
+export declare function handleMindMapPanelReorderNode(commandService: ICommandService, params: {
+    unitId: string;
+    subUnitId: string;
+    scopeId: string;
+    nodeId: string;
+    targetNodeId: string;
+    placement: 'before' | 'after';
+}): Promise<boolean>;
+export declare function handleMindMapPanelRenameNode(commandService: ICommandService, params: {
+    unitId: string;
+    subUnitId: string;
+    scopeId: string;
+    nodeId: string;
+    text: string;
+}): Promise<boolean>;
+export declare function writeMindMapPanelClipboardText(content: string): Promise<boolean>;
+export declare function handleMindMapPanelExportOpml(commandService: ICommandService, params: {
+    unitId: string;
+    subUnitId: string;
+    scopeId: string;
+}, writeText?: (content: string) => Promise<boolean | void>): Promise<boolean>;
+export declare function handleMindMapPanelImportOpml(commandService: ICommandService, params: {
+    unitId: string;
+    subUnitId: string;
+    left: number;
+    top: number;
+    opml: string;
+}): Promise<boolean>;
+export declare function collectMindMapPanelOutlineItems(elementData: Record<string, IBoardElementData>, scopeId: string, fallbackText?: string): IBoardMindMapPanelOutlineItem[];
+export declare function filterMindMapPanelOutlineItems(outlineItems: IBoardMindMapPanelOutlineItem[], query: string): IBoardMindMapPanelOutlineItem[];
+export declare function resolveMindMapPanelOutlineIndent(depth: number): CSSProperties;
+export declare function BoardMindMapPanelShell(props: {
+    children?: ReactNode;
+}): import("react").JSX.Element;
+export declare function BoardMindMapPanelTabs(props: {
+    items: Array<{
+        label: string;
+        value: BoardMindMapPanelTab;
+    }>;
+    value: BoardMindMapPanelTab;
+    onChange: (tab: BoardMindMapPanelTab) => void;
+}): import("react").JSX.Element;
+export declare function BoardMindMapPanelSection(props: {
+    titleKey: LocaleKey;
+    children?: ReactNode;
+}): import("react").JSX.Element;
+export declare function BoardMindMapPanelEmptyState(props: {
+    children?: ReactNode;
+}): import("react").JSX.Element;
+export declare function BoardMindMapPanelOutlineRenameButton(props: {
+    onClick: () => void;
+}): import("react").JSX.Element;
+export declare function BoardMindMapPanel(props: IBoardMindMapPanelProps): import("react").JSX.Element;