@snaptrude/plugin-core 0.0.4 → 0.0.6

package/src/api/entity/space.ts

@@ -4,32 +4,177 @@ import { PVec3 } from "../core/math/vec3"
 import { PQuat } from "../core/math/quat"
 import { PProfile } from "../core/geom/profile"
 
+/**
+ * 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>
 
-  public abstract deleteById({
+  /**
+   * 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,
-  }: PluginSpaceDeleteByIdArgs): PluginApiReturn<PluginSpaceDeleteByIdResult>
+  }: PluginSpaceDeleteArgs): PluginApiReturn<PluginSpaceDeleteResult>
 }
 
+/**
+ * Arguments for {@linkcode PluginSpaceApi.createRectangular}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `position` | {@linkcode PVec3} | Origin position in Babylon units |
+ * | `dimensions` | `{ width, height, depth }` | Box dimensions in Babylon units |
+ */
 export const PluginSpaceCreateRectangularArgs = z.object({
   position: PVec3,
   dimensions: z.object({
@@ -41,12 +186,28 @@ export const PluginSpaceCreateRectangularArgs = z.object({
 
 export type PluginSpaceCreateRectangularArgs = z.infer<typeof PluginSpaceCreateRectangularArgs>
 
+/**
+ * Result of {@linkcode PluginSpaceApi.createRectangular}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `spaceId` | `string` | Unique ID of the created space |
+ */
 export const PluginSpaceCreateRectangularResult = z.object({
   spaceId: z.string(),
 })
 
 export type PluginSpaceCreateRectangularResult = z.infer<typeof PluginSpaceCreateRectangularResult>
 
+/**
+ * Arguments for {@linkcode PluginSpaceApi.createFromProfile}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode PProfile} | Closed 2D profile defining the floor shape |
+ * | `extrudeHeight` | `number` | Extrusion height in Babylon units |
+ * | `position` | {@linkcode PVec3} | Offset position in Babylon units |
+ */
 export const PluginSpaceCreateFromProfileArgs = z.object({
   profile: PProfile,
   extrudeHeight: z.number(),
@@ -55,12 +216,35 @@ export const PluginSpaceCreateFromProfileArgs = z.object({
 
 export type PluginSpaceCreateFromProfileArgs = z.infer<typeof PluginSpaceCreateFromProfileArgs>
 
+/**
+ * Result of {@linkcode PluginSpaceApi.createFromProfile}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `spaceId` | `string` | Unique ID of the created space |
+ */
 export const PluginSpaceCreateFromProfileResult = z.object({
   spaceId: z.string(),
 })
 
 export type PluginSpaceCreateFromProfileResult = z.infer<typeof PluginSpaceCreateFromProfileResult>
 
+/**
+ * Available properties that can be queried on a space.
+ *
+ * | Value | Return Type | Description |
+ * |---|---|---|
+ * | `"id"` | `string` | Unique space identifier |
+ * | `"type"` | `string` | Component type |
+ * | `"room_type"` | `string` | Room type classification |
+ * | `"name"` | `string` | Display name of the space |
+ * | `"area"` | `number` | Bottom (floor) area |
+ * | `"department"` | `string` | Assigned department name |
+ * | `"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 |
+ */
 export const PluginSpaceGetProperty = z.enum([
   "id",
   "type",
@@ -74,6 +258,14 @@ export const PluginSpaceGetProperty = z.enum([
   "rotationQuaternion",
 ])
 
+/**
+ * Arguments for {@linkcode PluginSpaceApi.get}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `spaceId` | `string` | The space ID to query |
+ * | `properties` | {@linkcode PluginSpaceGetProperty}`[]` | Properties to retrieve |
+ */
 export const PluginSpaceGetArgs = z.object({
   spaceId: z.string(),
   properties: z.array(PluginSpaceGetProperty),
@@ -81,6 +273,12 @@ export const PluginSpaceGetArgs = z.object({
 
 export type PluginSpaceGetArgs = z.infer<typeof PluginSpaceGetArgs>
 
+/**
+ * Result of {@linkcode PluginSpaceApi.get}.
+ *
+ * A partial object — only the properties that were requested in
+ * {@linkcode PluginSpaceGetArgs.properties} will be present.
+ */
 export const PluginSpaceGetResult = z
   .object({
     id: z.string(),
@@ -98,16 +296,31 @@ export const PluginSpaceGetResult = z
 
 export type PluginSpaceGetResult = z.infer<typeof PluginSpaceGetResult>
 
+/**
+ * Result of {@linkcode PluginSpaceApi.getAll}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `spacesIds` | `string[]` | IDs of all spaces in the project |
+ */
 export const PluginSpaceGetAllResult = z.object({
   spacesIds: z.array(z.string()),
 })
 
 export type PluginSpaceGetAllResult = z.infer<typeof PluginSpaceGetAllResult>
 
-export const PluginSpaceDeleteByIdArgs = z.object({
+/**
+ * Arguments for {@linkcode PluginSpaceApi.delete}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `spaceId` | `string` | The space ID to delete |
+ */
+export const PluginSpaceDeleteArgs = z.object({
   spaceId: z.string(),
 })
 
-export type PluginSpaceDeleteByIdArgs = z.infer<typeof PluginSpaceDeleteByIdArgs>
+export type PluginSpaceDeleteArgs = z.infer<typeof PluginSpaceDeleteArgs>
 
-export type PluginSpaceDeleteByIdResult = void
+/** Result type for {@linkcode PluginSpaceApi.delete} — returns nothing on success. */
+export type PluginSpaceDeleteResult = void

package/src/api/entity/story.ts

@@ -1,27 +1,140 @@
 import * as z from "zod"
 import { PluginApiReturn } from "../../types"
 
+/**
+ * Story (floor/storey) management.
+ *
+ * A story represents a building floor in the Snaptrude project. Stories
+ * are identified by their integer **story value** (e.g. `1` for ground
+ * floor, `2` for first floor, `-1` for a basement).
+ *
+ * All methods are **host API calls** that return Promises and support
+ * undo/redo via Snaptrude's command system.
+ *
+ * Accessed via `snaptrude.entity.story`.
+ */
 export abstract class PluginStoryApi {
   constructor() {}
 
+  /**
+   * Get properties of a story by its storey number.
+   *
+   * Only the properties listed in {@linkcode PluginStoryGetArgs.properties args.properties}
+   * are returned — unlisted properties will be `undefined` in the result.
+   *
+   * @param args - An object containing:
+   *   - {@linkcode PluginStoryGetArgs.storyValue args.storyValue} — Integer storey number
+   *     (e.g. `1` for ground floor, `2` for first floor, `-1` for basement)
+   *   - {@linkcode PluginStoryGetArgs.properties args.properties} — Array of property names
+   *     to retrieve. See {@linkcode PluginStoryGetProperty} for available values.
+   * @returns A partial {@linkcode PluginStoryGetResult} containing only the requested properties
+   * @throws If the story with the given value does not exist
+   *
+   * # Example
+   * ```ts
+   * const info = await snaptrude.entity.story.get({
+   *   storyValue: 1,
+   *   properties: ["height", "name", "spacesCount"],
+   * })
+   * console.log(info.name, info.height, info.spacesCount)
+   * ```
+   */
   public abstract get({
     storyValue,
     properties,
   }: PluginStoryGetArgs): PluginApiReturn<PluginStoryGetResult>
 
+  /**
+   * Get all stories in the current project.
+   *
+   * Returns basic identification data for every storey. Stories are sorted
+   * from **top to bottom** (highest story value first).
+   *
+   * @returns A {@linkcode PluginStoryGetAllResult} with a `stories` array,
+   *   each entry containing `value`, `id`, and `name`
+   *
+   * # Example
+   * ```ts
+   * const { stories } = await snaptrude.entity.story.getAll()
+   * for (const s of stories) {
+   *   console.log(`Story ${s.value}: ${s.name} (id: ${s.id})`)
+   * }
+   * ```
+   */
   public abstract getAll(): PluginApiReturn<PluginStoryGetAllResult>
 
+  /**
+   * Create a new story (floor) in the project.
+   *
+   * The new story is inserted at the position specified by
+   * {@linkcode PluginStoryCreateArgs.storyValue args.storyValue}. This
+   * operation is undoable.
+   *
+   * @param args - An object containing:
+   *   - {@linkcode PluginStoryCreateArgs.storyValue args.storyValue} — Integer storey number
+   *     to create (e.g. `3` to add a third floor)
+   *   - {@linkcode PluginStoryCreateArgs.height args.height} — Optional height in Babylon
+   *     units. If omitted, the project's default storey height is used.
+   * @returns A {@linkcode PluginStoryCreateResult} with `storyId` and `storyValue`
+   * @throws If a story with the given value already exists or creation fails
+   *
+   * # Example
+   * ```ts
+   * // Create a new third floor with custom height
+   * const { storyId } = await snaptrude.entity.story.create({
+   *   storyValue: 3,
+   *   height: 4.5,
+   * })
+   * ```
+   */
   public abstract create({
     storyValue,
     height,
   }: PluginStoryCreateArgs): PluginApiReturn<PluginStoryCreateResult>
 
+  /**
+   * Update a story's height.
+   *
+   * Changes the floor-to-floor height of the specified story. This
+   * operation is undoable.
+   *
+   * @param args - An object containing:
+   *   - {@linkcode PluginStoryUpdateArgs.storyValue args.storyValue} — Integer storey number
+   *     identifying the story to update
+   *   - {@linkcode PluginStoryUpdateArgs.height args.height} — New height value in Babylon
+   *     units
+   * @returns A {@linkcode PluginStoryUpdateResult} with the updated `storyValue` and `height`
+   * @throws If the story does not exist or the update fails
+   *
+   * # Example
+   * ```ts
+   * // Set ground floor height to 5 Babylon units
+   * const result = await snaptrude.entity.story.update({
+   *   storyValue: 1,
+   *   height: 5,
+   * })
+   * ```
+   */
   public abstract update({
     storyValue,
     height,
   }: PluginStoryUpdateArgs): PluginApiReturn<PluginStoryUpdateResult>
 }
 
+/**
+ * Available properties that can be queried on a story.
+ *
+ * | Value | Type | Description |
+ * |---|---|---|
+ * | `"value"` | `number` | The integer storey number |
+ * | `"id"` | `string` | Unique story identifier |
+ * | `"name"` | `string` | Display name of the story |
+ * | `"height"` | `number` | Floor-to-floor height in Babylon units |
+ * | `"base"` | `number` | Base elevation in Babylon units |
+ * | `"hidden"` | `boolean` | Whether the story is hidden in the viewport |
+ * | `"spacesCount"` | `number` | Number of spaces on this story |
+ * | `"totalArea"` | `number` | Total floor area of this story |
+ */
 export const PluginStoryGetProperty = z.enum([
   "value",
   "id",
@@ -33,6 +146,14 @@ export const PluginStoryGetProperty = z.enum([
   "totalArea",
 ])
 
+/**
+ * Arguments for {@linkcode PluginStoryApi.get}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `storyValue` | `number` (int) | The storey number to query |
+ * | `properties` | {@linkcode PluginStoryGetProperty}`[]` | Properties to retrieve |
+ */
 export const PluginStoryGetArgs = z.object({
   storyValue: z.number().int(),
   properties: z.array(PluginStoryGetProperty),
@@ -40,6 +161,12 @@ export const PluginStoryGetArgs = z.object({
 
 export type PluginStoryGetArgs = z.infer<typeof PluginStoryGetArgs>
 
+/**
+ * Result of {@linkcode PluginStoryApi.get}.
+ *
+ * A partial object — only the properties that were requested in
+ * {@linkcode PluginStoryGetArgs.properties} will be present.
+ */
 export const PluginStoryGetResult = z
   .object({
     value: z.number(),
@@ -55,6 +182,13 @@ export const PluginStoryGetResult = z
 
 export type PluginStoryGetResult = z.infer<typeof PluginStoryGetResult>
 
+/**
+ * Result of {@linkcode PluginStoryApi.getAll}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `stories` | `Array<{ value, id, name }>` | All stories, sorted top to bottom |
+ */
 export const PluginStoryGetAllResult = z.object({
   stories: z.array(
     z.object({
@@ -67,6 +201,14 @@ export const PluginStoryGetAllResult = z.object({
 
 export type PluginStoryGetAllResult = z.infer<typeof PluginStoryGetAllResult>
 
+/**
+ * Arguments for {@linkcode PluginStoryApi.create}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `storyValue` | `number` (int) | The storey number for the new story |
+ * | `height` | `number?` | Optional height in Babylon units |
+ */
 export const PluginStoryCreateArgs = z.object({
   storyValue: z.number().int(),
   height: z.number().optional(),
@@ -74,6 +216,14 @@ export const PluginStoryCreateArgs = z.object({
 
 export type PluginStoryCreateArgs = z.infer<typeof PluginStoryCreateArgs>
 
+/**
+ * Result of {@linkcode PluginStoryApi.create}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `storyId` | `string` | Unique ID of the created story |
+ * | `storyValue` | `number` | The storey number of the created story |
+ */
 export const PluginStoryCreateResult = z.object({
   storyId: z.string(),
   storyValue: z.number(),
@@ -81,6 +231,14 @@ export const PluginStoryCreateResult = z.object({
 
 export type PluginStoryCreateResult = z.infer<typeof PluginStoryCreateResult>
 
+/**
+ * Arguments for {@linkcode PluginStoryApi.update}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `storyValue` | `number` (int) | Storey number of the story to update |
+ * | `height` | `number` | New height in Babylon units |
+ */
 export const PluginStoryUpdateArgs = z.object({
   storyValue: z.number().int(),
   height: z.number(),
@@ -88,6 +246,14 @@ export const PluginStoryUpdateArgs = z.object({
 
 export type PluginStoryUpdateArgs = z.infer<typeof PluginStoryUpdateArgs>
 
+/**
+ * Result of {@linkcode PluginStoryApi.update}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `storyValue` | `number` | The storey number of the updated story |
+ * | `height` | `number` | The new height after the update |
+ */
 export const PluginStoryUpdateResult = z.object({
   storyValue: z.number(),
   height: z.number(),

package/src/api/index.ts

@@ -3,10 +3,24 @@ import { PluginEntityApi } from "./entity"
 import { PluginToolsApi } from "./tools"
 import { PluginUnitsApi } from "./units"
 
+/**
+ * Root API surface for Snaptrude plugins.
+ *
+ * Access all plugin capabilities through the namespaced properties:
+ *
+ * - {@linkcode PluginApi.core} — Math and geometry primitives
+ * - {@linkcode PluginApi.entity} — CRUD operations on Snaptrude entities (spaces, stories)
+ * - {@linkcode PluginApi.tools} — Selection and transform tools
+ * - {@linkcode PluginApi.units} — Unit conversion utilities
+ */
 export abstract class PluginApi {
+  /** Core math and geometry primitives. See {@linkcode PluginCoreApi}. */
   public abstract core: PluginCoreApi
+  /** Selection and transform tools. See {@linkcode PluginToolsApi}. */
   public abstract tools: PluginToolsApi
+  /** CRUD operations on Snaptrude entities. See {@linkcode PluginEntityApi}. */
   public abstract entity: PluginEntityApi
+  /** Unit conversion utilities. See {@linkcode PluginUnitsApi}. */
   public abstract units: PluginUnitsApi
 
   constructor() {}

package/src/api/tools/index.ts

@@ -1,8 +1,16 @@
 import { PluginSelectionApi } from "./selection"
 import { PluginTransformApi } from "./transform"
 
+/**
+ * Snaptrude editor tools for querying and manipulating scene components.
+ *
+ * - {@linkcode PluginToolsApi.selection} — Query the current user selection
+ * - {@linkcode PluginToolsApi.transform} — Move and rotate components
+ */
 export abstract class PluginToolsApi {
+  /** Query the current selection. See {@linkcode PluginSelectionApi}. */
   public abstract selection: PluginSelectionApi
+  /** Move and rotate components. See {@linkcode PluginTransformApi}. */
   public abstract transform: PluginTransformApi
 
   constructor() {}

package/src/api/tools/selection.ts

@@ -1,12 +1,49 @@
 import * as z from "zod"
 import { PluginApiReturn } from "../../types"
 
+/**
+ * Query the current user selection in the Snaptrude editor.
+ *
+ * Accessed via `snaptrude.tools.selection`.
+ */
 export abstract class PluginSelectionApi {
   constructor() {}
 
+  /**
+   * Get the IDs of all currently selected components.
+   *
+   * Returns the component IDs from the editor's active selection stack.
+   * If nothing is selected, returns an empty array.
+   *
+   * The returned IDs can be used with {@linkcode PluginTransformApi.move},
+   * {@linkcode PluginTransformApi.rotate}, or entity query methods like
+   * {@linkcode PluginSpaceApi.get}.
+   *
+   * @returns A {@linkcode PluginSelectionGetResult} with a `selected` array
+   *   of component ID strings
+   *
+   * # Example
+   * ```ts
+   * const { selected } = await snaptrude.tools.selection.get()
+   * if (selected.length > 0) {
+   *   // Move selected components 5 units along X
+   *   await snaptrude.tools.transform.move({
+   *     componentIds: selected,
+   *     displacement: snaptrude.core.math.vec3.new(5, 0, 0),
+   *   })
+   * }
+   * ```
+   */
   public abstract get(): PluginApiReturn<PluginSelectionGetResult>
 }
 
+/**
+ * Result of {@linkcode PluginSelectionApi.get}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `selected` | `string[]` | Component IDs of the current selection |
+ */
 export const PluginSelectionGetResult = z.object({
   selected: z.array(z.string()),
 })