blockly 12.4.0 → 12.5.0

package/core/bubbles/bubble.d.ts

@@ -0,0 +1,228 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { IBubble } from '../interfaces/i_bubble.js';
+import type { IFocusableNode } from '../interfaces/i_focusable_node.js';
+import type { IFocusableTree } from '../interfaces/i_focusable_tree.js';
+import type { IHasBubble } from '../interfaces/i_has_bubble.js';
+import { ISelectable } from '../interfaces/i_selectable.js';
+import { Coordinate } from '../utils/coordinate.js';
+import { Rect } from '../utils/rect.js';
+import { Size } from '../utils/size.js';
+import { WorkspaceSvg } from '../workspace_svg.js';
+/**
+ * The abstract pop-up bubble class. This creates a UI that looks like a speech
+ * bubble, where it has a "tail" that points to the block, and a "head" that
+ * displays arbitrary svg elements.
+ */
+export declare abstract class Bubble implements IBubble, ISelectable, IFocusableNode {
+    readonly workspace: WorkspaceSvg;
+    protected anchor: Coordinate;
+    protected ownerRect?: Rect | undefined;
+    protected owner?: (IHasBubble & IFocusableNode) | undefined;
+    /** The width of the border around the bubble. */
+    static readonly BORDER_WIDTH = 6;
+    /** Double the width of the border around the bubble. */
+    static readonly DOUBLE_BORDER: number;
+    /** The minimum size the bubble can have. */
+    static readonly MIN_SIZE: number;
+    /**
+     * The thickness of the base of the tail in relation to the size of the
+     * bubble. Higher numbers result in thinner tails.
+     */
+    static readonly TAIL_THICKNESS = 1;
+    /** The number of degrees that the tail bends counter-clockwise. */
+    static readonly TAIL_ANGLE = 20;
+    /**
+     * The sharpness of the tail's bend. Higher numbers result in smoother
+     * tails.
+     */
+    static readonly TAIL_BEND = 4;
+    /** Distance between arrow point and anchor point. */
+    static readonly ANCHOR_RADIUS = 8;
+    id: string;
+    /** The SVG group containing all parts of the bubble. */
+    protected svgRoot: SVGGElement;
+    /** The SVG path for the arrow from the anchor to the bubble. */
+    private tail;
+    /** The SVG background rect for the main body of the bubble. */
+    private background;
+    /** The SVG group containing the contents of the bubble. */
+    protected contentContainer: SVGGElement;
+    /**
+     * The size of the bubble (including background and contents but not tail).
+     */
+    private size;
+    /** The colour of the background of the bubble. */
+    private colour;
+    /** True if the bubble has been disposed, false otherwise. */
+    disposed: boolean;
+    /** The position of the top of the bubble relative to its anchor. */
+    private relativeTop;
+    /** The position of the left of the bubble realtive to its anchor. */
+    private relativeLeft;
+    private dragStrategy;
+    private focusableElement;
+    /**
+     * @param workspace The workspace this bubble belongs to.
+     * @param anchor The anchor location of the thing this bubble is attached to.
+     *     The tail of the bubble will point to this location.
+     * @param ownerRect An optional rect we don't want the bubble to overlap with
+     *     when automatically positioning.
+     * @param overriddenFocusableElement An optional replacement to the focusable
+     *     element that's represented by this bubble (as a focusable node). This
+     *     element will have its ID overwritten. If not provided, the focusable
+     *     element of this node will default to the bubble's SVG root.
+     * @param owner The object responsible for hosting/spawning this bubble.
+     */
+    constructor(workspace: WorkspaceSvg, anchor: Coordinate, ownerRect?: Rect | undefined, overriddenFocusableElement?: SVGElement | HTMLElement, owner?: (IHasBubble & IFocusableNode) | undefined);
+    /** Dispose of this bubble. */
+    dispose(): void;
+    /**
+     * Set the location the tail of this bubble points to.
+     *
+     * @param anchor The location the tail of this bubble points to.
+     * @param relayout If true, reposition the bubble from scratch so that it is
+     *     optimally visible. If false, reposition it so it maintains the same
+     *     position relative to the anchor.
+     */
+    setAnchorLocation(anchor: Coordinate, relayout?: boolean): void;
+    /** Sets the position of this bubble relative to its anchor. */
+    setPositionRelativeToAnchor(left: number, top: number): void;
+    /** @returns the size of this bubble. */
+    protected getSize(): Size;
+    /**
+     * Sets the size of this bubble, including the border.
+     *
+     * @param size Sets the size of this bubble, including the border.
+     * @param relayout If true, reposition the bubble from scratch so that it is
+     *     optimally visible. If false, reposition it so it maintains the same
+     *     position relative to the anchor.
+     */
+    protected setSize(size: Size, relayout?: boolean): void;
+    /** Returns the colour of the background and tail of this bubble. */
+    protected getColour(): string;
+    /** Sets the colour of the background and tail of this bubble. */
+    setColour(colour: string): void;
+    /**
+     * Passes the pointer event off to the gesture system and ensures the bubble
+     * is focused.
+     */
+    private onMouseDown;
+    /**
+     * Handles key events when this bubble is focused. By default, closes the
+     * bubble on Escape.
+     *
+     * @param e The keyboard event to handle.
+     */
+    protected onKeyDown(e: KeyboardEvent): void;
+    /** Positions the bubble relative to its anchor. Does not render its tail. */
+    protected positionRelativeToAnchor(): void;
+    /**
+     * Moves the bubble to the given coordinates.
+     *
+     * @internal
+     */
+    moveTo(x: number, y: number): void;
+    /**
+     * Positions the bubble "optimally" so that the most of it is visible and
+     * it does not overlap the rect (if provided).
+     */
+    protected positionByRect(rect?: Rect): void;
+    /**
+     * Calculate the what percentage of the bubble overlaps with the visible
+     * workspace (what percentage of the bubble is visible).
+     *
+     * @param relativeMin The position of the top-left corner of the bubble
+     *     relative to the anchor point.
+     * @param viewMetrics The view metrics of the workspace the bubble will appear
+     *     in.
+     * @returns The percentage of the bubble that is visible.
+     */
+    private getOverlap;
+    /**
+     * Calculate what the optimal horizontal position of the top-left corner of
+     * the bubble is (relative to the anchor point) so that the most area of the
+     * bubble is shown.
+     *
+     * @param viewMetrics The view metrics of the workspace the bubble will appear
+     *     in.
+     * @returns The optimal horizontal position of the top-left corner of the
+     *     bubble.
+     */
+    private getOptimalRelativeLeft;
+    /**
+     * Calculate what the optimal vertical position of the top-left corner of
+     * the bubble is (relative to the anchor point) so that the most area of the
+     * bubble is shown.
+     *
+     * @param viewMetrics The view metrics of the workspace the bubble will appear
+     *     in.
+     * @returns The optimal vertical position of the top-left corner of the
+     *     bubble.
+     */
+    private getOptimalRelativeTop;
+    /**
+     * @returns a rect defining the bounds of the workspace's view in workspace
+     * coordinates.
+     */
+    private getWorkspaceViewRect;
+    /** @returns the scrollbar thickness in workspace units. */
+    private getScrollbarThickness;
+    /** Draws the tail of the bubble. */
+    private renderTail;
+    /**
+     * Move this bubble to the front of the visible workspace.
+     *
+     * @returns Whether or not the bubble has been moved.
+     * @internal
+     */
+    bringToFront(): boolean;
+    /** @internal */
+    getRelativeToSurfaceXY(): Coordinate;
+    /** @internal */
+    getSvgRoot(): SVGElement;
+    /**
+     * Move this bubble during a drag.
+     *
+     * @param newLoc The location to translate to, in workspace coordinates.
+     * @internal
+     */
+    moveDuringDrag(newLoc: Coordinate): void;
+    setDragging(_start: boolean): void;
+    /** @internal */
+    setDeleteStyle(_enable: boolean): void;
+    /** @internal */
+    isDeletable(): boolean;
+    /** @internal */
+    showContextMenu(_e: Event): void;
+    /** Returns whether this bubble is movable or not. */
+    isMovable(): boolean;
+    /** Starts a drag on the bubble. */
+    startDrag(): void;
+    /** Drags the bubble to the given location. */
+    drag(newLoc: Coordinate): void;
+    /** Ends the drag on the bubble. */
+    endDrag(): void;
+    /** Moves the bubble back to where it was at the start of a drag. */
+    revertDrag(): void;
+    select(): void;
+    unselect(): void;
+    /** See IFocusableNode.getFocusableElement. */
+    getFocusableElement(): HTMLElement | SVGElement;
+    /** See IFocusableNode.getFocusableTree. */
+    getFocusableTree(): IFocusableTree;
+    /** See IFocusableNode.onNodeFocus. */
+    onNodeFocus(): void;
+    /** See IFocusableNode.onNodeBlur. */
+    onNodeBlur(): void;
+    /** See IFocusableNode.canBeFocused. */
+    canBeFocused(): boolean;
+    /**
+     * Returns the object that owns/hosts this bubble, if any.
+     */
+    getOwner(): (IHasBubble & IFocusableNode) | undefined;
+}
+//# sourceMappingURL=bubble.d.ts.map

package/core/bubbles/mini_workspace_bubble.d.ts

@@ -0,0 +1,84 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { BlocklyOptions } from '../blockly_options.js';
+import { Abstract as AbstractEvent } from '../events/events_abstract.js';
+import { Options } from '../options.js';
+import { Coordinate } from '../utils/coordinate.js';
+import type { Rect } from '../utils/rect.js';
+import type { WorkspaceSvg } from '../workspace_svg.js';
+import { Bubble } from './bubble.js';
+/**
+ * A bubble that contains a mini-workspace which can hold arbitrary blocks.
+ * Used by the mutator icon.
+ */
+export declare class MiniWorkspaceBubble extends Bubble {
+    readonly workspace: WorkspaceSvg;
+    protected anchor: Coordinate;
+    protected ownerRect?: Rect | undefined;
+    /**
+     * The minimum amount of change to the mini workspace view to trigger
+     * resizing the bubble.
+     */
+    private static readonly MINIMUM_VIEW_CHANGE;
+    /**
+     * An arbitrary margin of whitespace to put around the blocks in the
+     * workspace.
+     */
+    private static readonly MARGIN;
+    /** The root svg element containing the workspace. */
+    private svgDialog;
+    /** The workspace that gets shown within this bubble. */
+    private miniWorkspace;
+    /**
+     * Should this bubble automatically reposition itself when it resizes?
+     * Becomes false after this bubble is first dragged.
+     */
+    private autoLayout;
+    /** @internal */
+    constructor(workspaceOptions: BlocklyOptions, workspace: WorkspaceSvg, anchor: Coordinate, ownerRect?: Rect | undefined);
+    dispose(): void;
+    /** @internal */
+    getWorkspace(): WorkspaceSvg;
+    /** Adds a change listener to the mini workspace. */
+    addWorkspaceChangeListener(listener: (e: AbstractEvent) => void): void;
+    /**
+     * Validates the workspace options to make sure folks aren't trying to
+     * enable things the miniworkspace doesn't support.
+     */
+    private validateWorkspaceOptions;
+    private onWorkspaceChange;
+    /**
+     * Bumps blocks that are above the top or outside the start-side of the
+     * workspace back within the workspace.
+     *
+     * Blocks that are below the bottom or outside the end-side of the workspace
+     * are dealt with by resizing the workspace to show them.
+     */
+    private bumpBlocksIntoBounds;
+    /**
+     * Updates the size of this bubble to account for the size of the
+     * mini workspace.
+     */
+    private updateBubbleSize;
+    /**
+     * Calculates the size of the mini workspace for use in resizing the bubble.
+     */
+    private calculateWorkspaceSize;
+    /** Reapplies styles to all of the blocks in the mini workspace. */
+    updateBlockStyles(): void;
+    /**
+     * Move this bubble during a drag.
+     *
+     * @param newLoc The location to translate to, in workspace coordinates.
+     * @internal
+     */
+    moveDuringDrag(newLoc: Coordinate): void;
+    /** @internal */
+    moveTo(x: number, y: number): void;
+    /** @internal */
+    newWorkspaceSvg(options: Options): WorkspaceSvg;
+}
+//# sourceMappingURL=mini_workspace_bubble.d.ts.map

package/core/bubbles/text_bubble.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Coordinate } from '../utils/coordinate.js';
+import { Rect } from '../utils/rect.js';
+import { WorkspaceSvg } from '../workspace_svg.js';
+import { Bubble } from './bubble.js';
+/**
+ * A bubble that displays non-editable text. Used by the warning icon.
+ */
+export declare class TextBubble extends Bubble {
+    private text;
+    readonly workspace: WorkspaceSvg;
+    protected anchor: Coordinate;
+    protected ownerRect?: Rect | undefined;
+    private paragraph;
+    constructor(text: string, workspace: WorkspaceSvg, anchor: Coordinate, ownerRect?: Rect | undefined);
+    /** @returns the current text of this text bubble. */
+    getText(): string;
+    /** Sets the current text of this text bubble, and updates the display. */
+    setText(text: string): void;
+    /**
+     * Converts the given string into an svg containing that string,
+     * broken up by newlines.
+     */
+    private stringToSvg;
+    /** Creates the paragraph container for this bubble's view's text fragments. */
+    private createParagraph;
+    /** Creates the text fragments visualizing the text of this bubble. */
+    private createTextFragments;
+    /** Right aligns the given text fragments. */
+    private rightAlignTextFragments;
+    /** Updates the size of this bubble to account for the size of the text. */
+    private updateBubbleSize;
+}
+//# sourceMappingURL=text_bubble.d.ts.map

package/core/bubbles/textinput_bubble.d.ts

@@ -0,0 +1,102 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CommentEditor } from '../comments/comment_editor.js';
+import type { IFocusableNode } from '../interfaces/i_focusable_node.js';
+import type { IHasBubble } from '../interfaces/i_has_bubble.js';
+import { Coordinate } from '../utils/coordinate.js';
+import { Rect } from '../utils/rect.js';
+import { Size } from '../utils/size.js';
+import { WorkspaceSvg } from '../workspace_svg.js';
+import { Bubble } from './bubble.js';
+/**
+ * A bubble that displays editable text. It can also be resized by the user.
+ * Used by the comment icon.
+ */
+export declare class TextInputBubble extends Bubble {
+    readonly workspace: WorkspaceSvg;
+    protected anchor: Coordinate;
+    protected ownerRect?: Rect | undefined;
+    protected owner?: (IHasBubble & IFocusableNode) | undefined;
+    /** The group containing the lines indicating the bubble is resizable. */
+    private resizeGroup;
+    /**
+     * Event data associated with the listener for pointer up events on the
+     * resize group.
+     */
+    private resizePointerUpListener;
+    /**
+     * Event data associated with the listener for pointer move events on the
+     * resize group.
+     */
+    private resizePointerMoveListener;
+    /** Functions listening for changes to the size of this bubble. */
+    private sizeChangeListeners;
+    /** Functions listening for changes to the location of this bubble. */
+    private locationChangeListeners;
+    /** The default size of this bubble, including borders. */
+    private readonly DEFAULT_SIZE;
+    /** The minimum size of this bubble, including borders. */
+    private readonly MIN_SIZE;
+    private editable;
+    /** View responsible for supporting text editing. */
+    private editor;
+    /**
+     * @param workspace The workspace this bubble belongs to.
+     * @param anchor The anchor location of the thing this bubble is attached to.
+     *     The tail of the bubble will point to this location.
+     * @param ownerRect An optional rect we don't want the bubble to overlap with
+     *     when automatically positioning.
+     * @param owner The object that owns/hosts this bubble.
+     */
+    constructor(workspace: WorkspaceSvg, anchor: Coordinate, ownerRect?: Rect | undefined, owner?: (IHasBubble & IFocusableNode) | undefined);
+    /** @returns the text of this bubble. */
+    getText(): string;
+    /** Sets the text of this bubble. Calls change listeners. */
+    setText(text: string): void;
+    /** Sets whether or not the text in the bubble is editable. */
+    setEditable(editable: boolean): void;
+    /** Returns whether or not the text in the bubble is editable. */
+    isEditable(): boolean;
+    /** Adds a change listener to be notified when this bubble's text changes. */
+    addTextChangeListener(listener: () => void): void;
+    /** Adds a change listener to be notified when this bubble's size changes. */
+    addSizeChangeListener(listener: () => void): void;
+    /** Adds a change listener to be notified when this bubble's location changes. */
+    addLocationChangeListener(listener: () => void): void;
+    /** Creates the resize handler elements and binds events to them. */
+    private createResizeHandle;
+    /**
+     * Sets the size of this bubble, including the border.
+     *
+     * @param size Sets the size of this bubble, including the border.
+     * @param relayout If true, reposition the bubble from scratch so that it is
+     *     optimally visible. If false, reposition it so it maintains the same
+     *     position relative to the anchor.
+     */
+    setSize(size: Size, relayout?: boolean): void;
+    /** @returns the size of this bubble. */
+    getSize(): Size;
+    moveDuringDrag(newLoc: Coordinate): void;
+    setPositionRelativeToAnchor(left: number, top: number): void;
+    protected positionByRect(rect?: Rect): void;
+    /** Handles mouse down events on the resize target. */
+    private onResizePointerDown;
+    /** Handles pointer up events on the resize target. */
+    private onResizePointerUp;
+    /** Handles pointer move events on the resize target. */
+    private onResizePointerMove;
+    /** Handles a size change event for the text area. Calls event listeners. */
+    private onSizeChange;
+    /** Handles a location change event for the text area. Calls event listeners. */
+    private onLocationChange;
+    /**
+     * Returns the text editor component of this bubble.
+     *
+     * @internal
+     */
+    getEditor(): CommentEditor;
+}
+//# sourceMappingURL=textinput_bubble.d.ts.map

package/core/bubbles.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Bubble } from './bubbles/bubble.js';
+import { MiniWorkspaceBubble } from './bubbles/mini_workspace_bubble.js';
+import { TextBubble } from './bubbles/text_bubble.js';
+import { TextInputBubble } from './bubbles/textinput_bubble.js';
+export { Bubble, MiniWorkspaceBubble, TextBubble, TextInputBubble };
+//# sourceMappingURL=bubbles.d.ts.map

package/core/bump_objects.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Abstract } from './events/events_abstract.js';
+import type { IBoundedElement } from './interfaces/i_bounded_element.js';
+import type { ContainerRegion } from './metrics_manager.js';
+import type { WorkspaceSvg } from './workspace_svg.js';
+/**
+ * Bumps the given object that has passed out of bounds.
+ *
+ * @param workspace The workspace containing the object.
+ * @param bounds The region to bump an object into. For example, pass
+ *     ScrollMetrics to bump a block into the scrollable region of the
+ *     workspace, or pass ViewMetrics to bump a block into the visible region of
+ *     the workspace. This should be specified in workspace coordinates.
+ * @param object The object to bump.
+ * @returns True if object was bumped.
+ */
+declare function bumpObjectIntoBounds(workspace: WorkspaceSvg, bounds: ContainerRegion, object: IBoundedElement): boolean;
+export declare const bumpIntoBounds: typeof bumpObjectIntoBounds;
+/**
+ * Creates a handler for bumping objects when they cross fixed bounds.
+ *
+ * @param workspace The workspace to handle.
+ * @returns The event handler.
+ */
+export declare function bumpIntoBoundsHandler(workspace: WorkspaceSvg): (p1: Abstract) => void;
+/**
+ * Bumps the top objects in the given workspace into bounds.
+ *
+ * @param workspace The workspace.
+ */
+export declare function bumpTopObjectsIntoBounds(workspace: WorkspaceSvg): void;
+export {};
+//# sourceMappingURL=bump_objects.d.ts.map

package/core/button_flyout_inflater.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FlyoutItem } from './flyout_item.js';
+import type { IFlyout } from './interfaces/i_flyout.js';
+import type { IFlyoutInflater } from './interfaces/i_flyout_inflater.js';
+/**
+ * Class responsible for creating buttons for flyouts.
+ */
+export declare class ButtonFlyoutInflater implements IFlyoutInflater {
+    /**
+     * Inflates a flyout button from the given state and adds it to the flyout.
+     *
+     * @param state A JSON representation of a flyout button.
+     * @param flyout The flyout to create the button on.
+     * @returns A newly created FlyoutButton.
+     */
+    load(state: object, flyout: IFlyout): FlyoutItem;
+    /**
+     * Returns the amount of space that should follow this button.
+     *
+     * @param state A JSON representation of a flyout button.
+     * @param defaultGap The default spacing for flyout items.
+     * @returns The amount of space that should follow this button.
+     */
+    gapForItem(state: object, defaultGap: number): number;
+    /**
+     * Disposes of the given button.
+     *
+     * @param item The flyout button to dispose of.
+     */
+    disposeItem(item: FlyoutItem): void;
+    /**
+     * Returns the type of items this inflater is responsible for creating.
+     *
+     * @returns An identifier for the type of items this inflater creates.
+     */
+    getType(): string;
+}
+//# sourceMappingURL=button_flyout_inflater.d.ts.map

package/core/clipboard/block_paster.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BlockSvg } from '../block_svg.js';
+import { ICopyData } from '../interfaces/i_copyable.js';
+import { IPaster } from '../interfaces/i_paster.js';
+import { State } from '../serialization/blocks.js';
+import { Coordinate } from '../utils/coordinate.js';
+import { WorkspaceSvg } from '../workspace_svg.js';
+export declare class BlockPaster implements IPaster<BlockCopyData, BlockSvg> {
+    static TYPE: string;
+    paste(copyData: BlockCopyData, workspace: WorkspaceSvg, coordinate?: Coordinate): BlockSvg | null;
+}
+/**
+ * Moves the given block to a location where it does not: (1) overlap exactly
+ * with any other blocks, or (2) look like it is connected to any other blocks.
+ *
+ * Exported for testing.
+ *
+ * @param block The block to move to an unambiguous location.
+ * @param originalPosition The initial coordinate to start searching from,
+ *    likely the position of the copied block.
+ * @internal
+ */
+export declare function moveBlockToNotConflict(block: BlockSvg, originalPosition: Coordinate): void;
+export interface BlockCopyData extends ICopyData {
+    blockState: State;
+    typeCounts: {
+        [key: string]: number;
+    };
+}
+//# sourceMappingURL=block_paster.d.ts.map

package/core/clipboard/registry.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ICopyable, ICopyData } from '../interfaces/i_copyable.js';
+import type { IPaster } from '../interfaces/i_paster.js';
+/**
+ * Registers the given paster so that it cna be used for pasting.
+ *
+ * @param type The type of the paster to register, e.g. 'block', 'comment', etc.
+ * @param paster The paster to register.
+ */
+export declare function register<U extends ICopyData, T extends ICopyable<U>>(type: string, paster: IPaster<U, T>): void;
+/**
+ * Unregisters the paster associated with the given type.
+ *
+ * @param type The type of the paster to unregister.
+ */
+export declare function unregister(type: string): void;
+//# sourceMappingURL=registry.d.ts.map

package/core/clipboard/workspace_comment_paster.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { RenderedWorkspaceComment } from '../comments/rendered_workspace_comment.js';
+import { ICopyData } from '../interfaces/i_copyable.js';
+import { IPaster } from '../interfaces/i_paster.js';
+import * as commentSerialiation from '../serialization/workspace_comments.js';
+import { Coordinate } from '../utils/coordinate.js';
+import { WorkspaceSvg } from '../workspace_svg.js';
+export declare class WorkspaceCommentPaster implements IPaster<WorkspaceCommentCopyData, RenderedWorkspaceComment> {
+    static TYPE: string;
+    paste(copyData: WorkspaceCommentCopyData, workspace: WorkspaceSvg, coordinate?: Coordinate): RenderedWorkspaceComment | null;
+}
+export interface WorkspaceCommentCopyData extends ICopyData {
+    commentState: commentSerialiation.State;
+}
+//# sourceMappingURL=workspace_comment_paster.d.ts.map