@osamash/floor-planner 1.2.2 → 1.2.4

package/dist/types/index.d.ts

@@ -2,5 +2,7 @@ import ReactPlanner from "./react-planner/ReactPlanner";
 import ReactPlannerLoader from "./react-planner/ReactPlannerLoader";
 import convertUnits, { type Unit } from "./react-planner/utils/convert-units";
 import Catalog, { AreaFactory, ItemFactory, WallFactory, SurfaceFactory } from "./react-planner/catalog";
-export { Catalog, AreaFactory, ItemFactory, WallFactory, SurfaceFactory, convertUnits, type Unit, ReactPlannerLoader, };
+import type { AIRequestHandler, AIResponse, AIStreamContext, ChatMessage, PlanSummary, PlannerAction } from "./react-planner/ai-chat/aiService";
+import { createStreamingAIHandler, type StreamingAIHandlerOptions } from "./react-planner/ai-chat/streamingClient";
+export { Catalog, AreaFactory, ItemFactory, WallFactory, SurfaceFactory, convertUnits, type Unit, ReactPlannerLoader, createStreamingAIHandler, type StreamingAIHandlerOptions, type AIRequestHandler, type AIResponse, type AIStreamContext, type ChatMessage, type PlanSummary, type PlannerAction, };
 export default ReactPlanner;

package/dist/types/react-planner/ReactPlanner.d.ts

@@ -1,11 +1,13 @@
 import { type Plan as PlanType } from "../store/ReactPlannerStore";
 import "./react-planner.css";
+import type { AIRequestHandler } from "./ai-chat/aiService";
 interface ReactPlannerProps {
     catalog: any;
     plan: PlanType;
     has3dView?: boolean;
     onBack?: () => void;
     onSave?: (data: any) => void;
+    onAIMessage?: AIRequestHandler;
 }
-declare const ReactPlanner: ({ plan, catalog, onSave, onBack, has3dView, }: ReactPlannerProps) => import("react/jsx-runtime").JSX.Element;
+declare const ReactPlanner: ({ plan, catalog, onSave, onBack, has3dView, onAIMessage, }: ReactPlannerProps) => import("react/jsx-runtime").JSX.Element;
 export default ReactPlanner;

package/dist/types/react-planner/ai-chat/AIChatBubble.d.ts

@@ -0,0 +1,6 @@
+import type { AIRequestHandler } from "./aiService";
+interface AIChatBubbleProps {
+    onAIMessage?: AIRequestHandler;
+}
+declare const AIChatBubble: ({ onAIMessage }: AIChatBubbleProps) => import("react/jsx-runtime").JSX.Element;
+export default AIChatBubble;

package/dist/types/react-planner/ai-chat/AIChatPanel.d.ts

@@ -0,0 +1,8 @@
+import { type AIRequestHandler } from "./aiService";
+interface AIChatPanelProps {
+    open: boolean;
+    onClose: () => void;
+    onAIMessage?: AIRequestHandler;
+}
+declare const AIChatPanel: ({ open, onClose, onAIMessage }: AIChatPanelProps) => import("react/jsx-runtime").JSX.Element;
+export default AIChatPanel;

package/dist/types/react-planner/ai-chat/SelectionChips.d.ts

@@ -0,0 +1,2 @@
+declare const SelectionChips: () => import("react/jsx-runtime").JSX.Element | null;
+export default SelectionChips;

package/dist/types/react-planner/ai-chat/ThinkingIndicator.d.ts

@@ -0,0 +1,5 @@
+interface ThinkingIndicatorProps {
+    label?: string;
+}
+declare const ThinkingIndicator: ({ label }: ThinkingIndicatorProps) => import("react/jsx-runtime").JSX.Element;
+export default ThinkingIndicator;

package/dist/types/react-planner/ai-chat/aiService.d.ts

@@ -0,0 +1,327 @@
+export interface ChatMessage {
+    role: "user" | "assistant";
+    content: string;
+    /**
+     * Photos attached to a user message — e.g. a scan/photo of a paper floor
+     * plan the AI should interpret and turn into `add-room`/`add-wall`/etc.
+     * actions. `data` is raw base64 (no `data:...;base64,` prefix). Assistant
+     * messages never carry this.
+     */
+    images?: {
+        mediaType: string;
+        data: string;
+    }[];
+    /**
+     * True for the library's own "keep going" turn inserted between
+     * `done: false` continuation calls — never something the user typed.
+     * Several current models (Sonnet 5 and the whole Opus 4.6+/Fable 5
+     * family) reject a request whose message list ends on an `assistant`
+     * turn ("assistant message prefill" is no longer supported), so a
+     * continuation can't just resend the conversation as-is after appending
+     * the assistant's own reply — it needs a trailing `user` turn too. This
+     * flag exists so the chat UI can skip rendering that turn as if the user
+     * had sent it, while it's still included in what's sent to the backend.
+     */
+    synthetic?: boolean;
+}
+export interface WallInfo {
+    id: string;
+    v0: string;
+    v1: string;
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+    length: number;
+    orientation: "horizontal" | "vertical" | "diagonal";
+    holeCount: number;
+}
+export interface HoleInfo {
+    id: string;
+    type: string;
+    lineID: string;
+    offset: number;
+    /** Mirrored ALONG its wall — for a door, which end the hinge is at. */
+    flipAlongWall: boolean;
+    /** Mirrored ACROSS its wall — for a door, which side it opens into. */
+    flipAcrossWall: boolean;
+}
+export interface AreaInfo {
+    id: string;
+    /** "room" = enclosed by walls, "surface" = a free-standing polygon (grass,
+     *  patio, driveway…). Only surfaces can be transformed with
+     *  `set-surface-transform` / `duplicate-surface`. */
+    kind: "room" | "surface" | "area";
+    vertices: {
+        id: string;
+        x: number;
+        y: number;
+    }[];
+    color: string | null;
+    customName: string | null;
+    roomCategory: string | null;
+    roomType: string | null;
+    showName: boolean;
+    showSurfaceArea: boolean;
+}
+export interface RoomTypeOption {
+    value: string;
+    label: string;
+    color?: string;
+}
+export interface RoomCategoryOption {
+    value: string;
+    label: string;
+    types: RoomTypeOption[];
+}
+export interface PlanSelection {
+    walls: string[];
+    holes: string[];
+    items: string[];
+    areas: string[];
+    vertices: string[];
+}
+export interface ItemInfo {
+    id: string;
+    name: string;
+    x: number;
+    y: number;
+    /** Degrees. Positive reads counter-clockwise in the 2D view. */
+    rotation: number;
+    /** Uniform size multiplier on the catalog element's own dimensions. */
+    scale: number;
+    flipHorizontal: boolean;
+    flipVertical: boolean;
+}
+export interface PlanSummary {
+    layerName: string;
+    wallCount: number;
+    itemCount: number;
+    holeCount: number;
+    areaCount: number;
+    walls: WallInfo[];
+    holes: HoleInfo[];
+    areas: AreaInfo[];
+    items: ItemInfo[];
+    mode: string;
+    is3D: boolean;
+    showDimensions: boolean;
+    sceneWidth: number;
+    sceneHeight: number;
+    unit: string;
+    catalogItemTypes: string[];
+    catalogHoleTypes: string[];
+    catalogSurfaceTypes: string[];
+    /** Fill patterns (hatch styles) available for areas — pass in
+     *  `set-area-properties.pattern`. Also "none" is always accepted. */
+    catalogAreaPatterns: string[];
+    /** Textures registered on the current area catalog element — pass in
+     *  `set-area-properties.texture`. Also "none" is always accepted. */
+    catalogAreaTextures: string[];
+    /** Textures registered on the current wall catalog element — pass in
+     *  `set-wall-properties.textureA` / `textureB`. Also "none" is always
+     *  accepted. */
+    catalogWallTextures: string[];
+    roomTypes: RoomCategoryOption[];
+    selection: PlanSelection;
+}
+export type PlannerAction = {
+    type: "add-wall";
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+    id?: string;
+} | {
+    type: "add-room";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    id?: string;
+} | {
+    type: "add-surface";
+    points: {
+        x: number;
+        y: number;
+    }[];
+    surfaceType?: string;
+    id?: string;
+} | {
+    type: "add-item";
+    itemType: string;
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+    rotation?: number;
+    id?: string;
+} | {
+    type: "add-hole";
+    /** Real line ID, or a "$tag" / "$tag.side" reference — see note above. */
+    lineID: string;
+    holeType: string;
+    offset: number;
+    id?: string;
+} | {
+    type: "set-area-color";
+    areaID: string;
+    color: string;
+} | {
+    type: "set-area-properties";
+    areaID: string;
+    customName?: string;
+    roomCategory?: string;
+    roomType?: string;
+    patternColor?: string;
+    /** One of PlanSummary.catalogAreaPatterns keys (or "none"). */
+    pattern?: string;
+    /** One of PlanSummary.catalogAreaTextures keys (or "none"). */
+    texture?: string;
+    showName?: boolean;
+    showSurfaceArea?: boolean;
+} | {
+    type: "set-wall-properties";
+    wallID: string;
+    colorA?: string;
+    colorB?: string;
+    /** One of PlanSummary.catalogWallTextures keys (or "none"). */
+    textureA?: string;
+    textureB?: string;
+    /** cm */
+    thickness?: number;
+    /** cm */
+    height?: number;
+    customName?: string;
+    showName?: boolean;
+} | {
+    /** Edit an existing item in place — the same set of changes the
+     *  selection toolbar offers in the 2D view. Omitted fields are left
+     *  untouched. */
+    type: "set-item-properties";
+    itemID: string;
+    x?: number;
+    y?: number;
+    /** Degrees, absolute (not a delta). Positive = counter-clockwise. */
+    rotation?: number;
+    /** Uniform size multiplier, clamped to 0.2–8. 1 = catalog size. */
+    scale?: number;
+    flipHorizontal?: boolean;
+    flipVertical?: boolean;
+} | {
+    /** Edit an existing door / window in place. */
+    type: "set-hole-properties";
+    holeID: string;
+    /** 0..1 along its wall. */
+    offset?: number;
+    /** Mirror along the wall — moves a door's hinge to the other end. */
+    flipAlongWall?: boolean;
+    /** Mirror across the wall — flips which side a door opens into. */
+    flipAcrossWall?: boolean;
+} | {
+    /** Rotate / mirror a surface polygon about its own center. Rooms are
+     *  rejected: their vertices are shared with the walls around them. */
+    type: "set-surface-transform";
+    areaID: string;
+    /** Degrees, relative to where the surface is now. Positive =
+     *  counter-clockwise on screen, as for `set-item-properties.rotation`. */
+    rotate?: number;
+    /** "x" flips it left-right, "y" top-bottom. */
+    mirror?: "x" | "y";
+} | {
+    /** Copy a surface polygon, keeping its look, set down clear of the
+     *  original. The copy ends up selected. */
+    type: "duplicate-surface";
+    areaID: string;
+} | {
+    /** Copy an item, keeping its rotation / scale / flips, offset slightly
+     *  from the original. The copy ends up selected. */
+    type: "duplicate-item";
+    itemID: string;
+} | {
+    /** Copy a door / window along the same wall. */
+    type: "duplicate-hole";
+    holeID: string;
+} | {
+    type: "move-vertex";
+    vertexID: string;
+    x: number;
+    y: number;
+} | {
+    type: "delete-wall";
+    wallID: string;
+} | {
+    type: "delete-item";
+    itemID: string;
+} | {
+    type: "delete-hole";
+    holeID: string;
+} | {
+    type: "remove-room";
+    areaID: string;
+} | {
+    type: "clear";
+} | {
+    type: "switch-view";
+    view: "2d" | "3d";
+} | {
+    type: "toggle-dimensions";
+    show: boolean;
+} | {
+    type: "undo";
+};
+export interface AIResponse {
+    reply: string;
+    actions: PlannerAction[];
+    /**
+     * Multi-step continuation. Building something big (a whole multi-room
+     * floor plan) can need more actions than fit in one well-grounded
+     * response — e.g. you want to see a room's real wall IDs (from a fresh
+     * `PlanSummary`) before placing doors on it, rather than guessing with a
+     * `$tag` (see the note on `PlannerAction` above; `$tag`s work within one
+     * response, this is for spanning several).
+     *
+     * Set `done: false` to have the library apply this response's `actions`,
+     * take a fresh `summarizePlan()` of the result, and call your handler
+     * again — same `messages` array with this response's own `reply` appended
+     * as an assistant turn, no synthetic "continue" message injected — so you
+     * see your own last reply plus the updated plan and pick up from there.
+     * Each intermediate `reply` is shown in the chat as its own message, so
+     * narrate what that step did (e.g. "Built the room shells, adding doors
+     * next…").
+     *
+     * Omit, or set `true`, once you're finished — this is also the default
+     * for backends that don't implement this field, so single-response
+     * behavior is unchanged. The library caps continuations at 8 steps
+     * regardless, in case of a backend bug that never stops; don't rely on
+     * more than that for one user request.
+     */
+    done?: boolean;
+}
+/**
+ * Extras the library hands a handler on every call. Optional on purpose: a
+ * handler written against the original two-argument signature keeps working
+ * untouched — it just never streams and never gets cancelled.
+ */
+export interface AIStreamContext {
+    /**
+     * Aborted when the planner unmounts mid-request. Pass it to `fetch` so a
+     * closed tab stops the backend generating (and billing) into a dead socket.
+     */
+    signal?: AbortSignal;
+    /**
+     * Call with each incremental chunk of reply text as it arrives, in order.
+     * The chat paints the accumulated text live while the request is still in
+     * flight.
+     *
+     * The deltas are a *preview*, not the result: when the promise resolves,
+     * the chat throws the accumulated text away and renders `AIResponse.reply`
+     * instead. The two legitimately differ (a backend that re-parses its own
+     * output can correct or replace what it streamed), so a handler must still
+     * resolve with the complete, authoritative reply — never with `""` on the
+     * grounds that it already streamed the text.
+     */
+    onReplyDelta?: (delta: string) => void;
+}
+export type AIRequestHandler = (messages: ChatMessage[], plan: PlanSummary, ctx?: AIStreamContext) => Promise<AIResponse>;
+export declare function getAIResponse(messages: ChatMessage[], _plan: PlanSummary): Promise<AIResponse>;

package/dist/types/react-planner/ai-chat/imageUpload.d.ts

@@ -0,0 +1,6 @@
+export interface PendingImage {
+    mediaType: string;
+    data: string;
+    previewUrl: string;
+}
+export declare function fileToChatImage(file: File): Promise<PendingImage>;

package/dist/types/react-planner/ai-chat/plannerActions.d.ts

@@ -0,0 +1,3 @@
+import type { PlanSummary, PlannerAction } from "./aiService";
+export declare function summarizePlan(planner: any): PlanSummary;
+export declare function applyPlannerActions(actions: PlannerAction[]): void;

package/dist/types/react-planner/ai-chat/streamingClient.d.ts

@@ -0,0 +1,32 @@
+import type { AIRequestHandler } from "./aiService";
+/**
+ * Client for a backend that speaks the streaming variant of the chat contract
+ * (`floor-planner-ai-backend`'s `POST /ai/chat/stream`). Lives in the library
+ * so every consumer doesn't hand-roll an SSE parser; the URL and any auth
+ * headers still belong to the consuming app — the library never holds a key.
+ *
+ * Wire format (Server-Sent Events, POST — so NOT `EventSource`-compatible):
+ *
+ *   event: meta   data: { provider, model }           once, before any output
+ *   event: reply  data: { delta }                     zero or more, in order
+ *   event: final  data: { reply, actions, done, … }   authoritative, terminal
+ *   event: error  data: { error, type }               terminal
+ *
+ * Only the reply text streams. Actions arrive whole in `final` because a
+ * half-parsed action isn't something the planner can apply.
+ *
+ * Failures *before* the first token (bad key, rate limit, an image sent to a
+ * text-only model) come back as an ordinary JSON error with a real status
+ * code. Once the stream has started the status line is spent, so anything
+ * after that arrives as an `error` frame — hence both paths below.
+ */
+export interface StreamingAIHandlerOptions {
+    /** Full URL of the streaming endpoint, e.g. `http://host:3001/ai/chat/stream`. */
+    url: string;
+    /**
+     * Extra request headers (auth, tenant id…). A function is re-invoked per
+     * request, so a token that rotates doesn't go stale.
+     */
+    headers?: Record<string, string> | (() => Record<string, string>);
+}
+export declare const createStreamingAIHandler: ({ url, headers, }: StreamingAIHandlerOptions) => AIRequestHandler;

package/dist/types/react-planner/ai-chat/useTypewriter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Paces streamed text into the UI at frame rate instead of at network rate.
+ *
+ * Deltas off an SSE stream don't arrive one token at a time — TCP and any
+ * proxy in between coalesce them, so what lands is a few characters, then 80,
+ * then nothing for 300ms. Rendering each delta the moment it arrives makes the
+ * text jump in uneven blocks. Buffering here and draining a slice per animation
+ * frame turns the same bytes into steady output.
+ *
+ * The drain is proportional (a fixed chars-per-frame rate would fall further
+ * and further behind a fast model), so a big burst catches up in a handful of
+ * frames rather than trickling out for seconds after the response is done.
+ */
+export declare const useTypewriter: () => {
+    text: string;
+    push: (delta: string) => void;
+    reset: () => void;
+    getFullText: () => string;
+};

package/dist/types/react-planner/catalog/catalog.d.ts

@@ -50,6 +50,10 @@ export default class Catalog {
     unit: Unit;
     constructor(unit?: Unit);
     getElement(type: string): CatalogElement;
+    /** Every registered element of a prototype ("items", "holes", "lines"),
+     *  regardless of the category it was filed under. Backs the sidebar's
+     *  "similar items" list, which matches on tags rather than category. */
+    getElementsOfPrototype(prototype: string): CatalogElement[];
     getCategory(categoryName: string): CatalogCategory;
     getPropertyType(type: string): any;
     registerElement(json: any): void;

package/dist/types/react-planner/catalog/factories/AreaFactory.d.ts

@@ -1,24 +1 @@
-export default function AreaFactory(name: string, info: any, textures: any): {
-    name: string;
-    prototype: string;
-    info: any;
-    properties: {
-        patternColor: {
-            label: string;
-            type: string;
-            defaultValue: string;
-        };
-        thickness: {
-            label: string;
-            type: string;
-            defaultValue: {
-                length: number;
-                _length: number;
-                _unit: string;
-            };
-        };
-    };
-    render2D: (element: any, layer: any, scene: any) => import("react/jsx-runtime").JSX.Element;
-    render3D: (element: any, layer: any, scene: any) => Promise<import("three").Mesh<import("three").ShapeGeometry, import("three").MeshPhongMaterial, import("three").Object3DEventMap>>;
-    updateRender3D: (element: any, layer: any, scene: any, mesh: any, oldElement: any, differences: any, selfDestroy: any, selfBuild: any) => Promise<import("three").Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>;
-};
+export default function AreaFactory(name: string, info: any, textures: any): any;

package/dist/types/react-planner/catalog/factories/WallFactory.d.ts

@@ -1,26 +1 @@
-export default function WallFactory(name: string, info: any, textures: any): {
-    name: string;
-    prototype: string;
-    info: any;
-    properties: {
-        height: {
-            label: string;
-            type: string;
-            defaultValue: {
-                length: number;
-            };
-        };
-        thickness: {
-            label: string;
-            type: string;
-            defaultValue: {
-                length: number;
-                _length: number;
-                _unit: string;
-            };
-        };
-    };
-    render2D: (element: any, layer: any, scene: any, mode: string) => import("react/jsx-runtime").JSX.Element;
-    render3D: (element: any, layer: any, scene: any) => Promise<import("three").Group<import("three").Object3DEventMap>>;
-    updateRender3D: (element: any, layer: any, scene: any, mesh: any, oldElement: any, differences: any, selfDestroy: any, selfBuild: any) => any;
-};
+export default function WallFactory(name: string, info: any, textures: any): any;

package/dist/types/react-planner/catalog/factories/area-factory-3d.d.ts

@@ -1,4 +1,4 @@
-import { MeshPhongMaterial, ShapeGeometry, Mesh } from "three";
+import { MeshStandardMaterial, ShapeGeometry, Mesh } from "three";
 import * as THREE from "three";
 import type { Layer, Scene } from "../../models";
 type TextureData = {
@@ -13,6 +13,6 @@ type TextureData = {
         heightRepeatScale: number;
     };
 };
-export declare function createArea(element: any, layer: Layer, scene: Scene, textures: Record<string, TextureData>): Promise<Mesh<ShapeGeometry, MeshPhongMaterial, THREE.Object3DEventMap>>;
+export declare function createArea(element: any, layer: Layer, scene: Scene, textures: Record<string, TextureData>): Promise<Mesh<ShapeGeometry, MeshStandardMaterial, THREE.Object3DEventMap>>;
 export declare function updatedArea(element: any, layer: Layer, scene: Scene, textures: Record<string, TextureData>, mesh: Mesh, oldElement: any, differences: string[], selfDestroy: () => void, selfBuild: () => Promise<Mesh>): Promise<Mesh>;
 export {};

package/dist/types/react-planner/catalog/factories/area-patterns.d.ts

@@ -0,0 +1,42 @@
+export interface AreaPattern {
+    key: string;
+    name: string;
+    size: number;
+    /**
+     * Degrees the whole tiling lattice is turned by, SVG-style (positive =
+     * clockwise on screen). Only 45° is periodic under square tiling — see
+     * `patternTileDataURI` — so stick to that or leave it out.
+     */
+    rotation?: number;
+    /**
+     * The tile's contents as raw SVG markup rather than JSX, because the same
+     * string has to serve two very different consumers: React, for the 2D
+     * viewer, and a standalone `<svg>` document rasterized into a Three.js
+     * texture for the 3D viewer. Anything expressible only as React elements
+     * would have to be written twice and would drift.
+     */
+    marks: (color: string) => string;
+}
+export declare function darkenHex(hex: string, factor?: number): string;
+export declare const AREA_PATTERNS: AreaPattern[];
+export declare function getAreaPattern(key: string | undefined): AreaPattern | undefined;
+/** `patternTransform` for the SVG `<pattern>`, or undefined when unrotated. */
+export declare function patternTransform(pattern: AreaPattern): string | undefined;
+/** The marks, for any React consumer that is building an SVG `<pattern>`. */
+export declare function PatternMarks({ pattern, color, }: {
+    pattern: AreaPattern;
+    color: string;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * One tile of `pattern` as an `<svg>` data URI, background included.
+ *
+ * The 3D floor can't hatch a mesh the way SVG hatches a path, so it gets a
+ * texture instead — and the texture is produced by handing the browser the
+ * *same* `<pattern>` element the 2D viewer uses. Rotation, stroke widths and
+ * spacing therefore come out of one renderer, not two approximations of each
+ * other, and the mesh only has to tile the result.
+ */
+export declare function patternTileDataURI(pattern: AreaPattern, background: string, markColor: string): {
+    uri: string;
+    tileSize: number;
+};

package/dist/types/react-planner/catalog/factories/room-types.d.ts

@@ -0,0 +1,22 @@
+export interface RoomType {
+    value: string;
+    label: string;
+    color: string;
+}
+export interface RoomCategory {
+    value: string;
+    label: string;
+    types: RoomType[];
+}
+export declare const ROOM_CATEGORIES: RoomCategory[];
+export declare function getCategory(value: string | undefined): RoomCategory | undefined;
+export declare function getRoomType(categoryValue: string | undefined, typeValue: string | undefined): RoomType | undefined;
+export declare function getRoomTypeLabel(categoryValue: string | undefined, typeValue: string | undefined): string;
+export declare function getRoomTypeColor(categoryValue: string | undefined, typeValue: string | undefined): string | undefined;
+export declare const DEFAULT_ROOM_CATEGORY = "";
+export declare const DEFAULT_ROOM_TYPE = "";
+export type AreaKind = "Room" | "Surface" | "Area";
+export declare function getAreaKind(area: any, layer: any): AreaKind;
+export declare function deriveAreaLabel(area: any, layer: any, opts?: {
+    defaultLabel?: string;
+}): string;

package/dist/types/react-planner/catalog/factories/wall-factory-3d.d.ts

@@ -13,5 +13,5 @@ type TextureInfo = {
     };
 };
 export declare function buildWall(element: any, layer: Layer, scene: Scene, textures: Record<string, TextureInfo>): Promise<Group>;
-export declare function updatedWall(element: any, layer: any, scene: any, textures: any, mesh: any, oldElement: any, differences: any, selfDestroy: any, selfBuild: any): any;
+export declare function updatedWall(element: any, layer: any, scene: any, textures: any, mesh: any, _oldElement: any, differences: any, selfDestroy: any, selfBuild: any): any;
 export {};

package/dist/types/react-planner/class/area.d.ts

@@ -1,6 +1,29 @@
 import { Set } from "immutable";
 declare class Area {
     static getSurfaceLines(state: any, layerID: string, areaID: string): Set<string>;
+    static center(state: any, layerID: string, areaID: string): {
+        x: number;
+        y: number;
+    } | null;
+    static transform(state: any, layerID: string, areaID: string, transform: (point: {
+        x: number;
+        y: number;
+    }) => {
+        x: number;
+        y: number;
+    }): {
+        updatedState: any;
+    };
+    /** Rotate about the area's center. Maths convention: in these y-up scene
+     *  coords a positive angle turns counter-clockwise, which reads *clockwise*
+     *  in the y-flipped 2D view. */
+    static rotate(state: any, layerID: string, areaID: string, degrees: number): {
+        updatedState: any;
+    };
+    /** Mirror about the area's center — "x" flips it left-right, "y" top-bottom. */
+    static mirror(state: any, layerID: string, areaID: string, axis: "x" | "y"): {
+        updatedState: any;
+    };
     static add(state: any, layerID: any, type: any, verticesCoords: any, catalog: any): {
         updatedState: any;
         area: undefined;

package/dist/types/react-planner/class/hole.d.ts

@@ -28,6 +28,16 @@ declare class Hole {
     static endDraggingHole(state: any, x: any, y: any): {
         updatedState: any;
     };
+    static flip(state: any, layerID: any, holeID: any, axis?: "x" | "y"): {
+        updatedState: any;
+    };
+    static duplicate(state: any, layerID: any, holeID: any): {
+        updatedState: any;
+        hole?: undefined;
+    } | {
+        updatedState: any;
+        hole: any;
+    };
     static setProperties(state: any, layerID: any, holeID: any, properties: any): {
         updatedState: any;
     };
@@ -40,6 +50,9 @@ declare class Hole {
     static updateJsProperties(state: any, layerID: any, holeID: any, properties: any): {
         updatedState: any;
     };
+    static mergeAttributes(state: any, layerID: any, holeID: any, attributes: any): {
+        updatedState: any;
+    };
     static setAttributes(state: any, layerID: any, holeID: any, holesAttributes: any): {
         updatedState: any;
     };