microboard-temp 0.13.92 → 0.13.94

package/dist/types/Items/Shape/Shapes.d.ts

@@ -0,0 +1,330 @@
+export declare const Shapes: {
+    BPMN_Gateway: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    BPMN_DataStore: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Paths;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Paths;
+        useMbrUnderPointer: boolean;
+    };
+    BPMN_GatewayParallel: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Paths;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Paths;
+        useMbrUnderPointer: boolean;
+    };
+    BPMN_GatewayXOR: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Paths;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Paths;
+        useMbrUnderPointer: boolean;
+    };
+    BPMN_EndEvent: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    BPMN_StartEvent: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    BPMN_StartEventNoneInterrupting: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    BPMN_IntermediateEvent: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Paths;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Paths;
+        useMbrUnderPointer: boolean;
+    };
+    BPMN_IntermediateEventNoneInterrupting: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Paths;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Paths;
+        useMbrUnderPointer: boolean;
+    };
+    BPMN_Group: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    BPMN_Participant: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Paths;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Paths;
+        useMbrUnderPointer: boolean;
+    };
+    BPMN_Task: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    BPMN_Transaction: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Paths;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Paths;
+        useMbrUnderPointer: boolean;
+    };
+    BPMN_EventSubprocess: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Paths;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Paths;
+        useMbrUnderPointer: boolean;
+    };
+    BPMN_Annotation: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Paths;
+        anchorPoints: never[];
+        createPath: (mbr: import("..").Mbr) => import("..").Paths;
+        useMbrUnderPointer: boolean;
+    };
+    BPMN_DataObject: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Paths;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Paths;
+        useMbrUnderPointer: boolean;
+    };
+    Rectangle: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    Triangle: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    ReversedTriangle: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    Circle: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    ArrowLeft: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    ArrowLeftRight: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    ArrowRight: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    ArrowBlockLeft: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    ArrowBlockRight: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    BracesLeft: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: never[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    BracesRight: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: never[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    Cloud: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    Cross: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    Cylinder: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Paths;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Paths;
+        useMbrUnderPointer: boolean;
+    };
+    Hexagon: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    Octagon: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    Parallelogram: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    ReversedParallelogram: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    Pentagon: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    PredefinedProcess: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Paths;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Paths;
+        useMbrUnderPointer: boolean;
+    };
+    Rhombus: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    RoundedRectangle: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    SpeachBubble: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    Star: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+    Trapezoid: {
+        name: string;
+        textBounds: import("..").Mbr;
+        path: import("..").Path;
+        anchorPoints: import("..").Point[];
+        createPath: (mbr: import("..").Mbr) => import("..").Path;
+        useMbrUnderPointer: boolean;
+    };
+};

package/dist/types/Items/Shape/index.d.ts

@@ -2,5 +2,6 @@ export { Shape, Shapes } from "./Shape";
 export { ShapeCommand } from "./ShapeCommand";
 export type { ShapeOperation } from "./ShapeOperation";
 export * from "./ShapeData";
+export { shapeOps } from "./shapeOps";
 export type { ShapeType } from "./ShapeType";
 export { DefaultShapeData } from "./ShapeData";

package/dist/types/Items/Shape/shapeOps.d.ts

@@ -0,0 +1,19 @@
+import { ColorValue } from "../../Color";
+import { BorderStyle } from "../Path";
+import { ShapeOperation } from "./ShapeOperation";
+import { ShapeType } from "./ShapeType";
+type ItemLike = {
+    getId(): string;
+    getBorderWidth?(): number;
+};
+type ItemOrId = ItemLike | string;
+export declare const shapeOps: {
+    setBackgroundColor(items: readonly ItemOrId[], backgroundColor: ColorValue): ShapeOperation;
+    setBackgroundOpacity(items: readonly ItemOrId[], backgroundOpacity: number): ShapeOperation;
+    setBorderColor(items: readonly ItemOrId[], borderColor: ColorValue): ShapeOperation;
+    setBorderOpacity(items: readonly ItemOrId[], borderOpacity: number): ShapeOperation;
+    setBorderStyle(items: readonly ItemOrId[], borderStyle: BorderStyle): ShapeOperation;
+    setBorderWidth(items: readonly ItemLike[], borderWidth: number): ShapeOperation;
+    setShapeType(items: readonly ItemOrId[], shapeType: ShapeType): ShapeOperation;
+};
+export {};

package/dist/types/Items/Sticker/Sticker.d.ts

@@ -6,15 +6,12 @@ import { Mbr } from "../Mbr/Mbr";
 import { Path } from "../Path/Path";
 import { Paths } from "../Path/Paths";
 import { Point } from "../Point/Point";
-import { Transformation } from "../Transformation/Transformation";
 import { ResizeType } from "../../Selection/Transformer/TransformerHelpers/getResizeType";
 import { DrawingContext } from "../DrawingContext";
 import { GeometricNormal } from "../GeometricNormal";
 import { RichText } from "../RichText/RichText";
 import { StickerData, StickerOperation } from "./StickerOperation";
-import { LinkTo } from "../LinkTo/LinkTo";
 import { Board } from "../../Board";
-import { DocumentFactory } from "../../api/DocumentFactory";
 import { BaseItem } from "../BaseItem/BaseItem";
 import type { SerializedItemData } from "../BaseItem/BaseItem";
 import { ColorValue } from "../../..";
@@ -31,8 +28,6 @@ export declare class Sticker extends BaseItem<Sticker> {
     backgroundColor: ColorValue;
     parent: string;
     readonly itemType = "Sticker";
-    readonly transformation: Transformation;
-    readonly linkTo: LinkTo;
     private stickerPath;
     private textContainer;
     text: RichText;
@@ -48,10 +43,10 @@ export declare class Sticker extends BaseItem<Sticker> {
     protected onParentChanged(newParent: string): void;
     getId(): string;
     apply(op: Operation): void;
+    private applyStickerOperation;
     getBackgroundColor(): ColorValue;
     getWidth(): number;
     private applyBackgroundColor;
-    setBackgroundColor(backgroundColor: ColorValue): void;
     getIntersectionPoints(segment: Line): Point[];
     getMbr(): Mbr;
     getNearestEdgePointTo(point: Point): Point;
@@ -63,13 +58,14 @@ export declare class Sticker extends BaseItem<Sticker> {
     isInView(rect: Mbr): boolean;
     getNormal(point: Point): GeometricNormal;
     render(context: DrawingContext): void;
-    renderHTML(documentFactory: DocumentFactory): HTMLElement;
     renderShadow(context: DrawingContext): void;
     getPaths(): Path | Paths;
     isClosed(): boolean;
     getPath(): Path | Paths;
     getSnapAnchorPoints(): Point[];
+    /** Entry point for AddSticker tool during item creation */
     applyDiagonal(line: Line): void;
+    /** Entry point for AddSticker tool during item creation */
     applyTransformToCenter(pt: Point, newWidth?: number): void;
     doResize(resizeType: ResizeType, pointer: Point, mbr: Mbr, opposite: Point, startMbr: Mbr, timeStamp: number): {
         matrix: Matrix;

package/dist/types/Items/Sticker/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./Sticker";
 export * from "./StickerOperation";
+export * from "./stickerOps";

package/dist/types/Items/Sticker/stickerOps.d.ts

@@ -0,0 +1,9 @@
+import { ColorValue } from "../../..";
+import { Operation } from "../../Events";
+interface ItemLike {
+    getId(): string;
+}
+export declare const stickerOps: {
+    setBackgroundColor(items: ItemLike[], backgroundColor: ColorValue): Operation;
+};
+export {};

package/dist/types/Items/Transformation/Transformation.d.ts

@@ -1,13 +1,21 @@
-import { SubjectOperation } from '../../SubjectOperation';
-import { Events, Operation } from '../../Events';
-import { Point } from '../Point';
+import type { Events } from '../../Events';
 import { Matrix } from './Matrix';
 import { TransformationData } from './TransformationData';
 import { MatrixData, TransformationOperation } from './TransformationOperations';
+type LocalTransformationOperation = {
+    class: 'Transformation';
+    method: 'setLocalMatrix';
+    item: string[];
+    matrix: MatrixData;
+} | {
+    class: 'Transformation';
+    method: 'setLocal';
+    item: string[];
+    data: Partial<MatrixData>;
+};
 export declare class Transformation {
     private id;
     private events?;
-    readonly subject: SubjectOperation<Transformation, TransformationOperation>;
     private _matrix;
     previous: Matrix;
     private rotate;
@@ -26,13 +34,8 @@ export declare class Transformation {
         y: number;
     };
     getRotation(): number;
-    /**
-     * Replaces the internal matrix entirely with `matrix` without emitting an operation.
-     * Used by the nesting system to convert between world and local coordinate spaces.
-     */
-    setLocalMatrix(matrix: Matrix): void;
-    setLocal(x: number, y: number, scaleX?: number, scaleY?: number): void;
-    setLocal(data: Partial<MatrixData>): void;
+    private applyLocalMatrix;
+    private applyLocal;
     serialize(): TransformationData;
     deserialize(data: TransformationData & {
         dimension?: {
@@ -44,53 +47,28 @@ export declare class Transformation {
     getInverse(): Transformation;
     getId(): string;
     setId(id: string): void;
-    emit(operation: TransformationOperation): void;
+    private emit;
     private emitMatrix;
-    translateTo(x: number, y: number, timeStamp?: number): void;
-    translateBy(x: number, y: number, timeStamp?: number): void;
-    scaleTo(x: number, y: number, timeStamp?: number): void;
-    scaleBy(x: number, y: number, timeStamp?: number): void;
-    scaleByTranslateBy(scale: {
-        x: number;
-        y: number;
-    }, translate: {
-        x: number;
-        y: number;
-    }, timeStamp?: number): void;
-    rotateTo(degree: number, timeStamp?: number): void;
-    rotateBy(degree: number, timeStamp?: number): void;
-    scaleToRelativeTo(x: number, y: number, _point: Point, timeStamp?: number): void;
-    scaleByRelativeTo(x: number, y: number, point: Point, timeStamp?: number): void;
-    applyMatrixSilent(matrixData: MatrixData): void;
-    setIsLocked(isLocked: boolean, timestamp?: number): void;
-    apply(op: Operation): void;
-    /** @deprecated Only for replaying legacy events. Do not call directly. */
-    applyTranslateTo(x: number, y: number): void;
-    /** @deprecated Only for replaying legacy events. Do not call directly. */
-    applyTranslateBy(x: number, y: number): void;
-    /** @deprecated Only for replaying legacy events. Do not call directly. */
-    applyScaleTo(x: number, y: number): void;
-    /** @deprecated Only for replaying legacy events. Do not call directly. */
-    applyScaleBy(x: number, y: number): void;
-    /** @deprecated Only for replaying legacy events. Do not call directly. */
-    applyScaleByTranslateBy(scale: {
-        x: number;
-        y: number;
-    }, translate: {
-        x: number;
-        y: number;
-    }): void;
-    applyTransformMany(op: TransformationOperation): void;
-    applyScaleByRelativeTo(x: number, y: number, point: {
-        x: number;
-        y: number;
-    }): void;
-    applyScaleToRelativeTo(x: number, y: number, point: {
-        x: number;
-        y: number;
-    }): void;
-    applyRotateTo(degree: number): void;
-    applyRotateBy(degree: number): void;
-    applyLocked(locked: boolean): void;
-    applyUnlocked(locked: boolean): void;
+    private translateTo;
+    private translateBy;
+    private scaleTo;
+    private scaleBy;
+    private scaleByTranslateBy;
+    private rotateTo;
+    private rotateBy;
+    private scaleToRelativeTo;
+    private scaleByRelativeTo;
+    private applyMatrix;
+    private applyIsLocked;
+    apply(op: TransformationOperation | LocalTransformationOperation): void;
+    private applyTransformMany;
+    private applyTranslateTo;
+    private applyTranslateBy;
+    private applyScaleTo;
+    private applyScaleBy;
+    private applyScaleByRelativeTo;
+    private applyScaleToRelativeTo;
+    private applyRotateTo;
+    private applyRotateBy;
 }
+export {};

package/dist/types/Items/Transformation/TransformationCommand.d.ts

@@ -1,6 +1,7 @@
 import { Transformation } from "./Transformation";
 import { TransformationOperation } from "./TransformationOperations";
-import { Command, Operation } from "../../Events";
+import type { Command } from "../../Events/Command";
+import type { Operation } from "../../Events/EventsOperations";
 /** Minimal interface to avoid circular import with BaseItem/Item */
 interface TransformableItem {
     apply(op: Operation): void;

package/dist/types/Items/Transformation/TransformationOperations.d.ts

@@ -3,6 +3,7 @@ interface TransformationBase {
     class: "Transformation";
     item: string[];
     timestamp?: number;
+    silent?: boolean;
 }
 /** @deprecated Use ApplyMatrixOperation instead. Kept for reading legacy events. */
 export interface TranslateOperation extends TransformationBase {
@@ -24,17 +25,6 @@ interface RotateOperation extends TransformationBase {
     timeStamp?: number;
 }
 /** @deprecated Use ApplyMatrixOperation instead. Kept for reading legacy events. */
-interface ScaleRelativeToOperation extends TransformationBase {
-    method: "scaleToRelativeTo" | "scaleByRelativeTo";
-    x: number;
-    y: number;
-    point: {
-        x: number;
-        y: number;
-    };
-    timeStamp?: number;
-}
-/** @deprecated Use ApplyMatrixOperation instead. Kept for reading legacy events. */
 export interface ScaleByTranslateByOperation extends TransformationBase {
     method: "scaleByTranslateBy";
     translate: {
@@ -79,6 +69,7 @@ export interface ApplyMatrixOperation {
     method: "applyMatrix";
     items: ApplyMatrixItem[];
     timeStamp?: number;
+    silent?: boolean;
 }
 export interface TransformManyItems {
     [key: string]: ApplyMatrixOperation | ScaleByTranslateByOperation | ScaleOperation | TranslateOperation;
@@ -89,5 +80,5 @@ export interface TransformMany {
     items: TransformManyItems;
     timeStamp?: number;
 }
-export type TransformationOperation = ApplyMatrixOperation | TranslateOperation | ScaleOperation | RotateOperation | ScaleRelativeToOperation | ScaleByTranslateByOperation | DeserializeOperation | TransformMany | Locked | Unlocked;
+export type TransformationOperation = ApplyMatrixOperation | RotateOperation | DeserializeOperation | TransformMany | Locked | Unlocked | TranslateOperation | ScaleOperation | ScaleByTranslateByOperation;
 export {};

package/dist/types/Items/Transformation/transformOps.d.ts

@@ -0,0 +1,35 @@
+import { MatrixData, TransformationOperation } from "./TransformationOperations";
+interface ItemLike {
+    getId(): string;
+    transformation: {
+        getTranslation(): {
+            x: number;
+            y: number;
+        };
+        getScale(): {
+            x: number;
+            y: number;
+        };
+    };
+}
+type ItemOrId = ItemLike | string;
+export declare const transformOps: {
+    applyMatrix(items: readonly ItemOrId[] | ItemOrId, matrix: MatrixData, timeStamp?: number, silent?: boolean): TransformationOperation;
+    translateBy(items: readonly ItemOrId[] | ItemOrId, x: number, y: number, timeStamp?: number): TransformationOperation;
+    translateTo(item: ItemLike, x: number, y: number, timeStamp?: number): TransformationOperation;
+    scaleBy(items: readonly ItemOrId[] | ItemOrId, x: number, y: number, timeStamp?: number): TransformationOperation;
+    scaleTo(item: ItemLike, x: number, y: number, timeStamp?: number): TransformationOperation;
+    rotateBy(items: readonly ItemOrId[] | ItemOrId, degree: number, timeStamp?: number): TransformationOperation;
+    rotateTo(items: readonly ItemOrId[] | ItemOrId, degree: number, timeStamp?: number): TransformationOperation;
+    setLocalMatrix(item: ItemOrId, matrix: MatrixData): TransformationOperation;
+    scaleByTranslateBy(items: readonly ItemOrId[] | ItemOrId, scale: {
+        x: number;
+        y: number;
+    }, translate: {
+        x: number;
+        y: number;
+    }, timeStamp?: number): TransformationOperation;
+    setLocal(item: ItemOrId, data: Partial<MatrixData>): TransformationOperation;
+    lock(items: readonly ItemOrId[] | ItemOrId, locked: boolean): TransformationOperation;
+};
+export {};