@snaptrude/plugin-core 0.3.0 → 0.6.0

package/dist/api/design/query/index.d.ts

@@ -0,0 +1,1011 @@
+import * as z from "zod";
+import { PluginApiReturn } from "../../../types";
+import { ComponentHandle, BBoxComponents } from "../../../handles";
+import { PluginDesignQueryGeometryApi } from "./geometry";
+import { PluginDesignQuerySpacesApi } from "./spaces";
+/**
+ * The kind of a BIM entity — the discovery/filter vocabulary for the whole
+ * `design.query.*` surface. Values are clean `lowerCamel` tokens; the host maps
+ * each to the engine's internal type (whose raw strings are case-inconsistent —
+ * `"roof"`/`"slab"` lowercase, `"Wall"`/`"Door"` PascalCase — never surfaced here).
+ *
+ * | Value | Entity |
+ * |---|---|
+ * | `"wall"` | Wall |
+ * | `"space"` | Space (a room mass) |
+ * | `"mass"` | Generic mass (non-room) |
+ * | `"door"` | Door |
+ * | `"window"` | Window |
+ * | `"floor"` | Floor |
+ * | `"slab"` | Slab |
+ * | `"roof"` | Roof |
+ * | `"column"` | Column |
+ * | `"beam"` | Beam |
+ * | `"ceiling"` | Ceiling |
+ * | `"staircase"` | Staircase |
+ * | `"furniture"` | Furniture |
+ * | `"referenceLine"` | Reference line |
+ * | `"curtainWall"` | Parametric curtain wall |
+ * | `"mullion"` | Curtain-wall mullion |
+ * | `"panel"` | Curtain-wall panel |
+ */
+export declare const PluginEntityType: z.ZodEnum<{
+    mass: "mass";
+    floor: "floor";
+    wall: "wall";
+    ceiling: "ceiling";
+    space: "space";
+    door: "door";
+    window: "window";
+    slab: "slab";
+    roof: "roof";
+    column: "column";
+    beam: "beam";
+    staircase: "staircase";
+    furniture: "furniture";
+    referenceLine: "referenceLine";
+    curtainWall: "curtainWall";
+    mullion: "mullion";
+    panel: "panel";
+}>;
+export type PluginEntityType = z.infer<typeof PluginEntityType>;
+/**
+ * `EntityFilterOptions` — the **single filter** shared by every `design.query.list*`
+ * method, so filtering is identical across all BIM object types. Every field is
+ * optional and **AND-combined**: a component must satisfy all provided fields.
+ * Plural fields are arrays (match any of); singular fields are scalars. A field
+ * that names a type-specific dimension (`massTypes`/`spaceTypes`/`departmentId`)
+ * excludes components that lack that dimension.
+ *
+ * | Field | Type | Keeps components where |
+ * |---|---|---|
+ * | `types` | {@linkcode PluginEntityType}`[]` | entity kind ∈ `types` (ignored by per-type `list*` — the method fixes the kind) |
+ * | `storeys` | `number[]` | storey/floor level ∈ `storeys` (negative = basement) |
+ * | `buildingIds` | `string[]` | building ∈ `buildingIds` |
+ * | `structureIds` | `string[]` | structure ∈ `structureIds` |
+ * | `label` | `string` | label (`room_type` ?? mesh label) === `label` |
+ * | `massTypes` | {@linkcode PluginMassType}`[]` | mass-type ∈ (masses only) |
+ * | `spaceTypes` | {@linkcode PluginSpaceType}`[]` | space-type ∈ (spaces only) |
+ * | `departmentId` | {@linkcode PluginDepartmentId} | department === |
+ * | `isSelected` | `boolean` | current selection state === |
+ * | `isLocked` | `boolean` | lock flag === |
+ * | `isHidden` | `boolean` | user-hidden flag === |
+ * | `within` | {@linkcode BBoxComponents} | the entity's bounding box intersects the region |
+ * | `overlaps` | {@linkcode ComponentHandle} | the entity's plan footprint overlaps the given space's bottom-face footprint — non-zero intersection area, so fully-inside, boundary-nested, and partially-overhanging entities all match; edge-touching with zero interior overlap does not. Exact polygon intersection (holes respected). Tested in plan — storey height is ignored; compose with `storeys` to scope a floor. Hidden entities are excluded by default — pass `isHidden` explicitly to override. The reference space itself is never returned. Throws on an unknown id. Entities without a brep footprint use their bounding-box plan rectangle. |
+ * | `ids` | {@linkcode ComponentHandle}`[]` | id ∈ `ids` (restrict to a known set) |
+ */
+export declare const PluginEntityFilter: z.ZodObject<{
+    types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        mass: "mass";
+        floor: "floor";
+        wall: "wall";
+        ceiling: "ceiling";
+        space: "space";
+        door: "door";
+        window: "window";
+        slab: "slab";
+        roof: "roof";
+        column: "column";
+        beam: "beam";
+        staircase: "staircase";
+        furniture: "furniture";
+        referenceLine: "referenceLine";
+        curtainWall: "curtainWall";
+        mullion: "mullion";
+        panel: "panel";
+    }>>>;
+    storeys: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    buildingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    structureIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    label: z.ZodOptional<z.ZodString>;
+    massTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        Room: "Room";
+        Plinth: "Plinth";
+        Void: "Void";
+        Pergola: "Pergola";
+        Furniture: "Furniture";
+        "Facade element": "Facade element";
+        "Generic mass": "Generic mass";
+        Department: "Department";
+        Building: "Building";
+        "Revit Import": "Revit Import";
+        Mass: "Mass";
+        Site: "Site";
+    }>>>;
+    spaceTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        Room: "Room";
+        "Program Block": "Program Block";
+        Balcony: "Balcony";
+        Road: "Road";
+        Garden: "Garden";
+        Deck: "Deck";
+        Pool: "Pool";
+        Walkway: "Walkway";
+        Envelope: "Envelope";
+        Parking: "Parking";
+    }>>>;
+    departmentId: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        DEFAULT: "DEFAULT";
+        SITE: "SITE";
+        ENVELOPE: "ENVELOPE";
+        CORE: "CORE";
+    }>, z.ZodUUID]>>;
+    isSelected: z.ZodOptional<z.ZodBoolean>;
+    isLocked: z.ZodOptional<z.ZodBoolean>;
+    isHidden: z.ZodOptional<z.ZodBoolean>;
+    within: z.ZodOptional<z.ZodObject<{
+        min: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+        }, z.core.$strip>;
+        max: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    overlaps: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+    ids: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>>;
+}, z.core.$strip>;
+export type PluginEntityFilter = z.infer<typeof PluginEntityFilter>;
+/**
+ * Arguments for {@linkcode PluginDesignQueryApi.listByType} — a required entity
+ * `type` plus every {@linkcode PluginEntityFilter} field.
+ */
+export declare const PluginDesignQueryListByTypeArgs: z.ZodObject<{
+    types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        mass: "mass";
+        floor: "floor";
+        wall: "wall";
+        ceiling: "ceiling";
+        space: "space";
+        door: "door";
+        window: "window";
+        slab: "slab";
+        roof: "roof";
+        column: "column";
+        beam: "beam";
+        staircase: "staircase";
+        furniture: "furniture";
+        referenceLine: "referenceLine";
+        curtainWall: "curtainWall";
+        mullion: "mullion";
+        panel: "panel";
+    }>>>;
+    storeys: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    buildingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    structureIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    label: z.ZodOptional<z.ZodString>;
+    massTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        Room: "Room";
+        Plinth: "Plinth";
+        Void: "Void";
+        Pergola: "Pergola";
+        Furniture: "Furniture";
+        "Facade element": "Facade element";
+        "Generic mass": "Generic mass";
+        Department: "Department";
+        Building: "Building";
+        "Revit Import": "Revit Import";
+        Mass: "Mass";
+        Site: "Site";
+    }>>>;
+    spaceTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        Room: "Room";
+        "Program Block": "Program Block";
+        Balcony: "Balcony";
+        Road: "Road";
+        Garden: "Garden";
+        Deck: "Deck";
+        Pool: "Pool";
+        Walkway: "Walkway";
+        Envelope: "Envelope";
+        Parking: "Parking";
+    }>>>;
+    departmentId: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        DEFAULT: "DEFAULT";
+        SITE: "SITE";
+        ENVELOPE: "ENVELOPE";
+        CORE: "CORE";
+    }>, z.ZodUUID]>>;
+    isSelected: z.ZodOptional<z.ZodBoolean>;
+    isLocked: z.ZodOptional<z.ZodBoolean>;
+    isHidden: z.ZodOptional<z.ZodBoolean>;
+    within: z.ZodOptional<z.ZodObject<{
+        min: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+        }, z.core.$strip>;
+        max: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    overlaps: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+    ids: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>>;
+    type: z.ZodEnum<{
+        mass: "mass";
+        floor: "floor";
+        wall: "wall";
+        ceiling: "ceiling";
+        space: "space";
+        door: "door";
+        window: "window";
+        slab: "slab";
+        roof: "roof";
+        column: "column";
+        beam: "beam";
+        staircase: "staircase";
+        furniture: "furniture";
+        referenceLine: "referenceLine";
+        curtainWall: "curtainWall";
+        mullion: "mullion";
+        panel: "panel";
+    }>;
+}, z.core.$strip>;
+export type PluginDesignQueryListByTypeArgs = z.infer<typeof PluginDesignQueryListByTypeArgs>;
+/** Arguments for methods that read one entity by its {@linkcode ComponentHandle}. */
+export declare const PluginDesignQueryComponentArgs: z.ZodObject<{
+    component: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+}, z.core.$strip>;
+export type PluginDesignQueryComponentArgs = z.infer<typeof PluginDesignQueryComponentArgs>;
+/** Arguments for methods that look an entity up by id. */
+export declare const PluginDesignQueryIdArgs: z.ZodObject<{
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+}, z.core.$strip>;
+export type PluginDesignQueryIdArgs = z.infer<typeof PluginDesignQueryIdArgs>;
+/** Arguments for methods over a set of entities (e.g. the union bounding box). */
+export declare const PluginDesignQueryComponentsArgs: z.ZodObject<{
+    components: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+}, z.core.$strip>;
+export type PluginDesignQueryComponentsArgs = z.infer<typeof PluginDesignQueryComponentsArgs>;
+/**
+ * The common property record returned by {@linkcode PluginDesignQueryApi.getProperties} —
+ * a **partial** object (a field is present only when it applies to the entity).
+ * Type-specific and geometry reads live on {@linkcode PluginDesignQueryApi.measure}
+ * and `design.query.geometry.*`, keeping this record generic across every type.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `id` | `string` | The entity id |
+ * | `type` | {@linkcode PluginEntityType} | Entity kind |
+ * | `label` | `string` | `room_type` ?? mesh label ?? `""` |
+ * | `storey` | `number` | Storey/floor level |
+ * | `buildingId` | `string` | Owning building |
+ * | `structureId` | `string` | Owning structure |
+ * | `massType` | `string` | Mass-type (masses only) |
+ * | `spaceType` | {@linkcode PluginSpaceType} | Space-type (spaces only) |
+ * | `areaClass` | {@linkcode PluginAreaClass} | Area classification (spaces only) |
+ * | `departmentId` | `string` | Department (masses only) |
+ * | `isLocked` | `boolean` | Lock flag |
+ * | `isHidden` | `boolean` | User-hidden flag |
+ * | `isSelected` | `boolean` | Current selection state |
+ * | `boundingBox` | {@linkcode BBoxComponents} | World-space AABB |
+ * | `adjacency` | `{ spaceId: string; value: number }[]` | Adjacency relationships (spaces/masses only). `value`: `2` = Direct (required), `1` = Indirect or physical contact, `-1` = Restricted; `0` entries are filtered out. `[]` when adjacency has never been computed — see `program.adjacency.compute`. |
+ */
+export declare const PluginEntityProperties: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<{
+        mass: "mass";
+        floor: "floor";
+        wall: "wall";
+        ceiling: "ceiling";
+        space: "space";
+        door: "door";
+        window: "window";
+        slab: "slab";
+        roof: "roof";
+        column: "column";
+        beam: "beam";
+        staircase: "staircase";
+        furniture: "furniture";
+        referenceLine: "referenceLine";
+        curtainWall: "curtainWall";
+        mullion: "mullion";
+        panel: "panel";
+    }>>;
+    label: z.ZodOptional<z.ZodString>;
+    storey: z.ZodOptional<z.ZodNumber>;
+    buildingId: z.ZodOptional<z.ZodString>;
+    structureId: z.ZodOptional<z.ZodString>;
+    massType: z.ZodOptional<z.ZodString>;
+    spaceType: z.ZodOptional<z.ZodEnum<{
+        Room: "Room";
+        "Program Block": "Program Block";
+        Balcony: "Balcony";
+        Road: "Road";
+        Garden: "Garden";
+        Deck: "Deck";
+        Pool: "Pool";
+        Walkway: "Walkway";
+        Envelope: "Envelope";
+        Parking: "Parking";
+    }>>;
+    areaClass: z.ZodOptional<z.ZodEnum<{
+        NET: "NET";
+        GROSS: "GROSS";
+        EXCLUDED: "EXCLUDED";
+    }>>;
+    departmentId: z.ZodOptional<z.ZodString>;
+    isLocked: z.ZodOptional<z.ZodBoolean>;
+    isHidden: z.ZodOptional<z.ZodBoolean>;
+    isSelected: z.ZodOptional<z.ZodBoolean>;
+    boundingBox: z.ZodOptional<z.ZodObject<{
+        min: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+        }, z.core.$strip>;
+        max: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    adjacency: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        spaceId: z.ZodString;
+        value: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type PluginEntityProperties = z.infer<typeof PluginEntityProperties>;
+/**
+ * The multi-metric bundle returned by {@linkcode PluginDesignQueryApi.measure}.
+ * `boundingBox` is always present; the numeric metrics appear only when the
+ * entity's type computes them (area: floors/masses/slabs/roofs/beams/columns;
+ * volume: all; length: walls/beams).
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `area` | `number`? | Bottom-face area |
+ * | `volume` | `number`? | Solid volume |
+ * | `length` | `number`? | Running length (linear elements) |
+ * | `boundingBox` | {@linkcode BBoxComponents} | World-space AABB (always present) |
+ */
+export declare const PluginEntityMeasurements: z.ZodObject<{
+    area: z.ZodOptional<z.ZodNumber>;
+    volume: z.ZodOptional<z.ZodNumber>;
+    length: z.ZodOptional<z.ZodNumber>;
+    boundingBox: z.ZodObject<{
+        min: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+        }, z.core.$strip>;
+        max: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type PluginEntityMeasurements = z.infer<typeof PluginEntityMeasurements>;
+/**
+ * `design.query.*` — read-only enumeration + inspection of scene-committed BIM
+ * entities (all-handle model, §11). No query mutates the scene.
+ *
+ * Every `list*` returns a snapshot {@linkcode ComponentHandle}`[]` (`[]`, never
+ * `null`) filtered by the shared {@linkcode PluginEntityFilter}; per-entity reads
+ * take a {@linkcode ComponentHandle} and return primitive records / child handles
+ * or `null` when the entity is gone. Resolve details of a returned handle with
+ * {@linkcode PluginDesignQueryApi.getProperties} / {@linkcode PluginDesignQueryApi.measure}
+ * / `design.query.geometry.*`.
+ *
+ * Accessed via `snaptrude.design.query`.
+ */
+export declare abstract class PluginDesignQueryApi {
+    /** Entity-geometry reads (brep, bottom contour). See {@linkcode PluginDesignQueryGeometryApi}. */
+    abstract geometry: PluginDesignQueryGeometryApi;
+    /** Space-specific reads (footprint, …). See {@linkcode PluginDesignQuerySpacesApi}. */
+    abstract spaces: PluginDesignQuerySpacesApi;
+    constructor();
+    /**
+     * List **all** BIM entities in the project matching the filter.
+     *
+     * @param filter - an optional {@linkcode PluginEntityFilter}
+     * @returns matching entities as {@linkcode ComponentHandle}`[]` (`[]` if none)
+     *
+     * @examplePrompt Show me everything in the model
+     * @examplePrompt How many objects are on the ground floor?
+     * @examplePrompt List all the doors and windows on level 2
+     * @examplePrompt What elements are currently selected?
+     * @examplePrompt Find every hidden object in the project
+     *
+     * # Example
+     * ```ts
+     * // Doors and windows on the ground storey (fields AND-combine)
+     * const doorsAndWindows = await snaptrude.design.query.listEntities({
+     *   types: ["door", "window"],
+     *   storeys: [1],
+     * })
+     *
+     * // Everything the user currently has selected
+     * const selected = await snaptrude.design.query.listEntities({ isSelected: true })
+     *
+     * // Everything inside a world-space region (axis-aligned box, Snaptrude units)
+     * const inRegion = await snaptrude.design.query.listEntities({
+     *   within: { min: { x: 0, y: 0, z: 0 }, max: { x: 10, y: 4, z: 8 } },
+     * })
+     * ```
+     */
+    abstract listEntities(filter?: PluginEntityFilter): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * List all entities of one BIM object type — wall, door, slab, panel, and so
+     * on — optionally narrowed by the shared filter.
+     *
+     * @param type - the {@linkcode PluginEntityType} to list
+     * @param filter - an optional {@linkcode PluginEntityFilter}
+     * @returns matching entities as {@linkcode ComponentHandle}`[]`
+     *
+     * @examplePrompt List all the curtain walls in the project
+     * @examplePrompt Show every curtain wall panel on this storey
+     * @examplePrompt Get all the elements of a single type, like columns
+     * @examplePrompt Find all the locked slabs in the model
+     *
+     * # Example
+     * ```ts
+     * const lockedSlabs = await snaptrude.design.query.listByType("slab", { isLocked: true })
+     *
+     * // Curtain-wall panels on storeys 2-3 of one building
+     * const panels = await snaptrude.design.query.listByType("panel", {
+     *   storeys: [2, 3],
+     *   buildingIds: ["bld_1"],
+     * })
+     * ```
+     */
+    abstract listByType(type: PluginEntityType, filter?: PluginEntityFilter): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * List all the walls in the project, optionally filtered by storey, building,
+     * label, selection state, or region.
+     *
+     * The `types` field of the filter is ignored (this method fixes the kind).
+     *
+     * @param filter - an optional {@linkcode PluginEntityFilter}
+     * @returns wall {@linkcode ComponentHandle}`[]`
+     *
+     * @examplePrompt How many walls are in the project?
+     * @examplePrompt List all the walls on the ground floor
+     * @examplePrompt Which walls are currently selected?
+     * @examplePrompt Find the walls on level 2 of building A
+     * @examplePrompt Show me every hidden wall
+     *
+     * # Example
+     * ```ts
+     * const groundFloorWalls = await snaptrude.design.query.listWalls({ storeys: [1] })
+     * ```
+     */
+    abstract listWalls(filter?: PluginEntityFilter): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * List all the spaces (rooms) in the project, optionally filtered by storey,
+     * department, space type, label, selection state, or region.
+     *
+     * @param filter - an optional {@linkcode PluginEntityFilter}
+     * @returns space {@linkcode ComponentHandle}`[]`
+     *
+     * @examplePrompt How many rooms are in this project?
+     * @examplePrompt List all the spaces on the second storey
+     * @examplePrompt Which rooms are in the Bedrooms department?
+     * @examplePrompt Find every room labelled Kitchen
+     * @examplePrompt Show the spaces that are currently selected
+     *
+     * # Example
+     * ```ts
+     * // Balconies and decks on storey 2 (`label` is an exact match on room_type)
+     * const outdoor = await snaptrude.design.query.listSpaces({
+     *   storeys: [2],
+     *   spaceTypes: ["Balcony", "Deck"],
+     * })
+     *
+     * // Rooms in a department: resolve its id first, then filter and total the area
+     * const { departments } = await snaptrude.program.departments.list()
+     * const bedrooms = departments.find((d) => d.name === "Bedrooms")
+     * if (bedrooms) {
+     *   const rooms = await snaptrude.design.query.listSpaces({ departmentId: bedrooms.id })
+     *   let total = 0
+     *   for (const room of rooms) {
+     *     const m = await snaptrude.design.query.measure(room)
+     *     total += m?.area ?? 0
+     *   }
+     * }
+     * ```
+     */
+    abstract listSpaces(filter?: PluginEntityFilter): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * List all the generic masses (non-room massing volumes) in the project,
+     * optionally filtered by storey, building, label, mass type, or region.
+     *
+     * @param filter - an optional {@linkcode PluginEntityFilter}
+     * @returns mass {@linkcode ComponentHandle}`[]`
+     *
+     * @examplePrompt List all the masses in the model
+     * @examplePrompt How many massing blocks are on the site?
+     * @examplePrompt Show the generic masses on level 1
+     * @examplePrompt Find every mass that isn't a room
+     *
+     * # Example
+     * ```ts
+     * // Only certain mass kinds — massTypes matches any of the given values
+     * const massing = await snaptrude.design.query.listMasses({
+     *   massTypes: ["Generic mass", "Plinth"],
+     * })
+     * ```
+     */
+    abstract listMasses(filter?: PluginEntityFilter): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * List all the doors in the project, optionally filtered by storey, building,
+     * selection state, or region.
+     *
+     * @param filter - an optional {@linkcode PluginEntityFilter}
+     * @returns door {@linkcode ComponentHandle}`[]`
+     *
+     * @examplePrompt How many doors are in the project?
+     * @examplePrompt List all the doors on the ground floor
+     * @examplePrompt Which doors are currently selected?
+     * @examplePrompt Find every door in building B
+     *
+     * # Example
+     * ```ts
+     * // Ground-floor doors, then read each one's width via design.doors.*
+     * const doors = await snaptrude.design.query.listDoors({ storeys: [1] })
+     * for (const door of doors) {
+     *   const width = await snaptrude.design.doors.getWidth(door)
+     * }
+     * ```
+     */
+    abstract listDoors(filter?: PluginEntityFilter): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * List all the windows in the project, optionally filtered by storey,
+     * building, selection state, or region.
+     *
+     * @param filter - an optional {@linkcode PluginEntityFilter}
+     * @returns window {@linkcode ComponentHandle}`[]`
+     *
+     * @examplePrompt How many windows does this building have?
+     * @examplePrompt List every window on level 3
+     * @examplePrompt Which windows are on the ground floor?
+     * @examplePrompt Show all the windows that are currently selected
+     *
+     * # Example
+     * ```ts
+     * const level3Windows = await snaptrude.design.query.listWindows({ storeys: [3] })
+     * ```
+     */
+    abstract listWindows(filter?: PluginEntityFilter): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * List all the floor elements (floor plates / finishes) in the project,
+     * optionally filtered by storey, building, lock state, or region.
+     *
+     * @param filter - an optional {@linkcode PluginEntityFilter}
+     * @returns floor {@linkcode ComponentHandle}`[]`
+     *
+     * @examplePrompt List all the floor elements in the model
+     * @examplePrompt How many floor plates are on the second storey?
+     * @examplePrompt Which floors are locked?
+     * @examplePrompt Show the floor finishes on level 0
+     *
+     * # Example
+     * ```ts
+     * const lockedFloors = await snaptrude.design.query.listFloors({ isLocked: true })
+     * ```
+     */
+    abstract listFloors(filter?: PluginEntityFilter): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * List all the slabs in the project, optionally filtered by storey, building,
+     * lock state, or region.
+     *
+     * @param filter - an optional {@linkcode PluginEntityFilter}
+     * @returns slab {@linkcode ComponentHandle}`[]`
+     *
+     * @examplePrompt List all the slabs in the project
+     * @examplePrompt How many slabs are on level 2?
+     * @examplePrompt Which slabs are locked?
+     * @examplePrompt Show the slabs in the selected building
+     *
+     * # Example
+     * ```ts
+     * const storey2Slabs = await snaptrude.design.query.listSlabs({ storeys: [2] })
+     * ```
+     */
+    abstract listSlabs(filter?: PluginEntityFilter): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * List all the roofs in the project, optionally filtered by storey, building,
+     * visibility, or region.
+     *
+     * @param filter - an optional {@linkcode PluginEntityFilter}
+     * @returns roof {@linkcode ComponentHandle}`[]`
+     *
+     * @examplePrompt How many roofs does the model have?
+     * @examplePrompt List all the roof elements
+     * @examplePrompt Show the roofs on the top storey
+     * @examplePrompt Find every hidden roof
+     *
+     * # Example
+     * ```ts
+     * const hiddenRoofs = await snaptrude.design.query.listRoofs({ isHidden: true })
+     * ```
+     */
+    abstract listRoofs(filter?: PluginEntityFilter): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * List all the columns in the project, optionally filtered by storey,
+     * building, selection state, or region.
+     *
+     * @param filter - an optional {@linkcode PluginEntityFilter}
+     * @returns column {@linkcode ComponentHandle}`[]`
+     *
+     * @examplePrompt How many columns are on the ground floor?
+     * @examplePrompt List all the columns in building A
+     * @examplePrompt Show every column on level 3
+     * @examplePrompt Which columns are currently selected?
+     *
+     * # Example
+     * ```ts
+     * const groundFloorColumns = await snaptrude.design.query.listColumns({ storeys: [1] })
+     * ```
+     */
+    abstract listColumns(filter?: PluginEntityFilter): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * List all the beams in the project, optionally filtered by storey, building,
+     * lock state, or region.
+     *
+     * @param filter - an optional {@linkcode PluginEntityFilter}
+     * @returns beam {@linkcode ComponentHandle}`[]`
+     *
+     * @examplePrompt List all the beams in the project
+     * @examplePrompt How many beams are on the second storey?
+     * @examplePrompt Show the beams in this structure
+     * @examplePrompt Find every locked beam
+     *
+     * # Example
+     * ```ts
+     * const storey2Beams = await snaptrude.design.query.listBeams({ storeys: [2] })
+     * ```
+     */
+    abstract listBeams(filter?: PluginEntityFilter): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * List all the ceilings in the project, optionally filtered by storey,
+     * building, visibility, or region.
+     *
+     * @param filter - an optional {@linkcode PluginEntityFilter}
+     * @returns ceiling {@linkcode ComponentHandle}`[]`
+     *
+     * @examplePrompt List all the ceilings in the model
+     * @examplePrompt How many ceilings are on level 1?
+     * @examplePrompt Which ceilings are hidden?
+     * @examplePrompt Show the ceilings in building B
+     *
+     * # Example
+     * ```ts
+     * const hiddenCeilings = await snaptrude.design.query.listCeilings({ isHidden: true })
+     * ```
+     */
+    abstract listCeilings(filter?: PluginEntityFilter): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * List all the staircases in the project, optionally filtered by storey,
+     * building, selection state, or region.
+     *
+     * @param filter - an optional {@linkcode PluginEntityFilter}
+     * @returns staircase {@linkcode ComponentHandle}`[]`
+     *
+     * @examplePrompt How many staircases are in the building?
+     * @examplePrompt List all the stairs in the project
+     * @examplePrompt Show the staircases on the ground floor
+     * @examplePrompt Which stairs are currently selected?
+     *
+     * # Example
+     * ```ts
+     * const groundFloorStairs = await snaptrude.design.query.listStaircases({ storeys: [1] })
+     * ```
+     */
+    abstract listStaircases(filter?: PluginEntityFilter): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * List all the furniture in the project, optionally filtered by storey,
+     * building, label, selection state, or region.
+     *
+     * @param filter - an optional {@linkcode PluginEntityFilter}
+     * @returns furniture {@linkcode ComponentHandle}`[]`
+     *
+     * @examplePrompt List all the furniture in the project
+     * @examplePrompt How many furniture items are on this floor?
+     * @examplePrompt Show the furniture inside the selected room
+     * @examplePrompt Which furniture is on storey 2?
+     *
+     * # Example
+     * ```ts
+     * // Furniture whose plan footprint overlaps a room (`overlaps` is plan-only —
+     * // scope the storey too, or furniture stacked on other floors matches)
+     * const [kitchen] = await snaptrude.design.query.listSpaces({ label: "Kitchen" })
+     * if (kitchen) {
+     *   const inKitchen = await snaptrude.design.query.listFurniture({
+     *     overlaps: kitchen,
+     *     storeys: [1],
+     *   })
+     * }
+     * ```
+     */
+    abstract listFurniture(filter?: PluginEntityFilter): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * List all the reference lines in the project, optionally filtered by storey,
+     * building, or region.
+     *
+     * @param filter - an optional {@linkcode PluginEntityFilter}
+     * @returns reference-line {@linkcode ComponentHandle}`[]`
+     *
+     * @examplePrompt List all the reference lines in the model
+     * @examplePrompt Show the guide lines on the ground floor
+     * @examplePrompt How many reference lines are on this storey?
+     * @examplePrompt Find the setting-out lines in building A
+     *
+     * # Example
+     * ```ts
+     * const groundFloorRefLines = await snaptrude.design.query.listReferenceLines({ storeys: [1] })
+     * ```
+     */
+    abstract listReferenceLines(filter?: PluginEntityFilter): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * List all the curtain-wall mullions in the project, optionally filtered by
+     * storey, building, selection state, or region.
+     *
+     * @param filter - an optional {@linkcode PluginEntityFilter}
+     * @returns mullion {@linkcode ComponentHandle}`[]`
+     *
+     * @examplePrompt List all the mullions in the curtain wall
+     * @examplePrompt How many mullions are on the facade?
+     * @examplePrompt Show every curtain wall mullion on level 5
+     * @examplePrompt Which mullions are currently selected?
+     *
+     * # Example
+     * ```ts
+     * const level5Mullions = await snaptrude.design.query.listMullions({ storeys: [5] })
+     * ```
+     */
+    abstract listMullions(filter?: PluginEntityFilter): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * Look an entity up by id — returns the same handle if it still resolves live,
+     * else `null`. A cheap validity probe (distinct from {@linkcode PluginDesignQueryApi.exists}).
+     *
+     * @param id - the entity id ({@linkcode ComponentHandle}) to look up
+     * @returns the {@linkcode ComponentHandle}, or `null` if it no longer resolves
+     *
+     * @examplePrompt Look up an object by its id
+     * @examplePrompt Does id cmp_42 still point to something in the model?
+     * @examplePrompt Fetch the element with this id
+     * @examplePrompt Check if this saved element id is still valid
+     *
+     * # Example
+     * ```ts
+     * // Persistence round-trip: save a ref now, revalidate it in a later run
+     * const [wall] = await snaptrude.design.query.listWalls()
+     * const savedRef = await snaptrude.design.query.getEntityRef(wall)
+     *
+     * // ...later (savedRef restored from plugin storage)...
+     * const stillThere = await snaptrude.design.query.getById(savedRef)
+     * if (stillThere) {
+     *   const props = await snaptrude.design.query.getProperties(stillThere)
+     * }
+     * ```
+     */
+    abstract getById(id: ComponentHandle): PluginApiReturn<ComponentHandle | null>;
+    /**
+     * Test whether an entity id resolves to a live scene entity.
+     * @param id - the entity id ({@linkcode ComponentHandle}) to look up
+     * @returns `true` if it exists, otherwise `false`
+     *
+     * @examplePrompt Does this element still exist in the scene?
+     * @examplePrompt Check whether the wall I stored earlier is still there
+     * @examplePrompt Is id cmp_42 still valid?
+     * @examplePrompt Verify the object wasn't deleted
+     *
+     * # Example
+     * ```ts
+     * // Guard before acting on a handle that may have been deleted or undone
+     * if (await snaptrude.design.query.exists(wall)) {
+     *   const dx = await snaptrude.core.math.vec3.new(5, 0, 0)
+     *   await snaptrude.design.transform.move([wall], dx)
+     * }
+     * ```
+     */
+    abstract exists(id: ComponentHandle): PluginApiReturn<boolean>;
+    /**
+     * Get the kind of BIM entity a handle refers to — wall, door, space, slab,
+     * and so on (its {@linkcode PluginEntityType}).
+     * @param component - the entity's {@linkcode ComponentHandle}
+     * @returns the kind, or `null` if the entity is gone / its type is unknown
+     *
+     * @examplePrompt What kind of element is this?
+     * @examplePrompt Is the selected object a wall or a mass?
+     * @examplePrompt Tell me the type of this component
+     * @examplePrompt What am I looking at — a door, a window, or a panel?
+     *
+     * # Example
+     * ```ts
+     * // Dispatch on what the user selected
+     * const selection = await snaptrude.design.selection.get()
+     * for (const component of selection) {
+     *   const kind = await snaptrude.design.query.getEntityType(component)
+     *   if (kind === "wall") {
+     *     // wall-specific handling
+     *   } else if (kind === "space") {
+     *     // room-specific handling
+     *   }
+     * }
+     * ```
+     */
+    abstract getEntityType(component: ComponentHandle): PluginApiReturn<PluginEntityType | null>;
+    /**
+     * Get an entity's human label (`room_type` for spaces/masses, else the mesh
+     * label; `""` when unlabelled). The write side is `design.update` (`setLabel`).
+     * @param component - the entity's {@linkcode ComponentHandle}
+     * @returns the label string
+     *
+     * @examplePrompt What is this room called?
+     * @examplePrompt Get the name of the selected object
+     * @examplePrompt Show the label on this wall
+     * @examplePrompt What's the room type of this space?
+     *
+     * # Example
+     * ```ts
+     * // Fuzzy label search (the `label` filter field is exact-match; for
+     * // case-insensitive or partial matches, read labels and compare yourself)
+     * const spaces = await snaptrude.design.query.listSpaces()
+     * const kitchens: typeof spaces = []
+     * for (const space of spaces) {
+     *   const label = await snaptrude.design.query.getLabel(space)
+     *   if (label.toLowerCase().includes("kitchen")) kitchens.push(space)
+     * }
+     * ```
+     */
+    abstract getLabel(component: ComponentHandle): PluginApiReturn<string>;
+    /**
+     * Get a serializable, persistable reference to an entity. Under the all-handle
+     * model a {@linkcode ComponentHandle} already IS the ref (raw `Component.id`),
+     * so this is the identity passthrough — provided for API completeness.
+     * @param component - the entity's {@linkcode ComponentHandle}
+     * @returns the entity's {@linkcode ComponentHandle}
+     *
+     * @examplePrompt Give me a reference I can save for this element
+     * @examplePrompt Get a persistent id for the selected wall
+     * @examplePrompt Store a handle to this room so I can find it later
+     *
+     * # Example
+     * ```ts
+     * const [wall] = await snaptrude.design.query.listWalls()
+     * const savedRef = await snaptrude.design.query.getEntityRef(wall)
+     * // savedRef is a plain string — persist it, then revalidate in a later run
+     * // with snaptrude.design.query.getById(savedRef)
+     * ```
+     */
+    abstract getEntityRef(component: ComponentHandle): PluginApiReturn<ComponentHandle>;
+    /**
+     * List an entity's direct child entities — for example the doors and windows
+     * hosted in a wall.
+     * @param component - the entity's {@linkcode ComponentHandle}
+     * @returns child {@linkcode ComponentHandle}`[]` (`[]` if none)
+     *
+     * @examplePrompt What's inside this wall — list its doors and windows
+     * @examplePrompt Show the child elements of the selected object
+     * @examplePrompt Which openings belong to this wall?
+     * @examplePrompt List everything nested under this mass
+     *
+     * # Example
+     * ```ts
+     * // Count the openings hosted in a wall, split by kind
+     * const children = await snaptrude.design.query.listChildren(wall)
+     * let doors = 0
+     * let windows = 0
+     * for (const child of children) {
+     *   const kind = await snaptrude.design.query.getEntityType(child)
+     *   if (kind === "door") doors++
+     *   if (kind === "window") windows++
+     * }
+     * ```
+     */
+    abstract listChildren(component: ComponentHandle): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * Get an entity's host/parent entity (e.g. the wall a door is cut into).
+     * @param component - the entity's {@linkcode ComponentHandle}
+     * @returns the host {@linkcode ComponentHandle}, or `null` if top-level
+     *
+     * @examplePrompt Which wall is this door in?
+     * @examplePrompt Find the parent of the selected window
+     * @examplePrompt What is this element attached to?
+     * @examplePrompt Which wall hosts this window?
+     *
+     * # Example
+     * ```ts
+     * // From a door up to its host wall, then measure the wall
+     * const [door] = await snaptrude.design.query.listDoors({ isSelected: true })
+     * const hostWall = door ? await snaptrude.design.query.getHost(door) : null
+     * if (hostWall) {
+     *   const m = await snaptrude.design.query.measure(hostWall)
+     *   console.log("wall length:", m?.length)
+     * }
+     * ```
+     */
+    abstract getHost(component: ComponentHandle): PluginApiReturn<ComponentHandle | null>;
+    /**
+     * Read an entity's common properties as a {@linkcode PluginEntityProperties}
+     * record (only applicable fields are present). For spaces/masses this includes
+     * `adjacency` — the per-entity adjacency read (bulk form:
+     * `program.adjacency.getMatrix`).
+     *
+     * @param component - the entity's {@linkcode ComponentHandle}
+     * @returns the property record
+     *
+     * @examplePrompt Show me all the details of the selected object
+     * @examplePrompt What storey is this wall on?
+     * @examplePrompt Which department does this room belong to?
+     * @examplePrompt Is this element locked or hidden?
+     * @examplePrompt Get the adjacencies of this space
+     *
+     * # Example
+     * ```ts
+     * const [wall] = await snaptrude.design.query.listWalls()
+     * const props = await snaptrude.design.query.getProperties(wall)
+     * console.log(props.type, props.storey, props.boundingBox)
+     *
+     * // The record is partial — type-specific fields exist only where they apply
+     * const [room] = await snaptrude.design.query.listSpaces()
+     * const p = await snaptrude.design.query.getProperties(room)
+     * if (p.spaceType === "Room" && p.areaClass === "NET") {
+     *   for (const adj of p.adjacency ?? []) {
+     *     // adj.value: 2 = direct, 1 = indirect/contact, -1 = restricted
+     *     console.log(adj.spaceId, adj.value)
+     *   }
+     * }
+     * ```
+     */
+    abstract getProperties(component: ComponentHandle): PluginApiReturn<PluginEntityProperties>;
+    /**
+     * Measure an entity — read its area, volume, and/or running length (whichever
+     * its type supports) together with its world-space bounding box in one call.
+     *
+     * @param component - the entity's {@linkcode ComponentHandle}
+     * @returns a {@linkcode PluginEntityMeasurements}, or `null` if the entity is gone
+     *
+     * @examplePrompt What's the area of this room?
+     * @examplePrompt How long is the selected wall?
+     * @examplePrompt Get the volume of this mass
+     * @examplePrompt Give me the dimensions of the selected element
+     * @examplePrompt What's the floor area of the kitchen?
+     *
+     * # Example
+     * ```ts
+     * const [space] = await snaptrude.design.query.listSpaces()
+     * const m = await snaptrude.design.query.measure(space)
+     * console.log(m?.area, m?.volume)
+     * ```
+     */
+    abstract measure(component: ComponentHandle): PluginApiReturn<PluginEntityMeasurements | null>;
+    /**
+     * Get the **union** axis-aligned bounding box enclosing a set of entities.
+     *
+     * @param components - the set of entity {@linkcode ComponentHandle}s
+     * @returns the union {@linkcode BBoxComponents}, or `null` if the set is empty /
+     *   none resolve
+     *
+     * @examplePrompt Get the bounding box around the selected objects
+     * @examplePrompt What is the overall extent of these walls?
+     * @examplePrompt How big is the region these elements cover together?
+     * @examplePrompt Find the combined extents of everything on level 2
+     *
+     * # Example
+     * ```ts
+     * const walls = await snaptrude.design.query.listWalls()
+     * const box = await snaptrude.design.query.getBoundingBox(walls)
+     *
+     * // Compose with the `within` filter: everything in the selection's extents
+     * const selection = await snaptrude.design.selection.get()
+     * const extents = await snaptrude.design.query.getBoundingBox(selection)
+     * if (extents) {
+     *   const nearby = await snaptrude.design.query.listEntities({ within: extents })
+     *   const width = extents.max.x - extents.min.x
+     * }
+     * ```
+     */
+    abstract getBoundingBox(components: ComponentHandle[]): PluginApiReturn<BBoxComponents | null>;
+}
+export * from "./geometry";
+export * from "./spaces";
+//# sourceMappingURL=index.d.ts.map