@snaptrude/plugin-core 0.3.0 → 0.6.0

package/src/api/entity/space.ts

@@ -1,214 +1,27 @@
+// Space value types + schemas. The `entity.space.*` API was removed and its
+// operations migrated to `design.create.spaces` / `design.update.*` /
+// `design.query.*` / `design.delete.entities`. These shared space types survive
+// here because `design.create` / `design.query` / `design.update` import them.
 import * as z from "zod"
-import { PluginApiReturn } from "../../types"
-import { PVec3 } from "../core/math/vec3"
-import { PQuat } from "../core/math/quat"
-import { PProfile } from "../core/geom/profile"
+import {
+  ProfileHandle,
+  Vec3Handle,
+  Vec3Components,
+  QuatComponents,
+  CurveHandle,
+} from "../../handles"
 
-/**
- * Space (room/mass) management — create, query, and delete spaces.
- *
- * A **space** is a 3D volume representing a room or mass in the
- * Snaptrude scene. Spaces live on a particular story and carry
- * properties such as name, area, department, and room type.
- *
- * All methods are **host API calls** that return Promises and support
- * undo/redo via Snaptrude's command system.
- *
- * Accessed via `snaptrude.entity.space`.
- */
-export abstract class PluginSpaceApi {
-  constructor() {}
-
-  /**
-   * Create a rectangular (box) space.
-   *
-   * Generates an axis-aligned box with the given dimensions at the
-   * specified position. The created space is automatically assigned
-   * to the active story and a default department.
-   *
-   * @param args - An object containing:
-   *   - {@linkcode PluginSpaceCreateRectangularArgs.position args.position} — Origin
-   *     position as a {@linkcode PVec3} in Babylon units
-   *   - {@linkcode PluginSpaceCreateRectangularArgs.dimensions args.dimensions} — Box
-   *     dimensions `{ width, height, depth }` in Babylon units
-   * @returns A {@linkcode PluginSpaceCreateRectangularResult} with the `spaceId`
-   *   of the created space
-   * @throws If space creation fails
-   *
-   * # Example
-   * ```ts
-   * const { vec3 } = snaptrude.core.math
-   *
-   * const { spaceId } = await snaptrude.entity.space.createRectangular({
-   *   position: vec3.new(0, 0, 0),
-   *   dimensions: { width: 5, height: 3, depth: 4 },
-   * })
-   * ```
-   */
-  public abstract createRectangular({
-    position,
-    dimensions,
-  }: PluginSpaceCreateRectangularArgs): PluginApiReturn<PluginSpaceCreateRectangularResult>
-
-  /**
-   * Create a space by extruding a 2D profile.
-   *
-   * The {@linkcode PluginSpaceCreateFromProfileArgs.profile profile} is extruded
-   * upward (along the Y axis) by {@linkcode PluginSpaceCreateFromProfileArgs.extrudeHeight
-   * extrudeHeight}, then offset by {@linkcode PluginSpaceCreateFromProfileArgs.position
-   * position}. The created space is automatically assigned to the active story
-   * and a default department.
-   *
-   * Use {@linkcode PluginProfileApi.fromLinePoints} to quickly build a profile
-   * from a list of points.
-   *
-   * @param args - An object containing:
-   *   - {@linkcode PluginSpaceCreateFromProfileArgs.profile args.profile} — A closed
-   *     {@linkcode PProfile} defining the floor shape
-   *   - {@linkcode PluginSpaceCreateFromProfileArgs.extrudeHeight args.extrudeHeight} —
-   *     Extrusion height in Babylon units
-   *   - {@linkcode PluginSpaceCreateFromProfileArgs.position args.position} — Offset
-   *     position as a {@linkcode PVec3} in Babylon units
-   * @returns A {@linkcode PluginSpaceCreateFromProfileResult} with the `spaceId`
-   *   of the created space
-   * @throws If the profile is invalid or mesh creation fails
-   *
-   * # Example
-   * ```ts
-   * const { vec3 } = snaptrude.core.math
-   *
-   * const profile = await snaptrude.core.geom.profile.fromLinePoints({
-   *   points: [
-   *     vec3.new(0, 0, 0),
-   *     vec3.new(10, 0, 0),
-   *     vec3.new(10, 0, 8),
-   *     vec3.new(0, 0, 8),
-   *   ],
-   * })
-   *
-   * const { spaceId } = await snaptrude.entity.space.createFromProfile({
-   *   profile,
-   *   extrudeHeight: 3,
-   *   position: vec3.new(0, 0, 0),
-   * })
-   * ```
-   */
-  public abstract createFromProfile({
-    profile,
-    extrudeHeight,
-    position,
-  }: PluginSpaceCreateFromProfileArgs): PluginApiReturn<PluginSpaceCreateFromProfileResult>
-
-  /**
-   * Get the IDs of all spaces in the current project.
-   *
-   * Returns every space (mass that is not a building) across all stories.
-   * Use the returned IDs with {@linkcode PluginSpaceApi.get} to query
-   * individual space properties.
-   *
-   * @returns A {@linkcode PluginSpaceGetAllResult} with a `spacesIds` array
-   *
-   * # Example
-   * ```ts
-   * const { spacesIds } = await snaptrude.entity.space.getAll()
-   * console.log(`Project has ${spacesIds.length} spaces`)
-   * ```
-   */
-  public abstract getAll(): PluginApiReturn<PluginSpaceGetAllResult>
-
-  /**
-   * Get properties of a space by its ID.
-   *
-   * Only the properties listed in {@linkcode PluginSpaceGetArgs.properties
-   * args.properties} are returned — unlisted properties will be `undefined`
-   * in the result.
-   *
-   * @param args - An object containing:
-   *   - {@linkcode PluginSpaceGetArgs.spaceId args.spaceId} — The unique space ID
-   *     (as returned by creation methods or {@linkcode PluginSpaceApi.getAll})
-   *   - {@linkcode PluginSpaceGetArgs.properties args.properties} — Array of property
-   *     names to retrieve. See {@linkcode PluginSpaceGetProperty} for available values.
-   * @returns A partial {@linkcode PluginSpaceGetResult} containing only the requested
-   *   properties
-   * @throws If the space does not exist or the component is not a space/mass
-   *
-   * # Example
-   * ```ts
-   * const info = await snaptrude.entity.space.get({
-   *   spaceId: "some-space-id",
-   *   properties: ["name", "area", "position"],
-   * })
-   * console.log(info.name, info.area, info.position)
-   * ```
-   */
-  public abstract get({
-    spaceId,
-    properties,
-  }: PluginSpaceGetArgs): PluginApiReturn<PluginSpaceGetResult>
-
-  /**
-   * Delete a space by its ID.
-   *
-   * Permanently removes the space and its associated mesh from the scene.
-   * This operation is undoable via Snaptrude's command system.
-   *
-   * @param args - An object containing:
-   *   - {@linkcode PluginSpaceDeleteArgs.spaceId args.spaceId} — The unique space ID
-   *     to delete
-   * @throws If the space does not exist or the component is not a space/mass
-   *
-   * # Example
-   * ```ts
-   * await snaptrude.entity.space.delete({ spaceId: "some-space-id" })
-   * ```
-   */
-  public abstract delete({
-    spaceId,
-  }: PluginSpaceDeleteArgs): PluginApiReturn<PluginSpaceDeleteResult>
-
-  /**
-   * Update properties of a space by its ID.
-   *
-   * Only the properties provided in {@linkcode PluginSpaceUpdateArgs.properties
-   * args.properties} will be updated — omitted properties remain unchanged.
-   * This operation is undoable via Snaptrude's command system.
-   *
-   * @param args - An object containing:
-   *   - {@linkcode PluginSpaceUpdateArgs.spaceId args.spaceId} — The unique space ID
-   *     to update
-   *   - {@linkcode PluginSpaceUpdateArgs.properties args.properties} — Key/value pairs
-   *     of properties to update. See {@linkcode PluginSpaceUpdateArgs} for supported fields.
-   * @returns A {@linkcode PluginSpaceUpdateResult} echoing back the `spaceId` and
-   *   the updated property values
-   * @throws If the space does not exist or the component is not a space/mass
-   *
-   * # Example
-   * ```ts
-   * const result = await snaptrude.entity.space.update({
-   *   spaceId: "some-space-id",
-   *   properties: {
-   *     room_type: "Kitchen",
-   *     massType: "Room",
-   *     departmentId: "CORE",
-   *   },
-   * })
-   * ```
-   */
-  public abstract update(
-    args: PluginSpaceUpdateArgs
-  ): PluginApiReturn<PluginSpaceUpdateResult>
-}
 
 /**
- * Arguments for {@linkcode PluginSpaceApi.createRectangular}.
+ * Arguments for `createRectangular`.
  *
  * | Property | Type | Description |
  * |---|---|---|
- * | `position` | {@linkcode PVec3} | Origin position in Babylon units |
+ * | `position` | {@linkcode Vec3Handle} | Origin position in Babylon units |
  * | `dimensions` | `{ width, height, depth }` | Box dimensions in Babylon units |
  */
 export const PluginSpaceCreateRectangularArgs = z.object({
-  position: PVec3,
+  position: Vec3Handle,
   dimensions: z.object({
     width: z.number(),
     height: z.number(),
@@ -221,7 +34,7 @@ export type PluginSpaceCreateRectangularArgs = z.infer<
 >
 
 /**
- * Result of {@linkcode PluginSpaceApi.createRectangular}.
+ * Result of `createRectangular`.
  *
  * | Property | Type | Description |
  * |---|---|---|
@@ -236,18 +49,20 @@ export type PluginSpaceCreateRectangularResult = z.infer<
 >
 
 /**
- * Arguments for {@linkcode PluginSpaceApi.createFromProfile}.
+ * Arguments for `createFromProfile`.
  *
  * | Property | Type | Description |
  * |---|---|---|
- * | `profile` | {@linkcode PProfile} | Closed 2D profile defining the floor shape |
+ * | `profile` | {@linkcode ProfileHandle} | Handle to a closed 2D profile (the outer floor shape) |
+ * | `innerProfiles` | {@linkcode ProfileHandle}`[]` | Optional profile handles to subtract as holes |
  * | `extrudeHeight` | `number` | Extrusion height in Babylon units |
- * | `position` | {@linkcode PVec3} | Offset position in Babylon units |
+ * | `position` | {@linkcode Vec3Handle} | Offset position in Babylon units |
  */
 export const PluginSpaceCreateFromProfileArgs = z.object({
-  profile: PProfile,
+  profile: ProfileHandle,
+  innerProfiles: z.array(ProfileHandle).optional(),
   extrudeHeight: z.number(),
-  position: PVec3,
+  position: Vec3Handle,
 })
 
 export type PluginSpaceCreateFromProfileArgs = z.infer<
@@ -255,7 +70,7 @@ export type PluginSpaceCreateFromProfileArgs = z.infer<
 >
 
 /**
- * Result of {@linkcode PluginSpaceApi.createFromProfile}.
+ * Result of `createFromProfile`.
  *
  * | Property | Type | Description |
  * |---|---|---|
@@ -269,6 +84,40 @@ export type PluginSpaceCreateFromProfileResult = z.infer<
   typeof PluginSpaceCreateFromProfileResult
 >
 
+/**
+ * Arguments for `updateGeometryFromProfile`.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `spaceId` | `string` | Space to update |
+ * | `profile` | {@linkcode ProfileHandle} | Handle to the closed 2D profile defining the new floor shape |
+ * | `extrudeHeight` | `number` | New extrusion height in Babylon units |
+ */
+export const PluginSpaceUpdateGeometryFromProfileArgs = z.object({
+  spaceId: z.string(),
+  profile: ProfileHandle,
+  extrudeHeight: z.number(),
+})
+
+export type PluginSpaceUpdateGeometryFromProfileArgs = z.infer<
+  typeof PluginSpaceUpdateGeometryFromProfileArgs
+>
+
+/**
+ * Result of `updateGeometryFromProfile`.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `spaceId` | `string` | Unique ID of the updated space |
+ */
+export const PluginSpaceUpdateGeometryFromProfileResult = z.object({
+  spaceId: z.string(),
+})
+
+export type PluginSpaceUpdateGeometryFromProfileResult = z.infer<
+  typeof PluginSpaceUpdateGeometryFromProfileResult
+>
+
 /**
  * Available properties that can be queried on a space.
  *
@@ -297,15 +146,23 @@ export type PluginSpaceCreateFromProfileResult = z.infer<
  * **Derived from mesh:**
  * | Value | Return Type | Description |
  * |---|---|---|
- * | `"position"` | {@linkcode PVec3} | Local position relative to parent |
- * | `"absolutePosition"` | {@linkcode PVec3} | Absolute position in the scene |
- * | `"rotation"` | {@linkcode PVec3} | Euler rotation angles (radians) |
- * | `"rotationQuaternion"` | {@linkcode PQuat} \| `null` | Quaternion rotation, or `null` if unset |
+ * | `"position"` | {@linkcode Vec3Components} | Local position relative to parent |
+ * | `"absolutePosition"` | {@linkcode Vec3Components} | Absolute position in the scene |
+ * | `"rotation"` | {@linkcode Vec3Components} | Euler rotation angles (radians) |
+ * | `"rotationQuaternion"` | {@linkcode QuatComponents} \| `null` | Quaternion rotation, or `null` if unset |
  *
  * **Derived from brep:**
  * | Value | Return Type | Description |
  * |---|---|---|
- * | `"planPoints"` | {@linkcode PVec3}`[]` | Bottom outer profile points in world space with `y = 0` (2D plan). No closing duplicate point. |
+ * | `"planPoints"` | {@linkcode Vec3Components}`[]` | Bottom outer profile points in world space with `y = 0` (2D plan). No closing duplicate point. |
+ * | `"profile"` | {@linkcode CurveHandle}`[]` | Bottom outer profile curves in world space, as opaque curve handles. Read coordinates via the `core.geom.curve` read API. |
+ * | `"innerProfiles"` | {@linkcode CurveHandle}`[][]` | Inner (hole) profile curve loops in world space — one loop per hole, `[]` when the space has none. Each curve is an opaque handle. |
+ * | `"innerPlanPoints"` | {@linkcode Vec3Components}`[][]` | Inner (hole) profile points in world space with `y = 0` — one loop per hole, no closing duplicate, `[]` when none. |
+ *
+ * **Derived from adjacency manager:**
+ * | Value | Return Type | Description |
+ * |---|---|---|
+ * | `"adjacency"` | `{ spaceId: string; value: number }[]` | Adjacency relationships to other spaces. `value`: `2` = Direct (required), `1` = Indirect or physical contact, `-1` = Restricted; `0` (no relationship) entries are filtered out. Empty when adjacency has never been computed — see `program.adjacency.compute`. |
  */
 export const PluginSpaceGetProperty = z.enum([
   // Basic
@@ -320,6 +177,7 @@ export const PluginSpaceGetProperty = z.enum([
   "height",
   "massType",
   "spaceType",
+  "areaClass",
   "storey",
   "departmentId",
   "departmentName",
@@ -331,10 +189,15 @@ export const PluginSpaceGetProperty = z.enum([
   "rotationQuaternion",
   // Derived from brep
   "planPoints",
+  "profile",
+  "innerProfiles",
+  "innerPlanPoints",
+  // Derived from adjacency manager
+  "adjacency",
 ])
 
 /**
- * Arguments for {@linkcode PluginSpaceApi.get}.
+ * Arguments for `get`.
  *
  * | Property | Type | Description |
  * |---|---|---|
@@ -376,11 +239,24 @@ export const PluginSpaceType = z.enum([
   "Pool",
   "Walkway",
   "Envelope",
-  "Parking"
+  "Parking",
 ])
+/** The space-type value union (same-name type alias for positional signatures). */
+export type PluginSpaceType = z.infer<typeof PluginSpaceType>
 
 /**
- * Result of {@linkcode PluginSpaceApi.get}.
+ * Area-class classification of a space (mirrors the internal `AreaClass` enum).
+ *
+ * | Value | Description |
+ * |---|---|
+ * | `"NET"` | Net (usable) area |
+ * | `"GROSS"` | Gross area |
+ * | `"EXCLUDED"` | Excluded from area totals |
+ */
+export const PluginAreaClass = z.enum(["NET", "GROSS", "EXCLUDED"])
+
+/**
+ * Result of `get`.
  *
  * A partial object — only the properties that were requested in
  * {@linkcode PluginSpaceGetArgs.properties} will be present.
@@ -399,24 +275,36 @@ export const PluginSpaceGetResult = z
     height: z.number(),
     massType: z.string().nullable(),
     spaceType: PluginSpaceType.nullable(),
+    areaClass: PluginAreaClass,
     storey: z.number().nullable(),
     departmentId: z.string().nullable(),
     departmentName: z.string(),
     departmentColor: z.string(),
     // Derived from mesh
-    position: PVec3,
-    absolutePosition: PVec3,
-    rotation: PVec3,
-    rotationQuaternion: PQuat.nullable(),
+    position: Vec3Components,
+    absolutePosition: Vec3Components,
+    rotation: Vec3Components,
+    rotationQuaternion: QuatComponents.nullable(),
     // Derived from brep
-    planPoints: z.array(PVec3),
+    planPoints: z.array(Vec3Components),
+    profile: z.array(CurveHandle),
+    innerProfiles: z.array(z.array(CurveHandle)),
+    innerPlanPoints: z.array(z.array(Vec3Components)),
+    // Derived from adjacency manager.
+    // value: 2 = Direct (required), 1 = Indirect or physical contact, -1 = Restricted;
+    // 0 (no relationship) entries are filtered out. Empty array when adjacency has
+    // never been computed — run program.adjacency.compute() first for fresh data.
+    adjacency: z.array(z.object({
+      spaceId: z.string(),
+      value: z.number(),
+    })),
   })
   .partial()
 
 export type PluginSpaceGetResult = z.infer<typeof PluginSpaceGetResult>
 
 /**
- * Result of {@linkcode PluginSpaceApi.getAll}.
+ * Result of `getAll`.
  *
  * | Property | Type | Description |
  * |---|---|---|
@@ -429,7 +317,7 @@ export const PluginSpaceGetAllResult = z.object({
 export type PluginSpaceGetAllResult = z.infer<typeof PluginSpaceGetAllResult>
 
 /**
- * Arguments for {@linkcode PluginSpaceApi.delete}.
+ * Arguments for `delete`.
  *
  * | Property | Type | Description |
  * |---|---|---|
@@ -441,7 +329,7 @@ export const PluginSpaceDeleteArgs = z.object({
 
 export type PluginSpaceDeleteArgs = z.infer<typeof PluginSpaceDeleteArgs>
 
-/** Result type for {@linkcode PluginSpaceApi.delete} — returns nothing on success. */
+/** Result type for `delete` — returns nothing on success. */
 export type PluginSpaceDeleteResult = void
 
 /**
@@ -478,6 +366,8 @@ export const PluginMassType = z.enum([
   "Mass",
   "Site",
 ])
+/** The mass-type value union (same-name type alias for positional signatures). */
+export type PluginMassType = z.infer<typeof PluginMassType>
 
 /**
  * Well-known (built-in) department IDs.
@@ -504,9 +394,11 @@ export const PluginDepartmentId = z.union([
   PluginWellKnownDepartmentId,
   z.uuid(),
 ])
+/** The department-id value union (same-name type alias for positional signatures). */
+export type PluginDepartmentId = z.infer<typeof PluginDepartmentId>
 
 /**
- * Arguments for {@linkcode PluginSpaceApi.update}.
+ * Arguments for `update`.
  *
  * | Property | Type | Description |
  * |---|---|---|
@@ -522,6 +414,7 @@ export const PluginSpaceUpdateArgs = z.object({
     room_type: z.string().optional(),
     massType: PluginMassType.optional(),
     spaceType: PluginSpaceType.optional(),
+    areaClass: PluginAreaClass.optional(),
     departmentId: PluginDepartmentId.optional(),
   }),
 })
@@ -529,7 +422,7 @@ export const PluginSpaceUpdateArgs = z.object({
 export type PluginSpaceUpdateArgs = z.infer<typeof PluginSpaceUpdateArgs>
 
 /**
- * Result of {@linkcode PluginSpaceApi.update}.
+ * Result of `update`.
  *
  * Echoes back the `spaceId` and the values of properties that were updated.
  * Properties that were not included in the update request will be `undefined`.
@@ -547,7 +440,173 @@ export const PluginSpaceUpdateResult = z.object({
   room_type: z.string().optional(),
   massType: z.string().optional(),
   spaceType: z.string().optional(),
+  areaClass: PluginAreaClass.optional(),
   departmentId: z.string().nullable().optional(),
 })
 
 export type PluginSpaceUpdateResult = z.infer<typeof PluginSpaceUpdateResult>
+
+// ---------------------------------------------------------------------------
+// Bulk operations
+// ---------------------------------------------------------------------------
+
+/**
+ * A single item for `bulkCreate`.
+ *
+ * Discriminated on `kind`:
+ * - `"rectangular"` — a box defined by `position` + `dimensions` (mirrors
+ *   {@linkcode PluginSpaceCreateRectangularArgs})
+ * - `"profile"` — an extruded `profile` (with optional `innerProfiles`) by
+ *   `extrudeHeight` at `position` (mirrors {@linkcode PluginSpaceCreateFromProfileArgs})
+ *
+ * Every item may optionally set `room_type`, `spaceType`, `massType`, and
+ * `departmentId`; these are applied within the same single undo step as the
+ * creation.
+ */
+export const PluginSpaceBulkCreateItem = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("rectangular"),
+    position: Vec3Handle,
+    dimensions: z.object({
+      width: z.number(),
+      height: z.number(),
+      depth: z.number(),
+    }),
+    room_type: z.string().optional(),
+    spaceType: PluginSpaceType.optional(),
+    massType: PluginMassType.optional(),
+    departmentId: PluginDepartmentId.optional(),
+  }),
+  z.object({
+    kind: z.literal("profile"),
+    profile: ProfileHandle,
+    innerProfiles: z.array(ProfileHandle).optional(),
+    extrudeHeight: z.number(),
+    position: Vec3Handle,
+    room_type: z.string().optional(),
+    spaceType: PluginSpaceType.optional(),
+    massType: PluginMassType.optional(),
+    departmentId: PluginDepartmentId.optional(),
+  }),
+])
+
+export type PluginSpaceBulkCreateItem = z.infer<typeof PluginSpaceBulkCreateItem>
+
+/**
+ * Arguments for `bulkCreate`.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `items` | {@linkcode PluginSpaceBulkCreateItem}`[]` | Spaces to create |
+ */
+export const PluginSpaceBulkCreateArgs = z.object({
+  items: z.array(PluginSpaceBulkCreateItem),
+})
+
+export type PluginSpaceBulkCreateArgs = z.infer<typeof PluginSpaceBulkCreateArgs>
+
+/**
+ * Result of `bulkCreate`.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `spaceIds` | `string[]` | IDs of the created spaces, in input order |
+ */
+export const PluginSpaceBulkCreateResult = z.object({
+  spaceIds: z.array(z.string()),
+})
+
+export type PluginSpaceBulkCreateResult = z.infer<
+  typeof PluginSpaceBulkCreateResult
+>
+
+/**
+ * A single item for `bulkUpdate`.
+ *
+ * Targets an existing space by `spaceId`. Geometry fields `profile` and
+ * `extrudeHeight` must be supplied **together** (mirrors
+ * {@linkcode PluginSpaceUpdateGeometryFromProfileArgs}). Property changes are
+ * nested under `properties`, mirroring {@linkcode PluginSpaceUpdateArgs}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `spaceId` | `string` | The space to update |
+ * | `profile` | {@linkcode ProfileHandle}`?` | New floor shape handle (requires `extrudeHeight`) |
+ * | `extrudeHeight` | `number?` | New extrusion height (requires `profile`) |
+ * | `properties` | `object?` | Property changes (same shape as {@linkcode PluginSpaceUpdateArgs.properties}) |
+ */
+export const PluginSpaceBulkUpdateItem = z.object({
+  spaceId: z.string(),
+  profile: ProfileHandle.optional(),
+  extrudeHeight: z.number().optional(),
+  properties: z
+    .object({
+      room_type: z.string().optional(),
+      massType: PluginMassType.optional(),
+      spaceType: PluginSpaceType.optional(),
+      areaClass: PluginAreaClass.optional(),
+      departmentId: PluginDepartmentId.optional(),
+    })
+    .optional(),
+})
+
+export type PluginSpaceBulkUpdateItem = z.infer<typeof PluginSpaceBulkUpdateItem>
+
+/**
+ * Arguments for `bulkUpdate`.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `items` | {@linkcode PluginSpaceBulkUpdateItem}`[]` | Spaces to update |
+ */
+export const PluginSpaceBulkUpdateArgs = z.object({
+  items: z.array(PluginSpaceBulkUpdateItem),
+})
+
+export type PluginSpaceBulkUpdateArgs = z.infer<typeof PluginSpaceBulkUpdateArgs>
+
+/**
+ * Result of `bulkUpdate`.
+ *
+ * Echoes one {@linkcode PluginSpaceUpdateResult} per item, in input order —
+ * the same per-space shape returned by `update`.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `spaces` | {@linkcode PluginSpaceUpdateResult}`[]` | Per-item updated values, in input order |
+ */
+export const PluginSpaceBulkUpdateResult = z.object({
+  spaces: z.array(PluginSpaceUpdateResult),
+})
+
+export type PluginSpaceBulkUpdateResult = z.infer<
+  typeof PluginSpaceBulkUpdateResult
+>
+
+/**
+ * Arguments for `bulkDelete`.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `spaceIds` | `string[]` | The space IDs to delete |
+ */
+export const PluginSpaceBulkDeleteArgs = z.object({
+  spaceIds: z.array(z.string()),
+})
+
+export type PluginSpaceBulkDeleteArgs = z.infer<typeof PluginSpaceBulkDeleteArgs>
+
+/**
+ * Result of `bulkDelete`.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `deletedSpaceIds` | `string[]` | The space IDs that were removed |
+ */
+export const PluginSpaceBulkDeleteResult = z.object({
+  deletedSpaceIds: z.array(z.string()),
+})
+
+export type PluginSpaceBulkDeleteResult = z.infer<
+  typeof PluginSpaceBulkDeleteResult
+>