venuekit 0.0.0-stage → 0.10.0

package/dist/place-types-CeTjPHTF.d.cts

@@ -0,0 +1,670 @@
+import { z } from 'zod';
+
+/**
+ * Topes de tamaño. El plano llega de afuera (el servidor del host lo valida antes de
+ * guardar), así que todo lo que se expande o se recorre tiene techo.
+ */
+/** Techo de unidades vendibles totales del documento (Σ rows·cols de seatBlocks + Σ places de tables). */
+declare const MAX_UNITS = 100000;
+declare const MAX_ID_LENGTH = 64;
+declare const MAX_NAME_LENGTH = 120;
+declare const MAX_REF_LENGTH = 120;
+declare const MAX_TABLE_LABEL_LENGTH = 20;
+/** `background.src` es una URL (no data URL). */
+declare const MAX_SRC_LENGTH = 4096;
+declare const MAX_ELEMENTS = 5000;
+/** Letras del inicio de fila: "ZZZ" ya da 18.278 filas posibles. */
+declare const MAX_LETTERS_START = 3;
+declare const MAX_SKIP = 100;
+/** Tamaño de un bloque o una mesa respecto del de fábrica: sólo cambia el dibujo, nunca las unidades. */
+declare const MIN_SCALE = 0.4;
+declare const MAX_SCALE = 2;
+/** IDs de elementos. Nunca ":" — es el separador de IDs de unidad. */
+declare const idSchema: z.ZodString;
+/** Sólo pasos de 90°, sentido horario. */
+declare const rotationSchema: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>;
+declare const transformSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    rotation: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>>;
+}, z.core.$strip>;
+/**
+ * Cómo se nombran las filas o las butacas de un bloque. Lo opcional falta en los
+ * planos viejos y vale lo de siempre: `alphabet` "latin" (sin Ñ) y `pattern`
+ * "sequential" (1, 2, 3…). `pattern` sólo vale con números; `alphabet`, sólo con letras.
+ */
+declare const labelRuleSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        letters: "letters";
+        numbers: "numbers";
+    }>;
+    start: z.ZodString;
+    direction: z.ZodEnum<{
+        ltr: "ltr";
+        rtl: "rtl";
+    }>;
+    skip: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    alphabet: z.ZodOptional<z.ZodEnum<{
+        latin: "latin";
+        es: "es";
+    }>>;
+    pattern: z.ZodOptional<z.ZodEnum<{
+        sequential: "sequential";
+        odd: "odd";
+        even: "even";
+        center: "center";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Enlace a un tipo de lugar del host. `name` sirve para re-enlazar planos guardados.
+ * `ref: ""` significa "sin asignar, recuerda el nombre": la pieza no está atada a
+ * ningún tipo, pero conserva cómo se llamaba el que tenía para el próximo re-enlace.
+ */
+declare const placeTypeLinkSchema: z.ZodObject<{
+    ref: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+declare const seatBlockSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"seatBlock">;
+    transform: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        rotation: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>>;
+    }, z.core.$strip>;
+    rows: z.ZodNumber;
+    cols: z.ZodNumber;
+    rowLabels: z.ZodObject<{
+        kind: z.ZodEnum<{
+            letters: "letters";
+            numbers: "numbers";
+        }>;
+        start: z.ZodString;
+        direction: z.ZodEnum<{
+            ltr: "ltr";
+            rtl: "rtl";
+        }>;
+        skip: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        alphabet: z.ZodOptional<z.ZodEnum<{
+            latin: "latin";
+            es: "es";
+        }>>;
+        pattern: z.ZodOptional<z.ZodEnum<{
+            sequential: "sequential";
+            odd: "odd";
+            even: "even";
+            center: "center";
+        }>>;
+    }, z.core.$strip>;
+    seatLabels: z.ZodObject<{
+        kind: z.ZodEnum<{
+            letters: "letters";
+            numbers: "numbers";
+        }>;
+        start: z.ZodString;
+        direction: z.ZodEnum<{
+            ltr: "ltr";
+            rtl: "rtl";
+        }>;
+        skip: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        alphabet: z.ZodOptional<z.ZodEnum<{
+            latin: "latin";
+            es: "es";
+        }>>;
+        pattern: z.ZodOptional<z.ZodEnum<{
+            sequential: "sequential";
+            odd: "odd";
+            even: "even";
+            center: "center";
+        }>>;
+    }, z.core.$strip>;
+    spacing: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>;
+    curve: z.ZodDefault<z.ZodNumber>;
+    scale: z.ZodDefault<z.ZodNumber>;
+    removed: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    placeType: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        ref: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const tableSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"table">;
+    transform: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        rotation: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>>;
+    }, z.core.$strip>;
+    shape: z.ZodEnum<{
+        round: "round";
+        rect: "rect";
+    }>;
+    places: z.ZodNumber;
+    label: z.ZodString;
+    mode: z.ZodEnum<{
+        whole: "whole";
+        perPlace: "perPlace";
+    }>;
+    scale: z.ZodDefault<z.ZodNumber>;
+    placeType: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        ref: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const landmarkSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"landmark">;
+    transform: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        rotation: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>>;
+    }, z.core.$strip>;
+    kind: z.ZodString;
+    name: z.ZodString;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>;
+/** Dónde queda una entrada general en el plano. No tiene lugares: se vende por cantidad. */
+declare const zoneSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"zone">;
+    transform: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        rotation: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>>;
+    }, z.core.$strip>;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    curve: z.ZodDefault<z.ZodNumber>;
+    placeType: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        ref: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const elementSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"seatBlock">;
+    transform: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        rotation: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>>;
+    }, z.core.$strip>;
+    rows: z.ZodNumber;
+    cols: z.ZodNumber;
+    rowLabels: z.ZodObject<{
+        kind: z.ZodEnum<{
+            letters: "letters";
+            numbers: "numbers";
+        }>;
+        start: z.ZodString;
+        direction: z.ZodEnum<{
+            ltr: "ltr";
+            rtl: "rtl";
+        }>;
+        skip: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        alphabet: z.ZodOptional<z.ZodEnum<{
+            latin: "latin";
+            es: "es";
+        }>>;
+        pattern: z.ZodOptional<z.ZodEnum<{
+            sequential: "sequential";
+            odd: "odd";
+            even: "even";
+            center: "center";
+        }>>;
+    }, z.core.$strip>;
+    seatLabels: z.ZodObject<{
+        kind: z.ZodEnum<{
+            letters: "letters";
+            numbers: "numbers";
+        }>;
+        start: z.ZodString;
+        direction: z.ZodEnum<{
+            ltr: "ltr";
+            rtl: "rtl";
+        }>;
+        skip: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        alphabet: z.ZodOptional<z.ZodEnum<{
+            latin: "latin";
+            es: "es";
+        }>>;
+        pattern: z.ZodOptional<z.ZodEnum<{
+            sequential: "sequential";
+            odd: "odd";
+            even: "even";
+            center: "center";
+        }>>;
+    }, z.core.$strip>;
+    spacing: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>;
+    curve: z.ZodDefault<z.ZodNumber>;
+    scale: z.ZodDefault<z.ZodNumber>;
+    removed: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    placeType: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        ref: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"table">;
+    transform: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        rotation: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>>;
+    }, z.core.$strip>;
+    shape: z.ZodEnum<{
+        round: "round";
+        rect: "rect";
+    }>;
+    places: z.ZodNumber;
+    label: z.ZodString;
+    mode: z.ZodEnum<{
+        whole: "whole";
+        perPlace: "perPlace";
+    }>;
+    scale: z.ZodDefault<z.ZodNumber>;
+    placeType: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        ref: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"landmark">;
+    transform: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        rotation: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>>;
+    }, z.core.$strip>;
+    kind: z.ZodString;
+    name: z.ZodString;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"zone">;
+    transform: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        rotation: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>>;
+    }, z.core.$strip>;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    curve: z.ZodDefault<z.ZodNumber>;
+    placeType: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        ref: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>], "type">;
+declare const backgroundSchema: z.ZodObject<{
+    src: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    opacity: z.ZodNumber;
+    locked: z.ZodBoolean;
+}, z.core.$strip>;
+declare const metaSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodLiteral<2>;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    background: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        src: z.ZodString;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        opacity: z.ZodNumber;
+        locked: z.ZodBoolean;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const layoutSchema: z.ZodObject<{
+    meta: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        version: z.ZodLiteral<2>;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        background: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            src: z.ZodString;
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            opacity: z.ZodNumber;
+            locked: z.ZodBoolean;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    elements: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"seatBlock">;
+        transform: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            rotation: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>>;
+        }, z.core.$strip>;
+        rows: z.ZodNumber;
+        cols: z.ZodNumber;
+        rowLabels: z.ZodObject<{
+            kind: z.ZodEnum<{
+                letters: "letters";
+                numbers: "numbers";
+            }>;
+            start: z.ZodString;
+            direction: z.ZodEnum<{
+                ltr: "ltr";
+                rtl: "rtl";
+            }>;
+            skip: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            alphabet: z.ZodOptional<z.ZodEnum<{
+                latin: "latin";
+                es: "es";
+            }>>;
+            pattern: z.ZodOptional<z.ZodEnum<{
+                sequential: "sequential";
+                odd: "odd";
+                even: "even";
+                center: "center";
+            }>>;
+        }, z.core.$strip>;
+        seatLabels: z.ZodObject<{
+            kind: z.ZodEnum<{
+                letters: "letters";
+                numbers: "numbers";
+            }>;
+            start: z.ZodString;
+            direction: z.ZodEnum<{
+                ltr: "ltr";
+                rtl: "rtl";
+            }>;
+            skip: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            alphabet: z.ZodOptional<z.ZodEnum<{
+                latin: "latin";
+                es: "es";
+            }>>;
+            pattern: z.ZodOptional<z.ZodEnum<{
+                sequential: "sequential";
+                odd: "odd";
+                even: "even";
+                center: "center";
+            }>>;
+        }, z.core.$strip>;
+        spacing: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        curve: z.ZodDefault<z.ZodNumber>;
+        scale: z.ZodDefault<z.ZodNumber>;
+        removed: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        placeType: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            ref: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"table">;
+        transform: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            rotation: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>>;
+        }, z.core.$strip>;
+        shape: z.ZodEnum<{
+            round: "round";
+            rect: "rect";
+        }>;
+        places: z.ZodNumber;
+        label: z.ZodString;
+        mode: z.ZodEnum<{
+            whole: "whole";
+            perPlace: "perPlace";
+        }>;
+        scale: z.ZodDefault<z.ZodNumber>;
+        placeType: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            ref: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"landmark">;
+        transform: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            rotation: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>>;
+        }, z.core.$strip>;
+        kind: z.ZodString;
+        name: z.ZodString;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"zone">;
+        transform: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            rotation: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>>;
+        }, z.core.$strip>;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        curve: z.ZodDefault<z.ZodNumber>;
+        placeType: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            ref: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+/** Opciones de parseo con mensajes en español. Por parse, sin tocar la config global de Zod. */
+declare const spanishParseOptions: {
+    error: z.core.$ZodErrorMap<z.core.$ZodIssue>;
+};
+type Rotation = z.infer<typeof rotationSchema>;
+type Transform = z.infer<typeof transformSchema>;
+type LabelRule = z.infer<typeof labelRuleSchema>;
+type PlaceTypeLink = z.infer<typeof placeTypeLinkSchema>;
+type SeatBlock = z.infer<typeof seatBlockSchema>;
+type Table = z.infer<typeof tableSchema>;
+type Landmark = z.infer<typeof landmarkSchema>;
+type Zone = z.infer<typeof zoneSchema>;
+type Element = z.infer<typeof elementSchema>;
+type Background = z.infer<typeof backgroundSchema>;
+type Layout = z.infer<typeof layoutSchema>;
+
+type Point = {
+    x: number;
+    y: number;
+};
+type Box = {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+};
+/** Rota alrededor de (0,0) por `rotation` grados (horario, eje y hacia abajo) y traslada. */
+declare function applyTransform(p: Point, t: Transform): Point;
+declare function bbox(points: Point[]): Box;
+/** Ray casting. */
+declare function pointInPolygon(p: Point, polygon: [number, number][]): boolean;
+declare function distance(a: Point, b: Point): number;
+
+type SellableUnit = {
+    id: string;
+    label: string;
+    kind: "seat" | "place" | "table";
+    x: number;
+    y: number;
+    elementId: string;
+    /** Tipo de lugar del host al que está atada la pieza; null = "Sin asignar". */
+    placeTypeRef: string | null;
+    row?: string;
+    seat?: string;
+    rowIndex?: number;
+    colIndex?: number;
+    /** Etiqueta de la mesa ("4"), tanto en mesa entera como en sus lugares. */
+    table?: string;
+    place?: number;
+};
+declare function expandSeatBlock(block: SeatBlock): SellableUnit[];
+declare const TABLE_RADIUS = 30;
+declare const TABLE_WIDTH = 80;
+declare const TABLE_HEIGHT = 40;
+/** Distancia entre el borde de la mesa y el centro del lugar. */
+declare const PLACE_OFFSET = 10;
+declare function expandTable(table: Table): SellableUnit[];
+/** Las zonas no generan unidades: una entrada general se vende por cantidad, no por lugar. */
+declare function expand(layout: Layout): SellableUnit[];
+
+/**
+ * Qué parte de lo vendido tocaría el cambio: una por mesa y una por (bloque, fila),
+ * no una por butaca, porque es lo que la persona entiende ("la mesa 4", "la fila C").
+ */
+type LockViolation = {
+    reason: "table";
+    table: string;
+} | {
+    reason: "row";
+    row: string;
+    elementId: string;
+};
+/**
+ * IDs bloqueados (vendidos) que `after` haría desaparecer, cambiar de etiqueta, pasar
+ * a otro tipo de lugar o cambiar de lugar físico adentro de la pieza (renumerar
+ * empezando en otra letra o número, saltear, invertir el sentido). Mover, girar,
+ * escalar o curvar la pieza entera no cambia nada de eso y no viola nada.
+ * Las zonas no cuentan: no tienen unidades vendidas por lugar.
+ * Orden estable: el del documento `before`.
+ */
+declare function findLockViolations(before: Layout, after: Layout, locked: ReadonlySet<string>): LockViolation[];
+
+type PieceKind = "seatBlock" | "roundTable" | "rectTable" | "zone" | `landmark:${string}`;
+type PieceOptions = {
+    seats?: number;
+};
+declare const DEFAULT_BLOCK: {
+    rows: number;
+    cols: number;
+};
+declare const DEFAULT_TABLE_PLACES = 6;
+declare const DEFAULT_ZONE: {
+    width: number;
+    height: number;
+};
+/** "b-1", "b-2"… el primero libre del prefijo. */
+declare function newElementId(layout: Layout, prefix: "b" | "m" | "r" | "z"): string;
+/**
+ * Cuánto mide una mesa de `places` lugares. La medida sale de la cantidad de gente:
+ * en redonda los lugares van sobre la circunferencia (el radio crece con el perímetro);
+ * en rectangular, repartidos arriba y abajo (crece el ancho).
+ */
+declare function tableSize(shape: Table["shape"], places: number): {
+    radius: number;
+} | {
+    width: number;
+    height: number;
+};
+/**
+ * Filas y columnas de un bloque de `seats` butacas, de hasta 10 por fila (12 si divide justo).
+ * Si ninguna medida divide justo, filas de 10 y se sacan las últimas de la última fila:
+ * las butacas vivas son siempre `seats`. `removed` usa los ids de unidad del bloque `blockId`
+ * con la numeración por defecto (filas A, B…; butacas 1, 2…).
+ */
+declare function blockShape(seats: number, blockId: string): {
+    rows: number;
+    cols: number;
+    removed: string[];
+};
+/** Pieza nueva centrada en `at` (las mesas, zonas y referencias se anclan por el centro; el bloque, por su primera butaca). */
+declare function createPiece(kind: PieceKind, id: string, at: Point, layout: Layout, opts?: PieceOptions): Element;
+/**
+ * Copia corrida a la derecha, con otro id. La mesa toma el primer número libre y
+ * el bloque sigue la numeración de filas (B termina en F → la copia empieza en G),
+ * así quien compra no ve dos "fila A, butaca 1". Los huecos se copian fila por fila.
+ */
+declare function duplicatePiece(el: Element, id: string, layout: Layout): Element;
+declare function rotatePiece(el: Element): Element;
+declare function toggleRemovedSeat(block: SeatBlock, unitId: string): SeatBlock;
+/** El tamaño al paso más cercano (0.05 = 5 %), dentro de lo que acepta el esquema. */
+declare function snapScale(scale: number, step?: number): number;
+/**
+ * La pieza con otro tamaño y el mismo centro: crece o se achica en su lugar, no
+ * hacia un costado. El bloque se ancla en su primera butaca, así que hay que
+ * correrlo; la mesa ya se ancla en su centro.
+ */
+declare function scalePiece<T extends SeatBlock | Table>(el: T, scale: number): T;
+
+type PlaceTypeAccepts = "seats" | "tableWhole" | "tablePerPlace" | "zone";
+type PlaceTypeOption = {
+    ref: string;
+    label: string;
+    color: string;
+    accepts: PlaceTypeAccepts;
+    /**
+     * Los cupos de los lotes, en cualquier orden. Ausente o vacío = sin tope. El tope es
+     * el mayor y cada bloque nuevo completa el tramo siguiente. Si los cupos del host
+     * SUMAN (lotes de 30, 50 y 100 = 180 lugares), pasá las sumas acumuladas: [30, 80, 180].
+     */
+    capacitySteps?: readonly number[];
+};
+declare function canAssign(el: Element, option: PlaceTypeOption): boolean;
+/** El tope de lugares del tipo: el mayor de sus cupos. `null` = sin tope. */
+declare function placeTypeCapacity(option: PlaceTypeOption): number | null;
+/**
+ * Cuántos lugares trae el próximo bloque. Con lotes de cupos distintos va de a tramos
+ * (30 / 50 / 100 → 30, 20, 50): cada bloque completa el lote siguiente. 0 = ya está todo.
+ */
+declare function nextBlockUnits(option: PlaceTypeOption, placed: number): number;
+type CapacityViolation = {
+    ref: string;
+    label: string;
+    capacity: number;
+    units: number;
+};
+/**
+ * Los tipos que el cambio deja por encima de su cupo. Sólo cuenta lo que SUBE: un plano
+ * que ya venía pasado (el host bajó un cupo) se puede seguir editando, achicar o mover.
+ */
+declare function capacityViolations(before: Layout, after: Layout, options: readonly PlaceTypeOption[]): CapacityViolation[];
+/** Asigna (o con `null` quita) el tipo de lugar. La mesa toma el modo del tipo. */
+declare function assignPlaceType(el: SeatBlock, option: PlaceTypeOption | null): SeatBlock;
+declare function assignPlaceType(el: Table, option: PlaceTypeOption | null): Table;
+declare function assignPlaceType(el: Zone, option: PlaceTypeOption | null): Zone;
+declare function assignPlaceType(el: SeatBlock | Table | Zone, option: PlaceTypeOption | null): SeatBlock | Table | Zone;
+/**
+ * Re-enlaza un plano guardado a los tipos de lugar del evento actual, por nombre.
+ * Los refs viejos son de otro evento: se pisan siempre. Lo que no encuentra una única
+ * opción compatible queda sin asignar (`ref: ""`) pero recuerda el nombre.
+ */
+declare function rebindPlaceTypes(layout: Layout, options: readonly PlaceTypeOption[]): Layout;
+type PlanSummary = {
+    seats: number;
+    tables: number;
+    places: number;
+    /** Zonas de entradas generales: no suman unidades, se venden por cantidad. */
+    zones: number;
+    types: number;
+    unassignedPieces: number;
+    byRef: Record<string, {
+        units: number;
+        seats: number;
+        tables: number;
+        places: number;
+        zones: number;
+        /**
+         * Nombres repetidos adentro de este tipo: quien compra vería dos "fila A, butaca 1"
+         * o dos "mesa 4". `seats` como `"fila:butaca"` (`"A:1"`), `tables` por número. El host
+         * no debería dejar publicar con algo acá.
+         */
+        duplicates: {
+            seats: string[];
+            tables: string[];
+        };
+    }>;
+};
+declare function summarize(layout: Layout): PlanSummary;
+
+export { findLockViolations as $, type Table as A, type Box as B, type CapacityViolation as C, DEFAULT_BLOCK as D, type Element as E, type Transform as F, applyTransform as G, assignPlaceType as H, backgroundSchema as I, bbox as J, blockShape as K, type LabelRule as L, MAX_ELEMENTS as M, canAssign as N, capacityViolations as O, type Point as P, createPiece as Q, type Rotation as R, type SellableUnit as S, TABLE_HEIGHT as T, distance as U, duplicatePiece as V, elementSchema as W, expand as X, expandSeatBlock as Y, type Zone as Z, expandTable as _, type Layout as a, idSchema as a0, labelRuleSchema as a1, landmarkSchema as a2, layoutSchema as a3, metaSchema as a4, newElementId as a5, nextBlockUnits as a6, placeTypeCapacity as a7, placeTypeLinkSchema as a8, pointInPolygon as a9, rebindPlaceTypes as aa, rotatePiece as ab, rotationSchema as ac, scalePiece as ad, seatBlockSchema as ae, snapScale as af, spanishParseOptions as ag, summarize as ah, tableSchema as ai, tableSize as aj, toggleRemovedSeat as ak, transformSchema as al, zoneSchema as am, type Background as b, DEFAULT_TABLE_PLACES as c, DEFAULT_ZONE as d, type Landmark as e, type LockViolation as f, MAX_ID_LENGTH as g, MAX_LETTERS_START as h, MAX_NAME_LENGTH as i, MAX_REF_LENGTH as j, MAX_SCALE as k, MAX_SKIP as l, MAX_SRC_LENGTH as m, MAX_TABLE_LABEL_LENGTH as n, MAX_UNITS as o, MIN_SCALE as p, PLACE_OFFSET as q, type PieceKind as r, type PieceOptions as s, type PlaceTypeAccepts as t, type PlaceTypeLink as u, type PlaceTypeOption as v, type PlanSummary as w, type SeatBlock as x, TABLE_RADIUS as y, TABLE_WIDTH as z };