@adatechnology/game-floorplan 0.3.0 → 0.3.2

package/dist/index.d.ts

@@ -65,7 +65,8 @@ declare function palette(o?: PaletteOptions): Palette;
 type Rect = [number, number, number, number];
 type Vec2 = [number, number];
 type Weights = Record<string, number>;
-type Json = any;
+/** An open value from a template or a plugin: narrow it before use. */
+type Json = unknown;
 type MeshFront = '+z' | '-z' | '+x' | '-x';
 type Mount = 'ceiling' | 'wall' | 'window' | 'support' | 'floor' | 'roof' | 'ground' | 'wall_top' | (string & {});
 /** How an item is coloured: a palette role, a fixed colour, or a seeded pick from a list. */
@@ -134,6 +135,10 @@ interface SlotDef {
     facing?: FacingRule;
     target?: string;
     slide?: number;
+    /** Parent slot id of an `on`/`inside` slot (copied from `on` when the room's slots are expanded). */
+    parent?: string;
+    /** The slot may sit over door and stair swing zones. */
+    floorFree?: boolean;
     [extra: string]: Json;
 }
 type SlotLibrary = SlotDef[] | ((room: {
@@ -273,7 +278,7 @@ interface TemplateDef {
         veranda?: boolean;
         steelDoor?: boolean;
     };
-    facadeExtra?: (facade: Json, rng: Rng, w: number, d: number, o: FloorplanOptions) => void;
+    facadeExtra?: (facade: Facade, rng: Rng, w: number, d: number, o: FloorplanOptions) => void;
     building?: (w: number, d: number, o: FloorplanOptions) => Json;
     singleFloor?: boolean;
     /** Place tag of the building for finds (`house`, `pharmacy`...). */
@@ -297,14 +302,14 @@ interface TemplateDef {
     reservations?: (plan: Plan) => void;
     /** Own paths from the doors that sit away from the building edge (tents); replaces the generated ones. */
     paths?: (plan: Plan, context: {
-        gates: Json[];
+        gates: PlanGate[];
         setback: number;
         marginLeft: number;
         marginRight: number;
         backyard: number;
         w: number;
         d: number;
-    }) => Json[];
+    }) => LotPath[];
     /** Sides built against a neighbour (`left` / `right`): exempt from the side setback. */
     partyWalls?: ('left' | 'right')[];
     options?: Json;
@@ -350,13 +355,13 @@ interface CarClearance {
 interface ResultExtensionContext {
     plan: Plan;
     /** The result built so far: the plan, the items, the state items and the extensions that ran before. */
-    result: Json;
+    result: FloorplanResult;
     seed: number | string;
     /** Seeded stream of the extension: `createRng(seed, seedKey ?? name)`. */
     rng: Rng;
     options: FloorplanOptions;
 }
-type ResultExtensionRun = (context: ResultExtensionContext) => Json;
+type ResultExtensionRun = (context: ResultExtensionContext) => unknown;
 interface ResultExtensionOptions {
     /** Extensions that must run first. */
     after?: string[];
@@ -440,6 +445,156 @@ interface Room {
     seedKey?: string;
     ground?: string;
 }
+/** Axis a wall or opening runs along: `u` is across the lot (x), `v` is front to back (z). */
+type PlanAxis = 'u' | 'v';
+/** A door placed on a wall of one storey (`Plan.doors`). */
+interface PlanDoor {
+    id: string;
+    floor: number;
+    u: number;
+    v: number;
+    axis: PlanAxis;
+    /** Position of the wall line on the other axis. */
+    pos: number;
+    /** Centre of the door along the wall. */
+    at: number;
+    width: number;
+    /** Room on each side; `b` is `outside` on an exterior door. */
+    a: string;
+    b: string;
+    opensTo: string;
+    exterior: boolean;
+    side: string | null;
+    leaves: number;
+    model: string;
+    type: string;
+    steps: number;
+    hinge: string;
+    /** Swing areas on both sides that furniture keeps clear of. */
+    zones: Rect[];
+    /** Left open (set by a house state). */
+    open?: boolean;
+    /** Blocked shut, e.g. barricaded (set by a house state). */
+    blocked?: boolean;
+}
+/** One straight piece of wall or railing of one storey (`Plan.walls`). */
+interface PlanWall {
+    floor: number;
+    axis: PlanAxis;
+    u0: number;
+    v0: number;
+    u1: number;
+    v1: number;
+    thickness: number;
+    /** Room ids on each face (`outside` for the street side). */
+    sides: [string, string];
+    exterior: boolean;
+    type: 'railing' | 'wall';
+    /** Height in metres (the storey ceiling for a full wall). */
+    h: number;
+}
+/** A window on an exterior wall (`Plan.windows`). */
+interface PlanWindow {
+    id: string;
+    floor: number;
+    u: number;
+    v: number;
+    axis: PlanAxis;
+    pos: number;
+    at: number;
+    width: number;
+    /** Sill and head heights above the storey floor. */
+    y0: number;
+    y1: number;
+    room: string;
+    side: string;
+    /** Boarded up (set by a house state). */
+    boards?: boolean;
+}
+/** A gate in the lot boundary (`Plan.gates`). */
+interface PlanGate {
+    id: string;
+    type: string;
+    model: string;
+    u: number;
+    v: number;
+    axis: PlanAxis;
+    width: number;
+    height: number;
+    side: string;
+    /** What the gate leads to (`door`, `inner_garage`...), or null. */
+    to: string | null;
+    material: string;
+    zones: Rect[];
+    /** Starts open (set by a template or a later pass). */
+    open?: boolean;
+}
+/** A door or a lot gate: anything a path or the furniture fill has to keep clear. */
+type PlanOpening = PlanDoor | PlanGate;
+/** A walkway or driveway across the lot (`Plan.paths`). */
+interface LotPath {
+    id: string;
+    type: 'pedestrian' | 'vehicle' | string;
+    /** Gate the path starts at, or null when it starts at no gate. */
+    from: string | null;
+    to: string;
+    width: number;
+    rects: Rect[];
+    points: Vec2[];
+}
+/** How one side of the lot is closed (wall, fence or railing). */
+interface LotBoundary {
+    type: string;
+    material: string;
+    height: number;
+    top: string;
+    totalHeight: number;
+    thickness: number;
+}
+/** One straight piece of the lot boundary. */
+interface LotPerimeterPiece extends LotBoundary {
+    id: string;
+    side: string;
+    u0: number;
+    v0: number;
+    u1: number;
+    v1: number;
+}
+/** The lot around the building (`Plan.lot`). */
+interface Lot {
+    rect: Rect;
+    setback: number;
+    sideYard: {
+        left: number;
+        right: number;
+    };
+    backyard: number;
+    style: string;
+    zones: Room[];
+    perimeter: LotPerimeterPiece[];
+    gates: PlanGate[];
+    paths: LotPath[];
+    pool: boolean;
+}
+/** The known fields of a facade. */
+interface FacadeFields {
+    style: string;
+    color: {
+        name: string;
+        hex: string;
+    };
+    finish: string;
+    grilles: boolean;
+    roof: string;
+    balcony: boolean;
+    veranda: boolean;
+    steelDoor: boolean;
+    floors: number;
+}
+/** The look of the building from the street (`Plan.facade`); templates may add fields through `facadeExtra`. */
+interface Facade extends FacadeFields {
+    [extra: string]: unknown;
+}
 interface Plan {
     w: number;
     d: number;
@@ -455,13 +610,13 @@ interface Plan {
     }[];
     rooms: Room[];
     zones: Room[];
-    doors: Json[];
-    windows: Json[];
-    walls: Json[];
-    gates: Json[];
-    paths: Json[];
-    lot: Json;
-    facade?: Json;
+    doors: PlanDoor[];
+    windows: PlanWindow[];
+    walls: PlanWall[];
+    gates: PlanGate[];
+    paths: LotPath[];
+    lot: Lot | null;
+    facade?: Facade;
     openPairs: Record<number, [string, string][]>;
     zoning?: ZoningReport;
     /** Lot areas the building keeps out of the fill (set by `TemplateDef.reservations`). */
@@ -475,7 +630,16 @@ interface Plan {
     playerRadius: number;
     carClearance: CarClearance;
 }
-interface Slot {
+/** Where a resolved slot sits inside the room: its cell, facing, the room part and the walls it leans on. */
+interface SlotCell {
+    rect: Rect;
+    f: Vec2;
+    enclosed: string[];
+    R: Rect;
+    size: Vec2;
+}
+/** The known fields of a resolved slot. */
+interface SlotFields {
     id: string;
     room: string;
     floor: number;
@@ -483,11 +647,35 @@ interface Slot {
     anchor: string;
     side: string | null;
     cats: Weights;
+    slide?: number;
+    required: boolean;
+    chance: number;
+    clearance: number;
+    front: string;
+    group: string | null;
+    requires: string | null;
+    /** Parent slot of an `on`/`inside` slot. */
+    on: string | null;
+    target: string | null;
     valid: boolean;
     reason: string | null;
+    x: number;
+    z: number;
+    ry: number;
+    w: number;
+    d: number;
+    frontU: number;
+    frontV: number;
+    aabb: Rect;
+    /** Null on an invalid slot. */
+    _cell: SlotCell | null;
+}
+/** A slot of a room after it has been placed (`resolveSlot`); a library may carry fields of its own. */
+interface Slot extends SlotFields {
     [extra: string]: Json;
 }
-interface PlacedItem {
+/** The known fields of a placed item (`PlacedItem` without its open extras). */
+interface PlacedItemFields {
     id: string;
     type: string;
     category: string;
@@ -503,8 +691,149 @@ interface PlacedItem {
     outdoor: boolean;
     aabb: Rect;
     color?: number | string;
+    /** Facing of the item's front. */
+    frontU?: number;
+    frontV?: number;
+    /** Slot that placed it, and the item it stands on or in. */
+    slot?: string;
+    on?: string | null;
+    mode?: 'on' | 'inside' | null;
+    clearance?: number;
+    flat?: boolean;
+    low?: boolean;
+    decor?: boolean;
+    overhead?: boolean;
+    /** Driver side of a car (unit vector). */
+    driver?: Vec2;
+    carClearance?: CarClearance;
+    /** Storeys a stair or passage room connects, or the id of the item this one serves (a gas cylinder names its stove). */
+    link?: {
+        from: number;
+        to: number;
+    } | string;
+    /** Unrounded footprint used by the fill, dropped from the result. */
+    _r?: Rect;
+    _seedId?: string;
+    /** Where a decor item hangs (`floor`, `wall`...). */
+    mount?: Mount;
+    /** Colour rule set by a plugin; replaced by `color` in the result. */
+    colorSpec?: ItemColor;
+}
+/** An item placed by the fill, a decor pass or a state plugin; plugins may add fields of their own. */
+interface PlacedItem extends PlacedItemFields {
     [extra: string]: Json;
 }
+/** A storey of the result. */
+interface ResultFloor {
+    index: number;
+    label?: string;
+    name?: string;
+    number?: number;
+    y0: number;
+    ceiling: number;
+}
+/** A room of the result, with its first part spread as `u0..v1` and the colour roles of its wall and floor. */
+interface ResultRoom {
+    id: string;
+    type: string;
+    label?: string;
+    name?: string;
+    floor: number;
+    u0: number;
+    v0: number;
+    u1: number;
+    v1: number;
+    parts: Rect[];
+    link: number[] | null;
+    ceiling: number;
+    color: {
+        wall: string;
+        floor: string;
+    };
+}
+/** A gate of the result lot. */
+interface ResultGate extends Omit<PlanGate, 'zones' | 'open'> {
+    open: boolean;
+    color: string;
+}
+/** The lot of the result (null for apartments). */
+interface ResultLot {
+    rect: Rect;
+    setback: number;
+    backyard: number;
+    sideYard: {
+        left: number;
+        right: number;
+    };
+    style: string;
+    pool: boolean;
+    zones: {
+        id: string;
+        type: string;
+        label?: string;
+        name?: string;
+        parts: Rect[];
+        ground?: string;
+    }[];
+    perimeter: (LotPerimeterPiece & {
+        color: string;
+    })[];
+    gates: ResultGate[];
+    paths: LotPath[];
+}
+/** The facade of the result: the plan facade with the palette colour and the colour roles. */
+interface ResultFacade extends Omit<FacadeFields, 'color'> {
+    color: {
+        name?: string;
+        key: string;
+        hex: string;
+    };
+    roles: Record<string, string>;
+    [extra: string]: unknown;
+}
+/** An item of the result: the placed item without its internal fields, with its colour role or value. */
+interface ResultItem extends Omit<PlacedItemFields, '_r' | '_seedId' | 'colorSpec'> {
+    [extra: string]: unknown;
+}
+/** The known fields of a `generate` result. */
+interface FloorplanResultFields {
+    template: string;
+    name: string;
+    use: string;
+    seed: number | string;
+    style: string;
+    state: string;
+    locale?: string;
+    w: number;
+    d: number;
+    floors: ResultFloor[];
+    rooms: ResultRoom[];
+    walls: PlanWall[];
+    doors: PlanDoor[];
+    windows: PlanWindow[];
+    openPairs: [string, string][];
+    facade: ResultFacade;
+    lot: ResultLot | null;
+    items: ResultItem[];
+    stateItems: ResultItem[];
+    colors: Palette;
+    /** Output of `TemplateDef.building`. */
+    building: Json;
+    missing: {
+        room: string;
+        slot: string;
+    }[];
+    /** Storey of an apartment unit. */
+    floorNumber?: number;
+    partyWalls: string[];
+    /** Output of `TemplateDef.config`. */
+    config?: Json;
+    zoning?: ZoningReport;
+}
+/** What `generate` returns. Result extensions add their output under their own name. */
+interface FloorplanResult extends FloorplanResultFields {
+    [extension: string]: unknown;
+}
 interface ZoneDef {
     id: string;
     /** Generic use strings: `residential_single`, `residential_multi`, `commercial`, `mixed`, `industrial`... */
@@ -566,13 +895,39 @@ interface StatePlugin {
     /** Adjusts the palette roles (HSL) before the contrast rules run. */
     adjustPalette?(roles: Record<string, Hsl>): void;
 }
+/** Walkability grid of a room (`createGrid`): cells of `gs` metres, the walkable ones and the entry cells. */
+interface WalkGrid {
+    gs: number;
+    u0: number;
+    v0: number;
+    nx: number;
+    nz: number;
+    inside: Uint8Array;
+    entries: [number, number][];
+    center: [number, number];
+}
+/** Options of `PlacementContext.placeOnFloor`. */
+interface PlaceOnFloorOptions {
+    /** Treat the item as flat (no clearance or walkability check). */
+    flat?: boolean;
+    /** Candidate rectangles to try instead of the corners and walls. */
+    cands?: Rect[];
+    /** Footprint to use instead of the catalogue size. */
+    dim?: readonly number[];
+    /** Try the candidates in order instead of shuffled. */
+    ordered?: boolean;
+    /** Rejects a candidate. */
+    without?: (rect: Rect) => boolean;
+    /** Walkability grid to check instead of the room's. */
+    railing?: WalkGrid;
+}
 interface PlacementContext {
-    make(room: Room, type: string, rect: Rect, front: Vec2, extra?: Json): PlacedItem;
+    make(room: Room, type: string, rect: Rect, front: Vec2, extra?: Partial<PlacedItem>): PlacedItem;
     add(item: PlacedItem): PlacedItem;
-    placeOnFloor(room: Room, type: string, rng: Rng, opts?: Json): Rect | null;
+    placeOnFloor(room: Room, type: string, rng: Rng, opts?: PlaceOnFloorOptions): Rect | null;
     itemsOfRoom(room: Room): PlacedItem[];
     solidsOfRoom(room: Room): Rect[];
-    gridOf(room: Room): Json;
+    gridOf(room: Room): WalkGrid;
     extraSolids: Record<string, Rect[]>;
     roomById(id: string): Room | undefined;
     setIgnored(ids: Set<string> | null): void;
@@ -592,11 +947,11 @@ interface PlacementKit {
     insideUnion(r: Rect, inners: Rect[]): boolean;
     usableParts(room: Room, extra?: number): Rect[];
     zonesOfFloor(plan: Plan, floor: number): Rect[];
-    windowsOfRoom(plan: Plan, room: Room): Json[];
-    windowZone(j: Json, outside?: boolean): Rect;
+    windowsOfRoom(plan: Plan, room: Room): PlanWindow[];
+    windowZone(j: Pick<PlanWindow, 'width' | 'side' | 'u' | 'v' | 'axis'>, outside?: boolean): Rect;
     roomAt(plan: Plan, u: number, v: number, floor: number): Room | null;
-    reachable(grid: Json, solids: Rect[], inflation: number): boolean;
-    createGrid(plan: Plan, room: Room, ignored?: Set<string> | null): Json;
+    reachable(grid: WalkGrid, solids: Rect[], inflation: number): boolean;
+    createGrid(plan: Plan, room: Room, ignored?: Set<string> | null): WalkGrid;
     clearRect(r: Rect, f: Vec2, clearance: number): Rect;
     pickWeighted(rng: Rng, w: Weights): string;
     createRng(seed: number | string, key: string): Rng;
@@ -605,7 +960,7 @@ interface PlacementKit {
     shuffle<T>(a: T[], rng: Rng): T[];
     facingRotation(f: Vec2, type: string): number;
     cutIntervals(intervals: [number, number][], a: number, b: number): [number, number][];
-    blocksWindow(it: FurnitureDef, j: Json, overheadOff?: boolean): boolean;
+    blocksWindow(it: FurnitureDef, j: Pick<PlanWindow, 'y0'>, overheadOff?: boolean): boolean;
 }
 interface DecorPassContext {
     plan: Plan;
@@ -660,7 +1015,8 @@ interface FloorplanLocale {
 interface ViewerLayerContext {
     /** Canvas 2D context, already in CSS pixels. */
     g: CanvasRenderingContext2D;
-    plan: Json;
+    /** The `generate` result being drawn. */
+    plan: FloorplanResult;
     /** Storey being drawn (0 when `all`). */
     floor: number;
     /** All storeys at once (the lot view). */
@@ -685,7 +1041,7 @@ interface ViewerLayer {
     label: string;
     defaultOn?: boolean;
     draw(context: ViewerLayerContext): void;
-    legend?(plan: Json): ViewerLayerLegendEntry[];
+    legend?(plan: FloorplanResult): ViewerLayerLegendEntry[];
 }
 
 /** What a container holds, from the first registered provider that answers (`null` passes to the next); none answering means nothing. */
@@ -693,12 +1049,17 @@ declare function findsFor(query: FindsQuery): readonly FindStack[];
 /** Like `findsFor`, but `null` when no provider answered, so a pack can fall back to its own default. */
 declare function findsAnswer(query: FindsQuery): readonly FindStack[] | null;
 
+/** A recorded slot: the resolved slot without its internal fields, with the category names only. */
+interface RecordedSlot extends Omit<SlotFields, '_cell' | 'cats'> {
+    cats: string[];
+    [extra: string]: unknown;
+}
 /** Recorded slots (resolved positions) of every storey and of the lot. */
-declare function slots(template: string | TemplateDef, options?: FloorplanOptions): Json[];
+declare function slots(template: string | TemplateDef, options?: FloorplanOptions): RecordedSlot[];
 /** Generates a plan: building, lot, seeded item fill, decor, house state and palette. */
-declare function generate(template: string | TemplateDef, options?: FloorplanOptions): Json;
+declare function generate(template: string | TemplateDef, options?: FloorplanOptions): FloorplanResult;
 /** Validates a result of `generate`; returns a list of messages (empty when valid). */
-declare function validate(result: Json, options?: {
+declare function validate(result: FloorplanResult, options?: {
     locale?: string;
 }): string[];
 /** Size limits and default size of a template (they can depend on options such as `tier`). */
@@ -728,7 +1089,7 @@ declare function listTemplates(locale?: string): {
     floors: number;
     floorRange: [number, number] | null;
     lot: boolean;
-    options: any;
+    options: {};
 }[];
 
 declare const overlaps: (a: Rect, b: Rect, e?: number) => boolean;
@@ -742,11 +1103,11 @@ declare const listLocales: () => string[];
 declare function translate(ns: Namespace, key: string, locale?: string, vars?: Record<string, string | number>): string;
 
 /** Keep-out zone of a window (inside, or outside for the lot). */
-declare function windowZone(j: Json, outside?: boolean): Rect;
+declare function windowZone(j: Pick<PlanWindow, 'width' | 'side' | 'u' | 'v' | 'axis'>, outside?: boolean): Rect;
 /** `overheadOff`: the counter sits under the window without its wall cabinet. */
 declare function blocksWindow(it: Pick<FurnitureDef, 'window' | 'overhead' | 'windowHeight'> & {
     h: number;
-}, win: Json, overheadOff?: boolean): boolean;
+}, win: Pick<PlanWindow, 'y0'>, overheadOff?: boolean): boolean;
 
 /** All content registries of one engine instance. Content packs fill them through the `register*` functions. */
 type Registries = {
@@ -816,6 +1177,36 @@ declare function registerFindsProvider(provider: FindsProvider): void;
 /** Adds (or replaces, by id) a layer of the 2D viewer; drawn after the items, before the labels. */
 declare function registerViewerLayer(layer: ViewerLayer): void;
 
+/** What the zone checks read from a plan: a generated result or the internal plan. */
+interface ZoneCheckedPlan {
+    floors: {
+        y0: number;
+        ceiling: number;
+    }[];
+    floorNumber?: number | null;
+    rooms?: {
+        floor: number;
+        parts: readonly (readonly number[])[];
+    }[];
+    w: number;
+    d: number;
+    use?: string;
+    partyWalls?: string[];
+}
+/** What the zone checks read from a lot (`result.lot`). */
+interface ZoneCheckedLot {
+    rect: readonly number[];
+    setback: number;
+    sideYard: {
+        left: number;
+        right: number;
+    };
+    backyard: number;
+    zones: {
+        ground?: string;
+        parts: readonly (readonly number[])[];
+    }[];
+}
 /** Registers an urban zone (zoning rules). Returns the stored definition. */
 declare function defineZone(zone: ZoneDef): ZoneDef;
 declare const getZone: (id: string) => ZoneDef | undefined;
@@ -826,7 +1217,7 @@ declare function registerPermeableGround(...types: string[]): void;
  * Checks a generated lot against a zone and returns the violations (empty when compliant).
  * `lot` is `result.lot` (may be null for apartments), `plan` is the result of `generate`.
  */
-declare function checkLot(zoneIn: string | ZoneDef, lot: Json, plan: Json): ZoneViolation[];
+declare function checkLot(zoneIn: string | ZoneDef, lot: ZoneCheckedLot | null | undefined, plan: ZoneCheckedPlan): ZoneViolation[];
 
 declare const version = "0.1.0";
 /** Registers `packs` and applies `patch` / `remove` over the catalogs, by id. Items are keyed by `type`, templates by `id`. */
@@ -1117,4 +1508,4 @@ declare function createDetachedHouse(p: DetachedHouseParams): Silhouette;
  */
 declare const engine: FloorplanEngine;
 
-export { type Anchor, type BoundaryRule, type CarClearance, type ChaletParams, type CityBuildingParams, type ColonialParams, type CompanyHouseParams, type CreateFloorplanOptions, type DecorPass, type DecorPassContext, type DetachedHouseParams, type DoorDef, type FacingRule, type FarmhouseParams, type FindStack, type FindsProvider, type FindsQuery, type FloorDef, type FloorplanEngine, type FloorplanLocale, type FloorplanOptions, type FloorplanPack, type FurnitureDef, type GateCfg, type GroundOverlayRule, type Hsl, type ItemColor, type ItemInput, type Json, type LotConfig, type MeshFront, type Mount, type PaletteDraw, type PaletteEarly, type PaletteStyleDef, type PlacedItem, type PlacementContext, type PlacementKit, type Plan, type RandomSource, type Rect, type ResultExtensionContext, type ResultExtensionOptions, type ResultExtensionRun, type Room, type RoomColorDef, type RoomDef, type Side, type Silhouette, type SilhouettePart, type SilhouetteWindow, type SlabHouseParams, type Slot, type SlotDef, type SlotKit, type SlotLibrary, type StateContext, type StatePlugin, type StiltHouseParams, type StyleDef, type TemplateDef, type TwoStoreyParams, type Vec2, type ViewerLayer, type ViewerLayerContext, type ViewerLayerLegendEntry, type Weights, type WindowDef, type ZoneAdjustment, type ZoneDef, type ZoneViolation, type ZoningReport, blocksWindow, boxRadius, checkLot, createChalet, createCityBuilding, createColonialHouse, createCompanyHouse, createDetachedHouse, createFarmhouse, createFloorplan, createRng, createSilhouetteRandom, createSlabHouse, createStiltHouse, createTwoStoreyHouse, defaultFloorplan, defineZone, engine, findsAnswer, findsFor, generate, getZone, hashString, limitsOf, listLocales, listStates, listTemplates, listZones, mulberry32, openingZones, overlaps, palette, registerDecorProfile, registerFindsProvider, registerGroundOverlay, registerItem, registerItems, registerLibrary, registerLibraryAlias, registerLocale, registerPaletteStyle, registerPass, registerPermeableGround, registerResultExtension, registerRoomColors, registerSeedKeys, registerState, registerStyle, registerTemplate, registerViewerLayer, registerWallTop, setStateDistribution, slotKit, slots, translate, validate, version, windowZone };
+export { type Anchor, type BoundaryRule, type CarClearance, type ChaletParams, type CityBuildingParams, type ColonialParams, type CompanyHouseParams, type CreateFloorplanOptions, type DecorPass, type DecorPassContext, type DetachedHouseParams, type DoorDef, type Facade, type FacadeFields, type FacingRule, type FarmhouseParams, type FindStack, type FindsProvider, type FindsQuery, type FloorDef, type FloorplanEngine, type FloorplanLocale, type FloorplanOptions, type FloorplanPack, type FloorplanResult, type FloorplanResultFields, type FurnitureDef, type GateCfg, type GroundOverlayRule, type Hsl, type ItemColor, type ItemInput, type Json, type Lot, type LotBoundary, type LotConfig, type LotPath, type LotPerimeterPiece, type MeshFront, type Mount, type PaletteDraw, type PaletteEarly, type PaletteStyleDef, type PlaceOnFloorOptions, type PlacedItem, type PlacedItemFields, type PlacementContext, type PlacementKit, type Plan, type PlanAxis, type PlanDoor, type PlanGate, type PlanOpening, type PlanWall, type PlanWindow, type RandomSource, type RecordedSlot, type Rect, type ResultExtensionContext, type ResultExtensionOptions, type ResultExtensionRun, type ResultFacade, type ResultFloor, type ResultGate, type ResultItem, type ResultLot, type ResultRoom, type Room, type RoomColorDef, type RoomDef, type Side, type Silhouette, type SilhouettePart, type SilhouetteWindow, type SlabHouseParams, type Slot, type SlotCell, type SlotDef, type SlotFields, type SlotKit, type SlotLibrary, type StateContext, type StatePlugin, type StiltHouseParams, type StyleDef, type TemplateDef, type TwoStoreyParams, type Vec2, type ViewerLayer, type ViewerLayerContext, type ViewerLayerLegendEntry, type WalkGrid, type Weights, type WindowDef, type ZoneAdjustment, type ZoneCheckedLot, type ZoneCheckedPlan, type ZoneDef, type ZoneViolation, type ZoningReport, blocksWindow, boxRadius, checkLot, createChalet, createCityBuilding, createColonialHouse, createCompanyHouse, createDetachedHouse, createFarmhouse, createFloorplan, createRng, createSilhouetteRandom, createSlabHouse, createStiltHouse, createTwoStoreyHouse, defaultFloorplan, defineZone, engine, findsAnswer, findsFor, generate, getZone, hashString, limitsOf, listLocales, listStates, listTemplates, listZones, mulberry32, openingZones, overlaps, palette, registerDecorProfile, registerFindsProvider, registerGroundOverlay, registerItem, registerItems, registerLibrary, registerLibraryAlias, registerLocale, registerPaletteStyle, registerPass, registerPermeableGround, registerResultExtension, registerRoomColors, registerSeedKeys, registerState, registerStyle, registerTemplate, registerViewerLayer, registerWallTop, setStateDistribution, slotKit, slots, translate, validate, version, windowZone };