@snaptrude/plugin-core 0.7.0 → 0.8.0

package/src/api/presentation/annotate.ts

@@ -0,0 +1,360 @@
+import * as z from "zod"
+import { PluginApiReturn } from "../../types"
+
+/**
+ * Presentation annotate — add annotations to Present-mode sheets.
+ *
+ * The scriptable counterparts to the Present toolbar's annotation tools (all
+ * require Present mode to be open; each returns the created canvas shape id):
+ *
+ * - {@linkcode PluginPresentationAnnotateApi.text} — text labels (titles, captions)
+ * - {@linkcode PluginPresentationAnnotateApi.arrow} — arrows pointing between two points
+ * - {@linkcode PluginPresentationAnnotateApi.note} — sticky notes
+ * - {@linkcode PluginPresentationAnnotateApi.shape} — geo shapes (rectangle, ellipse, cloud, …)
+ *
+ * The freehand Draw tool is not scriptable (a stroke is an interactive gesture,
+ * not a single call) and is intentionally not exposed here.
+ *
+ * Accessed via `snaptrude.presentation.annotate`.
+ */
+export abstract class PluginPresentationAnnotateApi {
+  constructor() {}
+
+  /**
+   * Add a text label to a sheet.
+   *
+   * Creates a text shape on the given sheet and returns the id of the created
+   * canvas shape. Requires Present mode to be open.
+   *
+   * @param sheetId - The sheet to annotate.
+   * @param text - The label text.
+   * @param options - Optional `position` (`{ x, y }`, relative to the sheet's
+   *   top-left, in canvas units — defaults to the sheet's top-left corner),
+   *   `size` (`"s" | "m" | "l" | "xl"`, default `"m"`), and `color` (a named
+   *   palette color, default `"black"`).
+   * @returns A {@linkcode PluginPresentationAnnotateTextResult} with the created
+   *   `shapeId`.
+   * @throws If Present mode is not open or the sheet id is invalid.
+   *
+   * @examplePrompt Add a title "Ground Floor" to Sheet 1
+   * @examplePrompt Label the cover sheet with the project name
+   * @examplePrompt Caption this view with "Proposed layout"
+   * @examplePrompt Put a red note on the sheet
+   *
+   * # Example
+   * ```ts
+   * const { shapeId } = await snaptrude.presentation.annotate.text(
+   *   "sheet_1",
+   *   "Ground Floor",
+   *   { position: { x: 40, y: 40 }, size: "xl", color: "blue" },
+   * )
+   * ```
+   */
+  public abstract text(
+    sheetId: string,
+    text: string,
+    options?: {
+      position?: { x: number; y: number }
+      size?: PluginAnnotateTextSize
+      color?: PluginAnnotateTextColor
+    },
+  ): PluginApiReturn<PluginPresentationAnnotateTextResult>
+
+  /**
+   * Draw an arrow on a sheet.
+   *
+   * Creates an arrow shape from `start` to `end` (both relative to the sheet's
+   * top-left, in canvas units — the same Arrow tool as the Present toolbar) and
+   * returns the id of the created canvas shape. Requires Present mode to be open.
+   *
+   * @param sheetId - The sheet to annotate.
+   * @param start - Arrow tail position (`{ x, y }`, relative to the sheet's top-left).
+   * @param end - Arrow head position (`{ x, y }`, relative to the sheet's top-left).
+   * @param options - Optional `color` (a named palette color, default `"black"`)
+   *   and `size` (stroke weight preset, `"s" | "m" | "l" | "xl"`, default `"m"`).
+   * @returns A {@linkcode PluginPresentationAnnotateResult} with the created
+   *   `shapeId`.
+   * @throws If Present mode is not open or the sheet id is invalid.
+   *
+   * @examplePrompt Draw an arrow pointing at the entrance on Sheet 1
+   * @examplePrompt Add a red arrow from the title to the plan view
+   * @examplePrompt Point an arrow at the top-left view on the cover sheet
+   *
+   * # Example
+   * ```ts
+   * const { shapeId } = await snaptrude.presentation.annotate.arrow(
+   *   "sheet_1",
+   *   { x: 100, y: 200 },
+   *   { x: 300, y: 250 },
+   *   { color: "red" },
+   * )
+   * ```
+   */
+  public abstract arrow(
+    sheetId: string,
+    start: { x: number; y: number },
+    end: { x: number; y: number },
+    options?: {
+      color?: PluginAnnotateTextColor
+      size?: PluginAnnotateTextSize
+    },
+  ): PluginApiReturn<PluginPresentationAnnotateResult>
+
+  /**
+   * Add a sticky note to a sheet.
+   *
+   * Creates a note shape (the same Note tool as the Present toolbar — a
+   * fixed-size sticky square that grows with its text) and returns the id of
+   * the created canvas shape. Requires Present mode to be open.
+   *
+   * @param sheetId - The sheet to annotate.
+   * @param text - The note text.
+   * @param options - Optional `position` (`{ x, y }`, relative to the sheet's
+   *   top-left, in canvas units — defaults to the sheet's top-left corner),
+   *   `color` (a named palette color, default `"black"` — rendered as the
+   *   note's sticky fill), and `size` (text size preset,
+   *   `"s" | "m" | "l" | "xl"`, default `"m"`).
+   * @returns A {@linkcode PluginPresentationAnnotateResult} with the created
+   *   `shapeId`.
+   * @throws If Present mode is not open or the sheet id is invalid.
+   *
+   * @examplePrompt Add a sticky note "Review this wall" to Sheet 1
+   * @examplePrompt Put a yellow note on the cover sheet
+   * @examplePrompt Leave a note next to the ground floor plan
+   *
+   * # Example
+   * ```ts
+   * const { shapeId } = await snaptrude.presentation.annotate.note(
+   *   "sheet_1",
+   *   "Review this wall",
+   *   { position: { x: 60, y: 120 }, color: "yellow" },
+   * )
+   * ```
+   */
+  public abstract note(
+    sheetId: string,
+    text: string,
+    options?: {
+      position?: { x: number; y: number }
+      color?: PluginAnnotateTextColor
+      size?: PluginAnnotateTextSize
+    },
+  ): PluginApiReturn<PluginPresentationAnnotateResult>
+
+  /**
+   * Draw a geo shape (rectangle, ellipse, cloud, …) on a sheet.
+   *
+   * Creates a geo shape of the given `kind` — the same shapes as the Present
+   * toolbar's shape flyout — sized to `bounds` (relative to the sheet's
+   * top-left, in canvas units) and returns the id of the created canvas shape.
+   * Requires Present mode to be open.
+   *
+   * @param sheetId - The sheet to annotate.
+   * @param kind - The shape kind ({@linkcode PluginAnnotateGeoKind}), e.g.
+   *   `"rectangle"`, `"ellipse"`, `"cloud"`.
+   * @param bounds - Placement box `{ x, y, w, h }` — `x`/`y` are the shape's
+   *   top-left relative to the sheet's top-left; `w`/`h` must be positive.
+   * @param options - Optional `color` (a named palette color, default
+   *   `"black"`) and `fill` ({@linkcode PluginAnnotateFill}, default `"none"` —
+   *   outline only).
+   * @returns A {@linkcode PluginPresentationAnnotateResult} with the created
+   *   `shapeId`.
+   * @throws If Present mode is not open or the sheet id is invalid.
+   *
+   * @examplePrompt Draw a revision cloud around the kitchen on Sheet 2
+   * @examplePrompt Add a red rectangle highlight to the sheet
+   * @examplePrompt Draw an ellipse around the entrance on the cover sheet
+   *
+   * # Example
+   * ```ts
+   * const { shapeId } = await snaptrude.presentation.annotate.shape(
+   *   "sheet_1",
+   *   "cloud",
+   *   { x: 80, y: 80, w: 240, h: 160 },
+   *   { color: "red" },
+   * )
+   * ```
+   */
+  public abstract shape(
+    sheetId: string,
+    kind: PluginAnnotateGeoKind,
+    bounds: { x: number; y: number; w: number; h: number },
+    options?: {
+      color?: PluginAnnotateTextColor
+      fill?: PluginAnnotateFill
+    },
+  ): PluginApiReturn<PluginPresentationAnnotateResult>
+}
+
+/** Text size preset (the same s/m/l/xl scale as the Present-mode text tool). */
+export const PluginAnnotateTextSize = z.enum(["s", "m", "l", "xl"])
+export type PluginAnnotateTextSize = z.infer<typeof PluginAnnotateTextSize>
+
+/** Named palette color (the same swatches as the Present-mode style panel). */
+export const PluginAnnotateTextColor = z.enum([
+  "black",
+  "grey",
+  "light-violet",
+  "violet",
+  "blue",
+  "light-blue",
+  "yellow",
+  "orange",
+  "green",
+  "light-green",
+  "light-red",
+  "red",
+  "white",
+])
+export type PluginAnnotateTextColor = z.infer<typeof PluginAnnotateTextColor>
+
+/**
+ * Arguments for {@linkcode PluginPresentationAnnotateApi.text}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `sheetId` | `string` | The sheet to annotate |
+ * | `text` | `string` | The label text |
+ * | `position` | `{ x: number; y: number } \| undefined` | Where to place it (relative to the sheet) |
+ * | `size` | {@linkcode PluginAnnotateTextSize}` \| undefined` | Text size preset |
+ * | `color` | {@linkcode PluginAnnotateTextColor}` \| undefined` | Text color |
+ */
+export const PluginPresentationAnnotateTextArgs = z.object({
+  sheetId: z.string(),
+  text: z.string(),
+  position: z.object({ x: z.number(), y: z.number() }).optional(),
+  size: PluginAnnotateTextSize.optional(),
+  color: PluginAnnotateTextColor.optional(),
+})
+export type PluginPresentationAnnotateTextArgs = z.infer<
+  typeof PluginPresentationAnnotateTextArgs
+>
+
+/**
+ * Result of {@linkcode PluginPresentationAnnotateApi.text}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `shapeId` | `string` | Id of the created text shape |
+ */
+export const PluginPresentationAnnotateTextResult = z.object({
+  shapeId: z.string(),
+})
+export type PluginPresentationAnnotateTextResult = z.infer<
+  typeof PluginPresentationAnnotateTextResult
+>
+
+/**
+ * Geo shape kind — the shapes offered by the Present-mode toolbar's shape
+ * flyout.
+ */
+export const PluginAnnotateGeoKind = z.enum([
+  "rectangle",
+  "ellipse",
+  "triangle",
+  "diamond",
+  "hexagon",
+  "oval",
+  "rhombus",
+  "star",
+  "cloud",
+  "heart",
+  "x-box",
+  "check-box",
+  "arrow-left",
+  "arrow-up",
+  "arrow-right",
+  "arrow-down",
+])
+export type PluginAnnotateGeoKind = z.infer<typeof PluginAnnotateGeoKind>
+
+/** Fill style for geo shapes (the same fills as the Present-mode style panel). */
+export const PluginAnnotateFill = z.enum(["none", "semi", "solid", "pattern"])
+export type PluginAnnotateFill = z.infer<typeof PluginAnnotateFill>
+
+/**
+ * Arguments for {@linkcode PluginPresentationAnnotateApi.arrow}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `sheetId` | `string` | The sheet to annotate |
+ * | `start` | `{ x: number; y: number }` | Arrow tail (relative to the sheet) |
+ * | `end` | `{ x: number; y: number }` | Arrow head (relative to the sheet) |
+ * | `color` | {@linkcode PluginAnnotateTextColor}` \| undefined` | Arrow color |
+ * | `size` | {@linkcode PluginAnnotateTextSize}` \| undefined` | Stroke weight preset |
+ */
+export const PluginPresentationAnnotateArrowArgs = z.object({
+  sheetId: z.string(),
+  start: z.object({ x: z.number(), y: z.number() }),
+  end: z.object({ x: z.number(), y: z.number() }),
+  color: PluginAnnotateTextColor.optional(),
+  size: PluginAnnotateTextSize.optional(),
+})
+export type PluginPresentationAnnotateArrowArgs = z.infer<
+  typeof PluginPresentationAnnotateArrowArgs
+>
+
+/**
+ * Arguments for {@linkcode PluginPresentationAnnotateApi.note}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `sheetId` | `string` | The sheet to annotate |
+ * | `text` | `string` | The note text |
+ * | `position` | `{ x: number; y: number } \| undefined` | Where to place it (relative to the sheet) |
+ * | `color` | {@linkcode PluginAnnotateTextColor}` \| undefined` | Sticky fill color |
+ * | `size` | {@linkcode PluginAnnotateTextSize}` \| undefined` | Text size preset |
+ */
+export const PluginPresentationAnnotateNoteArgs = z.object({
+  sheetId: z.string(),
+  text: z.string(),
+  position: z.object({ x: z.number(), y: z.number() }).optional(),
+  color: PluginAnnotateTextColor.optional(),
+  size: PluginAnnotateTextSize.optional(),
+})
+export type PluginPresentationAnnotateNoteArgs = z.infer<
+  typeof PluginPresentationAnnotateNoteArgs
+>
+
+/**
+ * Arguments for {@linkcode PluginPresentationAnnotateApi.shape}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `sheetId` | `string` | The sheet to annotate |
+ * | `kind` | {@linkcode PluginAnnotateGeoKind} | The shape kind |
+ * | `bounds` | `{ x: number; y: number; w: number; h: number }` | Placement box (relative to the sheet; `w`/`h` positive) |
+ * | `color` | {@linkcode PluginAnnotateTextColor}` \| undefined` | Outline color |
+ * | `fill` | {@linkcode PluginAnnotateFill}` \| undefined` | Fill style |
+ */
+export const PluginPresentationAnnotateShapeArgs = z.object({
+  sheetId: z.string(),
+  kind: PluginAnnotateGeoKind,
+  bounds: z.object({
+    x: z.number(),
+    y: z.number(),
+    w: z.number().positive(),
+    h: z.number().positive(),
+  }),
+  color: PluginAnnotateTextColor.optional(),
+  fill: PluginAnnotateFill.optional(),
+})
+export type PluginPresentationAnnotateShapeArgs = z.infer<
+  typeof PluginPresentationAnnotateShapeArgs
+>
+
+/**
+ * Result of {@linkcode PluginPresentationAnnotateApi.arrow},
+ * {@linkcode PluginPresentationAnnotateApi.note}, and
+ * {@linkcode PluginPresentationAnnotateApi.shape}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `shapeId` | `string` | Id of the created canvas shape |
+ */
+export const PluginPresentationAnnotateResult = z.object({
+  shapeId: z.string(),
+})
+export type PluginPresentationAnnotateResult = z.infer<
+  typeof PluginPresentationAnnotateResult
+>

package/src/api/presentation/diagrams.ts

@@ -2,23 +2,54 @@ import * as z from "zod"
 import { PluginApiReturn } from "../../types"
 
 /**
- * Presentation diagrams — place diagram images onto sheets.
+ * Presentation diagrams — generate program diagrams from the model, and place
+ * diagram images onto sheets.
  *
- * {@linkcode PluginPresentationDiagramsApi.place} drops diagram images (by
- * URL) onto a sheet and returns the created canvas shape ids (requires Present
- * mode to be open). Adjacency data itself is read and computed via
+ * {@linkcode PluginPresentationDiagramsApi.generateProgram} runs the Present-mode
+ * **Program** action: it reads the project's spaces and departments and creates
+ * new layout sheets holding the generated diagram graphics.
+ * {@linkcode PluginPresentationDiagramsApi.place} drops ready diagram images (by
+ * URL) onto an existing sheet and returns the created canvas shape ids. Both
+ * require Present mode to be open. Adjacency data itself is read and computed via
  * `program.adjacency` (see {@linkcode PluginProgramAdjacencyApi}).
  *
- * A future one-step spec-based `place` — which would render a diagram spec
- * and place it in a single call — awaits a public generator from the
- * documentation engine; until that generator exists, `place` takes ready
- * image `urls` (we do not ship a spec-based `place` that would only throw).
+ * There is intentionally no `generateAdjacency`: the host's adjacency generator
+ * runs its sheet-creation task fire-and-forget internally, so a single call
+ * cannot return the sheets it creates. Use the Present-mode Adjacency menu for
+ * those, then `place` a pre-rendered adjacency image if you need it via the API.
  *
  * Accessed via `snaptrude.presentation.diagrams`.
  */
 export abstract class PluginPresentationDiagramsApi {
   constructor() {}
 
+  /**
+   * Generate the program (space + department) diagrams for the current model,
+   * creating new layout sheets.
+   *
+   * Runs the same auto-generation as the Present-mode **Program** action: reads
+   * the project's spaces and departments, lays them out to scale, and creates one
+   * or more new sheets holding the generated diagram graphics. Unlike
+   * {@linkcode PluginPresentationDiagramsApi.place} (which pastes ready image URLs
+   * onto an existing sheet), this generates the graphics from the model and
+   * creates its own sheets. Requires Present mode to be open.
+   *
+   * @returns A {@linkcode PluginPresentationDiagramsGenerateResult} with the
+   *   `sheetIds` of the sheets created.
+   * @throws If Present mode is not open, or the model has no spaces/departments to
+   *   generate from.
+   *
+   * @examplePrompt Generate the program diagrams for this project
+   * @examplePrompt Auto-generate the space and department diagram sheets
+   * @examplePrompt Create the program layout sheets from the model
+   *
+   * # Example
+   * ```ts
+   * const { sheetIds } = await snaptrude.presentation.diagrams.generateProgram()
+   * ```
+   */
+  public abstract generateProgram(): PluginApiReturn<PluginPresentationDiagramsGenerateResult>
+
   /**
    * Place diagram images onto a sheet.
    *
@@ -82,3 +113,17 @@ export const PluginPresentationDiagramsPlaceResult = z.object({
 export type PluginPresentationDiagramsPlaceResult = z.infer<
   typeof PluginPresentationDiagramsPlaceResult
 >
+
+/**
+ * Result of {@linkcode PluginPresentationDiagramsApi.generateProgram}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `sheetIds` | `string[]` | Ids of the sheets created by the generator |
+ */
+export const PluginPresentationDiagramsGenerateResult = z.object({
+  sheetIds: z.array(z.string()),
+})
+export type PluginPresentationDiagramsGenerateResult = z.infer<
+  typeof PluginPresentationDiagramsGenerateResult
+>

package/src/api/presentation/export.ts

@@ -0,0 +1,104 @@
+import * as z from "zod"
+
+/**
+ * Presentation export — render the Present-mode layout sheets to a downloadable
+ * file (PDF / PNG / JPG) and hand the plugin the bytes as base64.
+ *
+ * This wraps the same pipeline the Present-mode **Export** dialog drives:
+ * each sheet is serialized to an SVG, then either composed into a PDF
+ * (svg2pdf/jspdf) or rasterized to a PNG/JPG. Nothing is written to disk
+ * host-side — the plugin receives the encoded bytes and decides what to do
+ * with them (save, upload, preview).
+ *
+ * Requires **Present mode to be open** (the documentation editor); the call
+ * throws `PRECONDITION_FAILED` when it is not.
+ *
+ * The result is always a uniform `{ files }` array (see
+ * {@linkcode PluginPresentationExportResult}):
+ * - `pdf` with `combine` (the default) → a single multi-page file.
+ * - `pdf` with `combine: false`, or any `png`/`jpg` → one file per sheet.
+ *
+ * Accessed via `snaptrude.presentation.export`.
+ *
+ * The schemas and result types live here; the callable method is declared on
+ * {@linkcode PluginPresentationApi.export}.
+ */
+
+/** Output file format: a vector `pdf`, or a rasterized `png` / `jpg`. */
+export const PluginPresentationExportFormat = z.enum(["pdf", "png", "jpg"])
+export type PluginPresentationExportFormat = z.infer<
+  typeof PluginPresentationExportFormat
+>
+
+/**
+ * Target pixel dimensions for a rasterized (`png`/`jpg`) export. Ignored for
+ * `pdf`, which stays vector and takes its size from the sheet.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `width` | `number` | Output width in pixels |
+ * | `height` | `number` | Output height in pixels |
+ */
+export const PluginPresentationExportResolution = z.object({
+  width: z.number().positive(),
+  height: z.number().positive(),
+})
+export type PluginPresentationExportResolution = z.infer<
+  typeof PluginPresentationExportResolution
+>
+
+/**
+ * Arguments for {@linkcode PluginPresentationApi.export}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `format` | `"pdf" \| "png" \| "jpg"` | Output format |
+ * | `sheetIds` | `string[] \| undefined` | Sheets to export (all sheets when omitted) |
+ * | `combine` | `boolean \| undefined` | PDF only: one multi-page file (default `true`) vs one file per sheet |
+ * | `resolution` | {@linkcode PluginPresentationExportResolution}` \| undefined` | Raster target size (`png`/`jpg` only) |
+ * | `fileName` | `string \| undefined` | Base file name (without extension) |
+ */
+export const PluginPresentationExportArgs = z.object({
+  format: PluginPresentationExportFormat,
+  sheetIds: z.array(z.string()).optional(),
+  combine: z.boolean().optional(),
+  resolution: PluginPresentationExportResolution.optional(),
+  fileName: z.string().optional(),
+})
+export type PluginPresentationExportArgs = z.infer<
+  typeof PluginPresentationExportArgs
+>
+
+/**
+ * A single exported file.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `fileName` | `string` | File name including extension |
+ * | `mimeType` | `string` | MIME type (`application/pdf`, `image/png`, `image/jpeg`) |
+ * | `dataBase64` | `string` | The file bytes, base64-encoded (no data-URL prefix) |
+ */
+export const PluginPresentationExportFile = z.object({
+  fileName: z.string(),
+  mimeType: z.string(),
+  dataBase64: z.string(),
+})
+export type PluginPresentationExportFile = z.infer<
+  typeof PluginPresentationExportFile
+>
+
+/**
+ * Result of {@linkcode PluginPresentationApi.export} — always a `files` array.
+ * A combined PDF yields one entry; per-sheet exports yield one entry each, in
+ * sheet order.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `files` | {@linkcode PluginPresentationExportFile}`[]` | The exported files |
+ */
+export const PluginPresentationExportResult = z.object({
+  files: z.array(PluginPresentationExportFile),
+})
+export type PluginPresentationExportResult = z.infer<
+  typeof PluginPresentationExportResult
+>

package/src/api/presentation/index.ts

@@ -1,8 +1,15 @@
+import { PluginApiReturn } from "../../types"
 import { PluginPresentationViewsApi } from "./views"
 import { PluginPresentationAIInspirationApi } from "./aiInspiration"
 import { PluginPresentationSheetsApi } from "./sheets"
 import { PluginPresentationDiagramsApi } from "./diagrams"
+import { PluginPresentationAnnotateApi } from "./annotate"
 import { PluginPresentationImportApi } from "./import"
+import {
+  PluginPresentationExportResult,
+  type PluginPresentationExportFormat,
+  type PluginPresentationExportResolution,
+} from "./export"
 
 /**
  * Presentation APIs — prepare and assemble presentations.
@@ -29,14 +36,50 @@ export abstract class PluginPresentationApi {
   public abstract sheets: PluginPresentationSheetsApi
   /** Program/adjacency/site diagrams — place images on sheets. See {@linkcode PluginPresentationDiagramsApi}. */
   public abstract diagrams: PluginPresentationDiagramsApi
+  /** Annotations on Present-mode sheets — text/arrows/notes/geo shapes. See {@linkcode PluginPresentationAnnotateApi}. */
+  public abstract annotate: PluginPresentationAnnotateApi
   /** Import reference images/PDFs onto the Present canvas. See {@linkcode PluginPresentationImportApi}. */
   public abstract import: PluginPresentationImportApi
   /**
    * Present-mode AI Inspiration image/video generation. See
-   * {@linkcode PluginPresentationAIInspirationApi}. _(authored ahead — optional
-   * until the host lands; the host implementation today is a stub.)_
+   * {@linkcode PluginPresentationAIInspirationApi}.
    */
-  public aiInspiration?: PluginPresentationAIInspirationApi
+  public abstract aiInspiration: PluginPresentationAIInspirationApi
+
+  /**
+   * Export the presentation's layout sheets to a downloadable file (PDF / PNG /
+   * JPG) and return the encoded bytes as base64. Wraps the Present-mode Export
+   * dialog pipeline headlessly. Requires Present mode to be open.
+   *
+   * @param format - Output format: `"pdf"`, `"png"`, or `"jpg"`.
+   * @param options - Optional `sheetIds` (all sheets when omitted), `combine`
+   *   (PDF only — one multi-page file vs one per sheet, default `true`),
+   *   `resolution` (raster target size for `png`/`jpg`), and `fileName`.
+   * @returns A {@linkcode PluginPresentationExportResult} — always a `files`
+   *   array (one entry for a combined PDF, one per sheet otherwise).
+   * @throws If Present mode is not open, a `sheetId` is unknown, or a sheet
+   *   fails to serialize/encode.
+   *
+   * @examplePrompt Export the presentation as a PDF
+   * @examplePrompt Download all sheets as a single PDF
+   * @examplePrompt Export sheet 1 as a PNG
+   * @examplePrompt Save the presentation sheets as JPG images
+   * @examplePrompt Export these sheets to PDF at high resolution
+   *
+   * # Example
+   * ```ts
+   * const { files } = await snaptrude.presentation.export("pdf")
+   * ```
+   */
+  public abstract export(
+    format: PluginPresentationExportFormat,
+    options?: {
+      sheetIds?: string[]
+      combine?: boolean
+      resolution?: PluginPresentationExportResolution
+      fileName?: string
+    },
+  ): PluginApiReturn<PluginPresentationExportResult>
 
   constructor() {}
 }
@@ -44,5 +87,7 @@ export abstract class PluginPresentationApi {
 export * from "./views"
 export * from "./sheets"
 export * from "./diagrams"
+export * from "./annotate"
 export * from "./import"
 export * from "./aiInspiration"
+export * from "./export"