@dxos/plugin-illustrator 0.10.0

package/dist/types/src/model/scene.d.ts

@@ -0,0 +1,843 @@
+import * as Schema from 'effect/Schema';
+export declare const Color: Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>;
+export type Color = Schema.Schema.Type<typeof Color>;
+export declare const Fill: Schema.Literal<["none", "solid", "pattern"]>;
+export type Fill = Schema.Schema.Type<typeof Fill>;
+export declare const Stroke: Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>;
+export type Stroke = Schema.Schema.Type<typeof Stroke>;
+export declare const Weight: Schema.Literal<["s", "m", "l", "xl"]>;
+export type Weight = Schema.Schema.Type<typeof Weight>;
+export declare const Point: Schema.Struct<{
+    x: typeof Schema.Number;
+    y: typeof Schema.Number;
+}>;
+export type Point = Schema.Schema.Type<typeof Point>;
+/** Closed shape drawn inside a local bounding box. */
+export declare const Box: Schema.Struct<{
+    color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+    fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+    stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+    weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+    kind: Schema.Literal<["rect", "ellipse", "diamond", "triangle"]>;
+    id: Schema.SchemaClass<string, string, never>;
+    x: Schema.SchemaClass<number, number, never>;
+    y: Schema.SchemaClass<number, number, never>;
+    w: typeof Schema.Number;
+    h: typeof Schema.Number;
+    rotation: Schema.optional<typeof Schema.Number>;
+    text: Schema.optional<typeof Schema.String>;
+}>;
+export type Box = Schema.Schema.Type<typeof Box>;
+/** Circle sugar; reads back as an ellipse. */
+export declare const Circle: Schema.Struct<{
+    color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+    fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+    stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+    weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+    kind: Schema.Literal<["circle"]>;
+    id: Schema.SchemaClass<string, string, never>;
+    cx: Schema.SchemaClass<number, number, never>;
+    cy: Schema.SchemaClass<number, number, never>;
+    r: typeof Schema.Number;
+    text: Schema.optional<typeof Schema.String>;
+}>;
+export type Circle = Schema.Schema.Type<typeof Circle>;
+/** Straight segment or open polyline through the given points. */
+export declare const Polyline: Schema.Struct<{
+    color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+    fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+    stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+    weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+    kind: Schema.Literal<["line"]>;
+    id: Schema.SchemaClass<string, string, never>;
+    points: Schema.Array$<Schema.Struct<{
+        x: typeof Schema.Number;
+        y: typeof Schema.Number;
+    }>>;
+    closed: Schema.optional<typeof Schema.Boolean>;
+}>;
+export type Polyline = Schema.Schema.Type<typeof Polyline>;
+/** Smooth curve through the given points (spline). */
+export declare const Curve: Schema.Struct<{
+    color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+    fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+    stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+    weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+    kind: Schema.Literal<["curve"]>;
+    id: Schema.SchemaClass<string, string, never>;
+    points: Schema.Array$<Schema.Struct<{
+        x: typeof Schema.Number;
+        y: typeof Schema.Number;
+    }>>;
+}>;
+export type Curve = Schema.Schema.Type<typeof Curve>;
+/**
+ * Circular arc sugar; reads back as a curve. Angles are degrees, measured clockwise from
+ * the positive x-axis in screen coordinates (y grows downward): 0–180 is the lower half
+ * (a smile), 180–360 the upper half (a frown).
+ */
+export declare const Arc: Schema.Struct<{
+    color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+    fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+    stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+    weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+    kind: Schema.Literal<["arc"]>;
+    id: Schema.SchemaClass<string, string, never>;
+    cx: typeof Schema.Number;
+    cy: typeof Schema.Number;
+    r: typeof Schema.Number;
+    startAngle: typeof Schema.Number;
+    endAngle: typeof Schema.Number;
+}>;
+export type Arc = Schema.Schema.Type<typeof Arc>;
+/** Free-standing text. */
+export declare const Text: Schema.Struct<{
+    color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+    fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+    stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+    weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+    kind: Schema.Literal<["text"]>;
+    id: Schema.SchemaClass<string, string, never>;
+    x: typeof Schema.Number;
+    y: typeof Schema.Number;
+    w: Schema.optional<typeof Schema.Number>;
+    text: typeof Schema.String;
+}>;
+export type Text = Schema.Schema.Type<typeof Text>;
+/**
+ * Connector. Endpoints are element refs — `"<elementId>"` within the same object or
+ * `"<objectId>/<elementId>"` across objects — or explicit local points. Bound endpoints
+ * track their target when it moves.
+ */
+export declare const Arrow: Schema.Struct<{
+    color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+    fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+    stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+    weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+    kind: Schema.Literal<["arrow"]>;
+    id: Schema.SchemaClass<string, string, never>;
+    from: Schema.optional<typeof Schema.String>;
+    to: Schema.optional<typeof Schema.String>;
+    start: Schema.optional<Schema.Struct<{
+        x: typeof Schema.Number;
+        y: typeof Schema.Number;
+    }>>;
+    end: Schema.optional<Schema.Struct<{
+        x: typeof Schema.Number;
+        y: typeof Schema.Number;
+    }>>;
+    text: Schema.optional<typeof Schema.String>;
+}>;
+export type Arrow = Schema.Schema.Type<typeof Arrow>;
+export declare const Element: Schema.Union<[Schema.Struct<{
+    color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+    fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+    stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+    weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+    kind: Schema.Literal<["rect", "ellipse", "diamond", "triangle"]>;
+    id: Schema.SchemaClass<string, string, never>;
+    x: Schema.SchemaClass<number, number, never>;
+    y: Schema.SchemaClass<number, number, never>;
+    w: typeof Schema.Number;
+    h: typeof Schema.Number;
+    rotation: Schema.optional<typeof Schema.Number>;
+    text: Schema.optional<typeof Schema.String>;
+}>, Schema.Struct<{
+    color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+    fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+    stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+    weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+    kind: Schema.Literal<["circle"]>;
+    id: Schema.SchemaClass<string, string, never>;
+    cx: Schema.SchemaClass<number, number, never>;
+    cy: Schema.SchemaClass<number, number, never>;
+    r: typeof Schema.Number;
+    text: Schema.optional<typeof Schema.String>;
+}>, Schema.Struct<{
+    color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+    fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+    stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+    weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+    kind: Schema.Literal<["line"]>;
+    id: Schema.SchemaClass<string, string, never>;
+    points: Schema.Array$<Schema.Struct<{
+        x: typeof Schema.Number;
+        y: typeof Schema.Number;
+    }>>;
+    closed: Schema.optional<typeof Schema.Boolean>;
+}>, Schema.Struct<{
+    color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+    fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+    stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+    weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+    kind: Schema.Literal<["curve"]>;
+    id: Schema.SchemaClass<string, string, never>;
+    points: Schema.Array$<Schema.Struct<{
+        x: typeof Schema.Number;
+        y: typeof Schema.Number;
+    }>>;
+}>, Schema.Struct<{
+    color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+    fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+    stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+    weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+    kind: Schema.Literal<["arc"]>;
+    id: Schema.SchemaClass<string, string, never>;
+    cx: typeof Schema.Number;
+    cy: typeof Schema.Number;
+    r: typeof Schema.Number;
+    startAngle: typeof Schema.Number;
+    endAngle: typeof Schema.Number;
+}>, Schema.Struct<{
+    color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+    fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+    stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+    weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+    kind: Schema.Literal<["text"]>;
+    id: Schema.SchemaClass<string, string, never>;
+    x: typeof Schema.Number;
+    y: typeof Schema.Number;
+    w: Schema.optional<typeof Schema.Number>;
+    text: typeof Schema.String;
+}>, Schema.Struct<{
+    color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+    fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+    stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+    weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+    kind: Schema.Literal<["arrow"]>;
+    id: Schema.SchemaClass<string, string, never>;
+    from: Schema.optional<typeof Schema.String>;
+    to: Schema.optional<typeof Schema.String>;
+    start: Schema.optional<Schema.Struct<{
+        x: typeof Schema.Number;
+        y: typeof Schema.Number;
+    }>>;
+    end: Schema.optional<Schema.Struct<{
+        x: typeof Schema.Number;
+        y: typeof Schema.Number;
+    }>>;
+    text: Schema.optional<typeof Schema.String>;
+}>]>;
+export type Element = Schema.Schema.Type<typeof Element>;
+/**
+ * A semantic group of elements ("face", "hat") authored in its own local unit space.
+ * `origin` (canvas px) and `scale` (px per unit) place it on the canvas:
+ * `canvas = origin + local * scale`. On read, `origin` is derived as the top-left of the
+ * object's bounding box, so the model survives users dragging shapes around.
+ */
+export declare const WorldObject: Schema.Struct<{
+    id: Schema.SchemaClass<string, string, never>;
+    origin: Schema.optional<Schema.Struct<{
+        x: typeof Schema.Number;
+        y: typeof Schema.Number;
+    }>>;
+    scale: Schema.optional<typeof Schema.Number>;
+    elements: Schema.Array$<Schema.Union<[Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["rect", "ellipse", "diamond", "triangle"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        x: Schema.SchemaClass<number, number, never>;
+        y: Schema.SchemaClass<number, number, never>;
+        w: typeof Schema.Number;
+        h: typeof Schema.Number;
+        rotation: Schema.optional<typeof Schema.Number>;
+        text: Schema.optional<typeof Schema.String>;
+    }>, Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["circle"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        cx: Schema.SchemaClass<number, number, never>;
+        cy: Schema.SchemaClass<number, number, never>;
+        r: typeof Schema.Number;
+        text: Schema.optional<typeof Schema.String>;
+    }>, Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["line"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        points: Schema.Array$<Schema.Struct<{
+            x: typeof Schema.Number;
+            y: typeof Schema.Number;
+        }>>;
+        closed: Schema.optional<typeof Schema.Boolean>;
+    }>, Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["curve"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        points: Schema.Array$<Schema.Struct<{
+            x: typeof Schema.Number;
+            y: typeof Schema.Number;
+        }>>;
+    }>, Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["arc"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        cx: typeof Schema.Number;
+        cy: typeof Schema.Number;
+        r: typeof Schema.Number;
+        startAngle: typeof Schema.Number;
+        endAngle: typeof Schema.Number;
+    }>, Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["text"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        x: typeof Schema.Number;
+        y: typeof Schema.Number;
+        w: Schema.optional<typeof Schema.Number>;
+        text: typeof Schema.String;
+    }>, Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["arrow"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        from: Schema.optional<typeof Schema.String>;
+        to: Schema.optional<typeof Schema.String>;
+        start: Schema.optional<Schema.Struct<{
+            x: typeof Schema.Number;
+            y: typeof Schema.Number;
+        }>>;
+        end: Schema.optional<Schema.Struct<{
+            x: typeof Schema.Number;
+            y: typeof Schema.Number;
+        }>>;
+        text: Schema.optional<typeof Schema.String>;
+    }>]>>;
+}>;
+export type WorldObject = Schema.Schema.Type<typeof WorldObject>;
+export declare const Scene: Schema.Struct<{
+    objects: Schema.Array$<Schema.Struct<{
+        id: Schema.SchemaClass<string, string, never>;
+        origin: Schema.optional<Schema.Struct<{
+            x: typeof Schema.Number;
+            y: typeof Schema.Number;
+        }>>;
+        scale: Schema.optional<typeof Schema.Number>;
+        elements: Schema.Array$<Schema.Union<[Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["rect", "ellipse", "diamond", "triangle"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            x: Schema.SchemaClass<number, number, never>;
+            y: Schema.SchemaClass<number, number, never>;
+            w: typeof Schema.Number;
+            h: typeof Schema.Number;
+            rotation: Schema.optional<typeof Schema.Number>;
+            text: Schema.optional<typeof Schema.String>;
+        }>, Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["circle"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            cx: Schema.SchemaClass<number, number, never>;
+            cy: Schema.SchemaClass<number, number, never>;
+            r: typeof Schema.Number;
+            text: Schema.optional<typeof Schema.String>;
+        }>, Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["line"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            points: Schema.Array$<Schema.Struct<{
+                x: typeof Schema.Number;
+                y: typeof Schema.Number;
+            }>>;
+            closed: Schema.optional<typeof Schema.Boolean>;
+        }>, Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["curve"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            points: Schema.Array$<Schema.Struct<{
+                x: typeof Schema.Number;
+                y: typeof Schema.Number;
+            }>>;
+        }>, Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["arc"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            cx: typeof Schema.Number;
+            cy: typeof Schema.Number;
+            r: typeof Schema.Number;
+            startAngle: typeof Schema.Number;
+            endAngle: typeof Schema.Number;
+        }>, Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["text"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            x: typeof Schema.Number;
+            y: typeof Schema.Number;
+            w: Schema.optional<typeof Schema.Number>;
+            text: typeof Schema.String;
+        }>, Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["arrow"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            from: Schema.optional<typeof Schema.String>;
+            to: Schema.optional<typeof Schema.String>;
+            start: Schema.optional<Schema.Struct<{
+                x: typeof Schema.Number;
+                y: typeof Schema.Number;
+            }>>;
+            end: Schema.optional<Schema.Struct<{
+                x: typeof Schema.Number;
+                y: typeof Schema.Number;
+            }>>;
+            text: Schema.optional<typeof Schema.String>;
+        }>]>>;
+    }>>;
+}>;
+export type Scene = Schema.Schema.Type<typeof Scene>;
+export declare const UpsertObject: Schema.Struct<{
+    op: Schema.Literal<["upsert-object"]>;
+    object: Schema.Struct<{
+        id: Schema.SchemaClass<string, string, never>;
+        origin: Schema.optional<Schema.Struct<{
+            x: typeof Schema.Number;
+            y: typeof Schema.Number;
+        }>>;
+        scale: Schema.optional<typeof Schema.Number>;
+        elements: Schema.Array$<Schema.Union<[Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["rect", "ellipse", "diamond", "triangle"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            x: Schema.SchemaClass<number, number, never>;
+            y: Schema.SchemaClass<number, number, never>;
+            w: typeof Schema.Number;
+            h: typeof Schema.Number;
+            rotation: Schema.optional<typeof Schema.Number>;
+            text: Schema.optional<typeof Schema.String>;
+        }>, Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["circle"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            cx: Schema.SchemaClass<number, number, never>;
+            cy: Schema.SchemaClass<number, number, never>;
+            r: typeof Schema.Number;
+            text: Schema.optional<typeof Schema.String>;
+        }>, Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["line"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            points: Schema.Array$<Schema.Struct<{
+                x: typeof Schema.Number;
+                y: typeof Schema.Number;
+            }>>;
+            closed: Schema.optional<typeof Schema.Boolean>;
+        }>, Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["curve"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            points: Schema.Array$<Schema.Struct<{
+                x: typeof Schema.Number;
+                y: typeof Schema.Number;
+            }>>;
+        }>, Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["arc"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            cx: typeof Schema.Number;
+            cy: typeof Schema.Number;
+            r: typeof Schema.Number;
+            startAngle: typeof Schema.Number;
+            endAngle: typeof Schema.Number;
+        }>, Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["text"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            x: typeof Schema.Number;
+            y: typeof Schema.Number;
+            w: Schema.optional<typeof Schema.Number>;
+            text: typeof Schema.String;
+        }>, Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["arrow"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            from: Schema.optional<typeof Schema.String>;
+            to: Schema.optional<typeof Schema.String>;
+            start: Schema.optional<Schema.Struct<{
+                x: typeof Schema.Number;
+                y: typeof Schema.Number;
+            }>>;
+            end: Schema.optional<Schema.Struct<{
+                x: typeof Schema.Number;
+                y: typeof Schema.Number;
+            }>>;
+            text: Schema.optional<typeof Schema.String>;
+        }>]>>;
+    }>;
+}>;
+export declare const UpsertElements: Schema.Struct<{
+    op: Schema.Literal<["upsert-elements"]>;
+    objectId: typeof Schema.String;
+    elements: Schema.Array$<Schema.Union<[Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["rect", "ellipse", "diamond", "triangle"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        x: Schema.SchemaClass<number, number, never>;
+        y: Schema.SchemaClass<number, number, never>;
+        w: typeof Schema.Number;
+        h: typeof Schema.Number;
+        rotation: Schema.optional<typeof Schema.Number>;
+        text: Schema.optional<typeof Schema.String>;
+    }>, Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["circle"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        cx: Schema.SchemaClass<number, number, never>;
+        cy: Schema.SchemaClass<number, number, never>;
+        r: typeof Schema.Number;
+        text: Schema.optional<typeof Schema.String>;
+    }>, Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["line"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        points: Schema.Array$<Schema.Struct<{
+            x: typeof Schema.Number;
+            y: typeof Schema.Number;
+        }>>;
+        closed: Schema.optional<typeof Schema.Boolean>;
+    }>, Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["curve"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        points: Schema.Array$<Schema.Struct<{
+            x: typeof Schema.Number;
+            y: typeof Schema.Number;
+        }>>;
+    }>, Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["arc"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        cx: typeof Schema.Number;
+        cy: typeof Schema.Number;
+        r: typeof Schema.Number;
+        startAngle: typeof Schema.Number;
+        endAngle: typeof Schema.Number;
+    }>, Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["text"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        x: typeof Schema.Number;
+        y: typeof Schema.Number;
+        w: Schema.optional<typeof Schema.Number>;
+        text: typeof Schema.String;
+    }>, Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["arrow"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        from: Schema.optional<typeof Schema.String>;
+        to: Schema.optional<typeof Schema.String>;
+        start: Schema.optional<Schema.Struct<{
+            x: typeof Schema.Number;
+            y: typeof Schema.Number;
+        }>>;
+        end: Schema.optional<Schema.Struct<{
+            x: typeof Schema.Number;
+            y: typeof Schema.Number;
+        }>>;
+        text: Schema.optional<typeof Schema.String>;
+    }>]>>;
+}>;
+export declare const RemoveElements: Schema.Struct<{
+    op: Schema.Literal<["remove-elements"]>;
+    objectId: typeof Schema.String;
+    elementIds: Schema.Array$<typeof Schema.String>;
+}>;
+export declare const RemoveObject: Schema.Struct<{
+    op: Schema.Literal<["remove-object"]>;
+    objectId: typeof Schema.String;
+}>;
+export declare const MoveObject: Schema.Struct<{
+    op: Schema.Literal<["move-object"]>;
+    objectId: typeof Schema.String;
+    origin: Schema.Struct<{
+        x: typeof Schema.Number;
+        y: typeof Schema.Number;
+    }>;
+}>;
+export declare const Command: Schema.Union<[Schema.Struct<{
+    op: Schema.Literal<["upsert-object"]>;
+    object: Schema.Struct<{
+        id: Schema.SchemaClass<string, string, never>;
+        origin: Schema.optional<Schema.Struct<{
+            x: typeof Schema.Number;
+            y: typeof Schema.Number;
+        }>>;
+        scale: Schema.optional<typeof Schema.Number>;
+        elements: Schema.Array$<Schema.Union<[Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["rect", "ellipse", "diamond", "triangle"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            x: Schema.SchemaClass<number, number, never>;
+            y: Schema.SchemaClass<number, number, never>;
+            w: typeof Schema.Number;
+            h: typeof Schema.Number;
+            rotation: Schema.optional<typeof Schema.Number>;
+            text: Schema.optional<typeof Schema.String>;
+        }>, Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["circle"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            cx: Schema.SchemaClass<number, number, never>;
+            cy: Schema.SchemaClass<number, number, never>;
+            r: typeof Schema.Number;
+            text: Schema.optional<typeof Schema.String>;
+        }>, Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["line"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            points: Schema.Array$<Schema.Struct<{
+                x: typeof Schema.Number;
+                y: typeof Schema.Number;
+            }>>;
+            closed: Schema.optional<typeof Schema.Boolean>;
+        }>, Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["curve"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            points: Schema.Array$<Schema.Struct<{
+                x: typeof Schema.Number;
+                y: typeof Schema.Number;
+            }>>;
+        }>, Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["arc"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            cx: typeof Schema.Number;
+            cy: typeof Schema.Number;
+            r: typeof Schema.Number;
+            startAngle: typeof Schema.Number;
+            endAngle: typeof Schema.Number;
+        }>, Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["text"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            x: typeof Schema.Number;
+            y: typeof Schema.Number;
+            w: Schema.optional<typeof Schema.Number>;
+            text: typeof Schema.String;
+        }>, Schema.Struct<{
+            color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+            fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+            stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+            weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+            kind: Schema.Literal<["arrow"]>;
+            id: Schema.SchemaClass<string, string, never>;
+            from: Schema.optional<typeof Schema.String>;
+            to: Schema.optional<typeof Schema.String>;
+            start: Schema.optional<Schema.Struct<{
+                x: typeof Schema.Number;
+                y: typeof Schema.Number;
+            }>>;
+            end: Schema.optional<Schema.Struct<{
+                x: typeof Schema.Number;
+                y: typeof Schema.Number;
+            }>>;
+            text: Schema.optional<typeof Schema.String>;
+        }>]>>;
+    }>;
+}>, Schema.Struct<{
+    op: Schema.Literal<["upsert-elements"]>;
+    objectId: typeof Schema.String;
+    elements: Schema.Array$<Schema.Union<[Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["rect", "ellipse", "diamond", "triangle"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        x: Schema.SchemaClass<number, number, never>;
+        y: Schema.SchemaClass<number, number, never>;
+        w: typeof Schema.Number;
+        h: typeof Schema.Number;
+        rotation: Schema.optional<typeof Schema.Number>;
+        text: Schema.optional<typeof Schema.String>;
+    }>, Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["circle"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        cx: Schema.SchemaClass<number, number, never>;
+        cy: Schema.SchemaClass<number, number, never>;
+        r: typeof Schema.Number;
+        text: Schema.optional<typeof Schema.String>;
+    }>, Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["line"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        points: Schema.Array$<Schema.Struct<{
+            x: typeof Schema.Number;
+            y: typeof Schema.Number;
+        }>>;
+        closed: Schema.optional<typeof Schema.Boolean>;
+    }>, Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["curve"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        points: Schema.Array$<Schema.Struct<{
+            x: typeof Schema.Number;
+            y: typeof Schema.Number;
+        }>>;
+    }>, Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["arc"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        cx: typeof Schema.Number;
+        cy: typeof Schema.Number;
+        r: typeof Schema.Number;
+        startAngle: typeof Schema.Number;
+        endAngle: typeof Schema.Number;
+    }>, Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["text"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        x: typeof Schema.Number;
+        y: typeof Schema.Number;
+        w: Schema.optional<typeof Schema.Number>;
+        text: typeof Schema.String;
+    }>, Schema.Struct<{
+        color: Schema.optional<Schema.Literal<["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"]>>;
+        fill: Schema.optional<Schema.Literal<["none", "solid", "pattern"]>>;
+        stroke: Schema.optional<Schema.Literal<["sketchy", "solid", "dashed", "dotted"]>>;
+        weight: Schema.optional<Schema.Literal<["s", "m", "l", "xl"]>>;
+        kind: Schema.Literal<["arrow"]>;
+        id: Schema.SchemaClass<string, string, never>;
+        from: Schema.optional<typeof Schema.String>;
+        to: Schema.optional<typeof Schema.String>;
+        start: Schema.optional<Schema.Struct<{
+            x: typeof Schema.Number;
+            y: typeof Schema.Number;
+        }>>;
+        end: Schema.optional<Schema.Struct<{
+            x: typeof Schema.Number;
+            y: typeof Schema.Number;
+        }>>;
+        text: Schema.optional<typeof Schema.String>;
+    }>]>>;
+}>, Schema.Struct<{
+    op: Schema.Literal<["remove-elements"]>;
+    objectId: typeof Schema.String;
+    elementIds: Schema.Array$<typeof Schema.String>;
+}>, Schema.Struct<{
+    op: Schema.Literal<["remove-object"]>;
+    objectId: typeof Schema.String;
+}>, Schema.Struct<{
+    op: Schema.Literal<["move-object"]>;
+    objectId: typeof Schema.String;
+    origin: Schema.Struct<{
+        x: typeof Schema.Number;
+        y: typeof Schema.Number;
+    }>;
+}>]>;
+export type Command = Schema.Schema.Type<typeof Command>;
+//# sourceMappingURL=scene.d.ts.map