@stablebaseline/sdk 0.4.3 → 0.4.5
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.cts +852 -54
- package/dist/index.d.ts +852 -54
- package/openapi.json +866 -8
- package/package.json +1 -1
- package/src/types.generated.ts +852 -54
package/dist/index.d.cts
CHANGED
|
@@ -683,6 +683,146 @@ interface paths {
|
|
|
683
683
|
patch?: never;
|
|
684
684
|
trace?: never;
|
|
685
685
|
};
|
|
686
|
+
"/tools/designDeck": {
|
|
687
|
+
parameters: {
|
|
688
|
+
query?: never;
|
|
689
|
+
header?: never;
|
|
690
|
+
path?: never;
|
|
691
|
+
cookie?: never;
|
|
692
|
+
};
|
|
693
|
+
get?: never;
|
|
694
|
+
put?: never;
|
|
695
|
+
/**
|
|
696
|
+
* designDeck
|
|
697
|
+
* @description Create or refine a slide deck on a whiteboard by conversing with the AI design agent. Send a brief for a NEW deck, a change to an EXISTING one, or an answer to the agent's question. The agent builds a polished, on-brand deck and places it on the board; if the brief is ambiguous it asks ONE clarifying question (answer with the same sessionId). Returns immediately; poll getDeckReply for the result. Use for building or editing slide decks / presentations. The deck lives in a whiteboard, so it needs an existing whiteboard documentId: if you do not have one, create it first with createWhiteboard and pass its documentId here. FIRST vs FOLLOW-UP: the first call (from nothing) builds; a follow-up call (an answer, a change, or a new instruction) passes the sessionId (or the deckId) plus the new message. kind:'deck' (default) is the premium on-brand HTML deck; kind:'express' builds the native, deterministic branded-executive deck directly on the whiteboard (faster, lower fidelity, one-shot, not conversational). COST + APPROVAL: a build costs 50 credits and an edit 10; a clarifying question is FREE. Call FIRST without confirm to get the exact cost plus the workspace balance, show it to the user, and only call again with confirm:true once they agree. The fee is auto-refunded if a turn produces no change or fails. Returns sessionId (the conversation), deckId (the deck), status, turnType, started, awaitingUser, needsConfirmation, insufficientCredits, and assistantMessage. Export the finished deck with exportFromWhiteboard.
|
|
698
|
+
*/
|
|
699
|
+
post: operations["designDeck"];
|
|
700
|
+
delete?: never;
|
|
701
|
+
options?: never;
|
|
702
|
+
head?: never;
|
|
703
|
+
patch?: never;
|
|
704
|
+
trace?: never;
|
|
705
|
+
};
|
|
706
|
+
"/tools/getDeckReply": {
|
|
707
|
+
parameters: {
|
|
708
|
+
query?: never;
|
|
709
|
+
header?: never;
|
|
710
|
+
path?: never;
|
|
711
|
+
cookie?: never;
|
|
712
|
+
};
|
|
713
|
+
get?: never;
|
|
714
|
+
put?: never;
|
|
715
|
+
/**
|
|
716
|
+
* getDeckReply
|
|
717
|
+
* @description Get the design agent's reply after calling designDeck: the status (thinking/building/ready) and EITHER the finished deck (slide count + preview) OR a clarifying question to answer (call designDeck with the sessionId + your answer). Poll until ready or a question appears. Give it the whiteboard documentId and the deckId (both returned by designDeck). It returns the build status ('generating' while working, 'ready' when the deck is finished, 'failed' if it failed) plus, once ready, the slide count and a thumbnail image URL. IMPORTANT for the conversation: if the agent asked a CLARIFYING QUESTION instead of doing the work, this returns awaitingUser:true with pendingQuestion (and assistantMessage) — relay that question to the user, then call designDeck again with the same sessionId and the user's answer as message to continue. It also returns the full conversation (history + status + pending question). A turn usually takes about 1 to 3 minutes, so poll every 15 to 30 seconds until it is 'ready' or awaitingUser is true. When ready, the deck has already been placed on the whiteboard; you can also export it with exportFromWhiteboard. If a turn failed or produced no change, the user was not charged.
|
|
718
|
+
*/
|
|
719
|
+
post: operations["getDeckReply"];
|
|
720
|
+
delete?: never;
|
|
721
|
+
options?: never;
|
|
722
|
+
head?: never;
|
|
723
|
+
patch?: never;
|
|
724
|
+
trace?: never;
|
|
725
|
+
};
|
|
726
|
+
"/tools/designInWhiteboard": {
|
|
727
|
+
parameters: {
|
|
728
|
+
query?: never;
|
|
729
|
+
header?: never;
|
|
730
|
+
path?: never;
|
|
731
|
+
cookie?: never;
|
|
732
|
+
};
|
|
733
|
+
get?: never;
|
|
734
|
+
put?: never;
|
|
735
|
+
/**
|
|
736
|
+
* designInWhiteboard
|
|
737
|
+
* @description DEPRECATED — use designDeck instead. This tool no longer designs anything; it returns a short message pointing you at designDeck (to build or edit a slide deck on a whiteboard) or at createWhiteboard + addWhiteboardElements (for manual whiteboard content). It has NO side effects and runs no design. It is kept only so existing callers get a clear message; it will be upgraded in a future update.
|
|
738
|
+
*/
|
|
739
|
+
post: operations["designInWhiteboard"];
|
|
740
|
+
delete?: never;
|
|
741
|
+
options?: never;
|
|
742
|
+
head?: never;
|
|
743
|
+
patch?: never;
|
|
744
|
+
trace?: never;
|
|
745
|
+
};
|
|
746
|
+
"/tools/editInWhiteboard": {
|
|
747
|
+
parameters: {
|
|
748
|
+
query?: never;
|
|
749
|
+
header?: never;
|
|
750
|
+
path?: never;
|
|
751
|
+
cookie?: never;
|
|
752
|
+
};
|
|
753
|
+
get?: never;
|
|
754
|
+
put?: never;
|
|
755
|
+
/**
|
|
756
|
+
* editInWhiteboard
|
|
757
|
+
* @description DEPRECATED — use designDeck instead. An edit is just another turn in the design conversation, and designDeck handles build AND edit. This tool no longer edits anything; it returns a short message pointing you at designDeck. It has NO side effects and runs no design. It is kept only so existing callers get a clear message; it will be upgraded in a future update.
|
|
758
|
+
*/
|
|
759
|
+
post: operations["editInWhiteboard"];
|
|
760
|
+
delete?: never;
|
|
761
|
+
options?: never;
|
|
762
|
+
head?: never;
|
|
763
|
+
patch?: never;
|
|
764
|
+
trace?: never;
|
|
765
|
+
};
|
|
766
|
+
"/tools/exportFromWhiteboard": {
|
|
767
|
+
parameters: {
|
|
768
|
+
query?: never;
|
|
769
|
+
header?: never;
|
|
770
|
+
path?: never;
|
|
771
|
+
cookie?: never;
|
|
772
|
+
};
|
|
773
|
+
get?: never;
|
|
774
|
+
put?: never;
|
|
775
|
+
/**
|
|
776
|
+
* exportFromWhiteboard
|
|
777
|
+
* @description Export a design that lives in a whiteboard to an editable PowerPoint (PPTX), PDF, PNG images, or raw HTML. Give it the whiteboard documentId and the designId (the deck). kind:'deck' (default) renders the finished deck via the export worker: 'pptx' = native, fully-editable PowerPoint (real shapes and text, not screenshots); 'pdf' = vector, one page per slide; 'png' = one image per slide (returned as a base64 array); 'html' = the self-contained deck HTML. Returns the file as base64 in data (pptx/pdf/html) or per-slide base64 in slides (png). The design must be finished; one that is still generating, failed, or archived returns a clear message.
|
|
778
|
+
*/
|
|
779
|
+
post: operations["exportFromWhiteboard"];
|
|
780
|
+
delete?: never;
|
|
781
|
+
options?: never;
|
|
782
|
+
head?: never;
|
|
783
|
+
patch?: never;
|
|
784
|
+
trace?: never;
|
|
785
|
+
};
|
|
786
|
+
"/tools/getDesignStatusInWhiteboard": {
|
|
787
|
+
parameters: {
|
|
788
|
+
query?: never;
|
|
789
|
+
header?: never;
|
|
790
|
+
path?: never;
|
|
791
|
+
cookie?: never;
|
|
792
|
+
};
|
|
793
|
+
get?: never;
|
|
794
|
+
put?: never;
|
|
795
|
+
/**
|
|
796
|
+
* getDesignStatusInWhiteboard
|
|
797
|
+
* @description DEPRECATED — use getDeckReply instead. This tool no longer reads any status; it returns a short message pointing you at getDeckReply (poll it after calling designDeck to get the agent's reply — the deck, or a clarifying question). It has NO side effects. It is kept only so existing callers get a clear message; it will be upgraded in a future update.
|
|
798
|
+
*/
|
|
799
|
+
post: operations["getDesignStatusInWhiteboard"];
|
|
800
|
+
delete?: never;
|
|
801
|
+
options?: never;
|
|
802
|
+
head?: never;
|
|
803
|
+
patch?: never;
|
|
804
|
+
trace?: never;
|
|
805
|
+
};
|
|
806
|
+
"/tools/generateInWhiteboard": {
|
|
807
|
+
parameters: {
|
|
808
|
+
query?: never;
|
|
809
|
+
header?: never;
|
|
810
|
+
path?: never;
|
|
811
|
+
cookie?: never;
|
|
812
|
+
};
|
|
813
|
+
get?: never;
|
|
814
|
+
put?: never;
|
|
815
|
+
/**
|
|
816
|
+
* generateInWhiteboard
|
|
817
|
+
* @description Generate an on-brand ASSET inside a whiteboard and place it on the board. kind:'illustration' (default) makes a standalone, on-brand illustration (raw pixels, the one thing native shapes and diagrams cannot make) from a plain-language prompt, colour-conditioned to the organisation's brand (or a specific brandKitId), in a clean flat-vector editorial style with NO text, letters, or numbers baked in. It is stored and dropped onto the whiteboard as an image element. Costs a small flat credit charge (refunded automatically if generation fails on our side); an identical prompt reuses a cached image at no charge. Returns the durable image URL and confirms it was placed.
|
|
818
|
+
*/
|
|
819
|
+
post: operations["generateInWhiteboard"];
|
|
820
|
+
delete?: never;
|
|
821
|
+
options?: never;
|
|
822
|
+
head?: never;
|
|
823
|
+
patch?: never;
|
|
824
|
+
trace?: never;
|
|
825
|
+
};
|
|
686
826
|
"/tools/createWhiteboard": {
|
|
687
827
|
parameters: {
|
|
688
828
|
query?: never;
|
|
@@ -994,7 +1134,7 @@ interface paths {
|
|
|
994
1134
|
put?: never;
|
|
995
1135
|
/**
|
|
996
1136
|
* rebuildPlatformCatalogEmbeddings
|
|
997
|
-
* @description Internal maintenance (requires write). Syncs gte-small (384-dim) vector embeddings for
|
|
1137
|
+
* @description Internal maintenance (requires write). Syncs gte-small (384-dim) vector embeddings for every platform catalog (MCP tools, whiteboard stencils, architecture icons, infographic templates, whiteboard design components, and open-design skills) into platform_catalog_embeddings, so the semantic search behind searchTools, listWhiteboardStencils, listArchitectureIcons, and the design-skill / component browsers stays current. Incremental: scans every catalog, diffs by content hash, and re-embeds ONLY changed rows (cheap no-op when nothing changed). This normally runs automatically every hour (the platform-catalog-sync cron), so manual calls are rarely needed; use it to force an immediate sync after changing any catalog. Embeds up to ~120 changed rows per call; if more changed, call again until allDone is true. Not part of normal authoring flows.
|
|
998
1138
|
*/
|
|
999
1139
|
post: operations["rebuildPlatformCatalogEmbeddings"];
|
|
1000
1140
|
delete?: never;
|
|
@@ -3677,7 +3817,7 @@ interface paths {
|
|
|
3677
3817
|
put?: never;
|
|
3678
3818
|
/**
|
|
3679
3819
|
* createBrandKit
|
|
3680
|
-
* @description Create a per-org BRAND KIT
|
|
3820
|
+
* @description Create a per-org BRAND KIT so Stable Baseline outputs come out fully on-brand. Upload your branding and it is auto-applied: pass a `logoUrl` (as little as your logo, and the vision model AUTO-EXTRACTS your palette and fonts), or an `officeUrl` (an existing .pptx/.docx, from which it extracts theme colours, fonts, logo, watermark and the embedded font files), or explicit `tokens`. The kit themes branded-executive slides AND document exports (PDF, Word, PowerPoint). Auth: can_admin_org. Tiered: free 0, pro 1, enterprise unlimited. Optionally set it as the default at a scope in one call.
|
|
3681
3821
|
*/
|
|
3682
3822
|
post: operations["createBrandKit"];
|
|
3683
3823
|
delete?: never;
|
|
@@ -6665,7 +6805,7 @@ interface operations {
|
|
|
6665
6805
|
* @enum {string}
|
|
6666
6806
|
*/
|
|
6667
6807
|
designProfile?: "standard" | "branded-executive" | "illustrated" | "image" | "agentic" | "agentic-deck";
|
|
6668
|
-
/** @description Optional brand kit id (from listBrandKits) to theme a branded-executive deck. If omitted, the org's built-in default is used. */
|
|
6808
|
+
/** @description Optional brand kit id (from listBrandKits) to theme a branded-executive deck. If omitted, the org's built-in default is used. Create one from just a logo (or a .pptx/.docx) via createBrandKit. */
|
|
6669
6809
|
brandKitId?: string;
|
|
6670
6810
|
};
|
|
6671
6811
|
};
|
|
@@ -6934,7 +7074,7 @@ interface operations {
|
|
|
6934
7074
|
};
|
|
6935
7075
|
};
|
|
6936
7076
|
};
|
|
6937
|
-
|
|
7077
|
+
designDeck: {
|
|
6938
7078
|
parameters: {
|
|
6939
7079
|
query?: never;
|
|
6940
7080
|
header?: never;
|
|
@@ -6944,11 +7084,38 @@ interface operations {
|
|
|
6944
7084
|
requestBody?: {
|
|
6945
7085
|
content: {
|
|
6946
7086
|
"application/json": {
|
|
6947
|
-
|
|
6948
|
-
|
|
6949
|
-
|
|
6950
|
-
|
|
6951
|
-
|
|
7087
|
+
/** @description The whiteboard to design into. REQUIRED: the deck lives in this whiteboard. Create one first with createWhiteboard if you do not already have its id. */
|
|
7088
|
+
documentId: string;
|
|
7089
|
+
/** @description This turn's message in plain language: the design brief on the first turn, an edit instruction later, or the user's ANSWER to a clarifying question the agent asked. On a follow-up turn, pass this together with the sessionId (or deckId) from the earlier call. */
|
|
7090
|
+
message: string;
|
|
7091
|
+
/** @description The design conversation to continue, as returned by an earlier designDeck call. Pass it together with message to answer a question, make an edit, or send a follow-up. Omit on the very first call to start a new conversation. */
|
|
7092
|
+
sessionId?: string;
|
|
7093
|
+
/** @description Optional. An existing deck to continue designing (usually you pass sessionId instead; when both are given the session's deck wins). */
|
|
7094
|
+
deckId?: string;
|
|
7095
|
+
/**
|
|
7096
|
+
* @description Which engine. 'deck' (default) = the premium on-brand HTML deck (conversational, build + edit); 'illustration' and 'design' are conversational variants. 'express' = the native, deterministic branded-executive deck (faster, lower fidelity, one-shot, not conversational).
|
|
7097
|
+
* @enum {string}
|
|
7098
|
+
*/
|
|
7099
|
+
kind?: "deck" | "illustration" | "design" | "express";
|
|
7100
|
+
/** @description Optional title. If omitted, a clear one is derived from the brief. */
|
|
7101
|
+
title?: string;
|
|
7102
|
+
/** @description Optional brand kit id (from listBrandKits) to theme the deck. If omitted, the organisation's effective brand is used. */
|
|
7103
|
+
brandKitId?: string;
|
|
7104
|
+
/** @description Optional target number of slides for a build turn (the composer adjusts to fit the story). Typical 6 to 12. */
|
|
7105
|
+
slideCount?: number;
|
|
7106
|
+
/** @description Optional reference images for THIS turn (up to 8; images only). The agent lifts palette, layout, and tone from them (it does not pixel-copy). Non-image attachments are ignored. */
|
|
7107
|
+
attachments?: {
|
|
7108
|
+
/** @description A public https URL to the image. */
|
|
7109
|
+
url?: string;
|
|
7110
|
+
/** @description The image as base64 (no data: prefix). Provide mediaType alongside it. */
|
|
7111
|
+
data?: string;
|
|
7112
|
+
/** @description The image MIME type, e.g. 'image/png' or 'image/jpeg'. */
|
|
7113
|
+
mediaType?: string;
|
|
7114
|
+
/** @description Optional human-readable name for the image. */
|
|
7115
|
+
name?: string;
|
|
7116
|
+
}[];
|
|
7117
|
+
/** @description Set true ONLY after the user has approved the cost (50 for a build, 10 for an edit). Leave unset/false on the first call of a turn to receive the cost quote plus balance. A clarifying question turn is never charged. */
|
|
7118
|
+
confirm?: boolean;
|
|
6952
7119
|
};
|
|
6953
7120
|
};
|
|
6954
7121
|
};
|
|
@@ -7020,7 +7187,7 @@ interface operations {
|
|
|
7020
7187
|
};
|
|
7021
7188
|
};
|
|
7022
7189
|
};
|
|
7023
|
-
|
|
7190
|
+
getDeckReply: {
|
|
7024
7191
|
parameters: {
|
|
7025
7192
|
query?: never;
|
|
7026
7193
|
header?: never;
|
|
@@ -7030,7 +7197,10 @@ interface operations {
|
|
|
7030
7197
|
requestBody?: {
|
|
7031
7198
|
content: {
|
|
7032
7199
|
"application/json": {
|
|
7033
|
-
|
|
7200
|
+
/** @description The whiteboard that hosts the deck. */
|
|
7201
|
+
documentId: string;
|
|
7202
|
+
/** @description The deck to poll, as returned by designDeck. */
|
|
7203
|
+
deckId: string;
|
|
7034
7204
|
};
|
|
7035
7205
|
};
|
|
7036
7206
|
};
|
|
@@ -7102,7 +7272,7 @@ interface operations {
|
|
|
7102
7272
|
};
|
|
7103
7273
|
};
|
|
7104
7274
|
};
|
|
7105
|
-
|
|
7275
|
+
designInWhiteboard: {
|
|
7106
7276
|
parameters: {
|
|
7107
7277
|
query?: never;
|
|
7108
7278
|
header?: never;
|
|
@@ -7112,9 +7282,10 @@ interface operations {
|
|
|
7112
7282
|
requestBody?: {
|
|
7113
7283
|
content: {
|
|
7114
7284
|
"application/json": {
|
|
7115
|
-
|
|
7116
|
-
|
|
7117
|
-
|
|
7285
|
+
/** @description Ignored. Deprecated tool — use designDeck. */
|
|
7286
|
+
documentId?: string;
|
|
7287
|
+
/** @description Ignored. Deprecated tool — use designDeck. */
|
|
7288
|
+
message?: string;
|
|
7118
7289
|
};
|
|
7119
7290
|
};
|
|
7120
7291
|
};
|
|
@@ -7186,7 +7357,94 @@ interface operations {
|
|
|
7186
7357
|
};
|
|
7187
7358
|
};
|
|
7188
7359
|
};
|
|
7189
|
-
|
|
7360
|
+
editInWhiteboard: {
|
|
7361
|
+
parameters: {
|
|
7362
|
+
query?: never;
|
|
7363
|
+
header?: never;
|
|
7364
|
+
path?: never;
|
|
7365
|
+
cookie?: never;
|
|
7366
|
+
};
|
|
7367
|
+
requestBody?: {
|
|
7368
|
+
content: {
|
|
7369
|
+
"application/json": {
|
|
7370
|
+
/** @description Ignored. Deprecated tool — use designDeck. */
|
|
7371
|
+
documentId?: string;
|
|
7372
|
+
/** @description Ignored. Deprecated tool — use designDeck. */
|
|
7373
|
+
designId?: string;
|
|
7374
|
+
/** @description Ignored. Deprecated tool — use designDeck. */
|
|
7375
|
+
instruction?: string;
|
|
7376
|
+
};
|
|
7377
|
+
};
|
|
7378
|
+
};
|
|
7379
|
+
responses: {
|
|
7380
|
+
/** @description Tool result (shape varies per tool — refer to the tool's docs for the exact return value). */
|
|
7381
|
+
200: {
|
|
7382
|
+
headers: {
|
|
7383
|
+
[name: string]: unknown;
|
|
7384
|
+
};
|
|
7385
|
+
content: {
|
|
7386
|
+
"application/json": {
|
|
7387
|
+
[key: string]: unknown;
|
|
7388
|
+
};
|
|
7389
|
+
};
|
|
7390
|
+
};
|
|
7391
|
+
/** @description Validation error. */
|
|
7392
|
+
400: {
|
|
7393
|
+
headers: {
|
|
7394
|
+
[name: string]: unknown;
|
|
7395
|
+
};
|
|
7396
|
+
content: {
|
|
7397
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7398
|
+
};
|
|
7399
|
+
};
|
|
7400
|
+
/** @description Missing or invalid credentials. */
|
|
7401
|
+
401: {
|
|
7402
|
+
headers: {
|
|
7403
|
+
[name: string]: unknown;
|
|
7404
|
+
};
|
|
7405
|
+
content: {
|
|
7406
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7407
|
+
};
|
|
7408
|
+
};
|
|
7409
|
+
/** @description Authenticated but lacking the required permission or feature flag. */
|
|
7410
|
+
403: {
|
|
7411
|
+
headers: {
|
|
7412
|
+
[name: string]: unknown;
|
|
7413
|
+
};
|
|
7414
|
+
content: {
|
|
7415
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7416
|
+
};
|
|
7417
|
+
};
|
|
7418
|
+
/** @description Resource not found. */
|
|
7419
|
+
404: {
|
|
7420
|
+
headers: {
|
|
7421
|
+
[name: string]: unknown;
|
|
7422
|
+
};
|
|
7423
|
+
content: {
|
|
7424
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7425
|
+
};
|
|
7426
|
+
};
|
|
7427
|
+
/** @description Body did not match the tool's input schema. */
|
|
7428
|
+
422: {
|
|
7429
|
+
headers: {
|
|
7430
|
+
[name: string]: unknown;
|
|
7431
|
+
};
|
|
7432
|
+
content: {
|
|
7433
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7434
|
+
};
|
|
7435
|
+
};
|
|
7436
|
+
/** @description Server error. */
|
|
7437
|
+
500: {
|
|
7438
|
+
headers: {
|
|
7439
|
+
[name: string]: unknown;
|
|
7440
|
+
};
|
|
7441
|
+
content: {
|
|
7442
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7443
|
+
};
|
|
7444
|
+
};
|
|
7445
|
+
};
|
|
7446
|
+
};
|
|
7447
|
+
exportFromWhiteboard: {
|
|
7190
7448
|
parameters: {
|
|
7191
7449
|
query?: never;
|
|
7192
7450
|
header?: never;
|
|
@@ -7196,24 +7454,22 @@ interface operations {
|
|
|
7196
7454
|
requestBody?: {
|
|
7197
7455
|
content: {
|
|
7198
7456
|
"application/json": {
|
|
7457
|
+
/** @description The whiteboard that hosts the design. */
|
|
7199
7458
|
documentId: string;
|
|
7200
|
-
/** @description
|
|
7201
|
-
|
|
7459
|
+
/** @description The design to export (the deck id), as returned by designInWhiteboard. */
|
|
7460
|
+
designId: string;
|
|
7202
7461
|
/**
|
|
7203
|
-
* @description
|
|
7462
|
+
* @description Which engine. 'deck' (default).
|
|
7204
7463
|
* @enum {string}
|
|
7205
7464
|
*/
|
|
7206
|
-
|
|
7207
|
-
/**
|
|
7208
|
-
|
|
7209
|
-
|
|
7210
|
-
|
|
7211
|
-
|
|
7212
|
-
|
|
7213
|
-
|
|
7214
|
-
versionTimestamp?: number;
|
|
7215
|
-
/** @description Safety acknowledgement for mode 'replace' ONLY. A replace that would DELETE ANY existing element not present in your `elements` is rejected unless this is true. Leave it unset and use mode:'patch' to edit part of a board (it merges by id and keeps the rest); set true only when you truly intend to overwrite the WHOLE scene. */
|
|
7216
|
-
confirmReplace?: boolean;
|
|
7465
|
+
kind?: "deck";
|
|
7466
|
+
/**
|
|
7467
|
+
* @description Output format. 'pptx' (default) = editable PowerPoint; 'pdf' = vector PDF; 'png' = one base64 image per slide; 'html' = the design's self-contained HTML.
|
|
7468
|
+
* @enum {string}
|
|
7469
|
+
*/
|
|
7470
|
+
format?: "pptx" | "pdf" | "png" | "html";
|
|
7471
|
+
/** @description Optional brand kit id (reserved for future per-export theming; the design is already branded, so this is usually unnecessary). */
|
|
7472
|
+
brandKitId?: string;
|
|
7217
7473
|
};
|
|
7218
7474
|
};
|
|
7219
7475
|
};
|
|
@@ -7285,7 +7541,7 @@ interface operations {
|
|
|
7285
7541
|
};
|
|
7286
7542
|
};
|
|
7287
7543
|
};
|
|
7288
|
-
|
|
7544
|
+
getDesignStatusInWhiteboard: {
|
|
7289
7545
|
parameters: {
|
|
7290
7546
|
query?: never;
|
|
7291
7547
|
header?: never;
|
|
@@ -7295,27 +7551,565 @@ interface operations {
|
|
|
7295
7551
|
requestBody?: {
|
|
7296
7552
|
content: {
|
|
7297
7553
|
"application/json": {
|
|
7298
|
-
|
|
7299
|
-
|
|
7300
|
-
|
|
7301
|
-
|
|
7302
|
-
|
|
7303
|
-
|
|
7304
|
-
|
|
7305
|
-
|
|
7306
|
-
|
|
7307
|
-
|
|
7308
|
-
|
|
7309
|
-
|
|
7310
|
-
|
|
7311
|
-
|
|
7312
|
-
|
|
7313
|
-
|
|
7314
|
-
|
|
7315
|
-
|
|
7316
|
-
|
|
7317
|
-
|
|
7318
|
-
|
|
7554
|
+
/** @description Ignored. Deprecated tool — use getDeckReply. */
|
|
7555
|
+
documentId?: string;
|
|
7556
|
+
/** @description Ignored. Deprecated tool — use getDeckReply. */
|
|
7557
|
+
designId?: string;
|
|
7558
|
+
};
|
|
7559
|
+
};
|
|
7560
|
+
};
|
|
7561
|
+
responses: {
|
|
7562
|
+
/** @description Tool result (shape varies per tool — refer to the tool's docs for the exact return value). */
|
|
7563
|
+
200: {
|
|
7564
|
+
headers: {
|
|
7565
|
+
[name: string]: unknown;
|
|
7566
|
+
};
|
|
7567
|
+
content: {
|
|
7568
|
+
"application/json": {
|
|
7569
|
+
[key: string]: unknown;
|
|
7570
|
+
};
|
|
7571
|
+
};
|
|
7572
|
+
};
|
|
7573
|
+
/** @description Validation error. */
|
|
7574
|
+
400: {
|
|
7575
|
+
headers: {
|
|
7576
|
+
[name: string]: unknown;
|
|
7577
|
+
};
|
|
7578
|
+
content: {
|
|
7579
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7580
|
+
};
|
|
7581
|
+
};
|
|
7582
|
+
/** @description Missing or invalid credentials. */
|
|
7583
|
+
401: {
|
|
7584
|
+
headers: {
|
|
7585
|
+
[name: string]: unknown;
|
|
7586
|
+
};
|
|
7587
|
+
content: {
|
|
7588
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7589
|
+
};
|
|
7590
|
+
};
|
|
7591
|
+
/** @description Authenticated but lacking the required permission or feature flag. */
|
|
7592
|
+
403: {
|
|
7593
|
+
headers: {
|
|
7594
|
+
[name: string]: unknown;
|
|
7595
|
+
};
|
|
7596
|
+
content: {
|
|
7597
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7598
|
+
};
|
|
7599
|
+
};
|
|
7600
|
+
/** @description Resource not found. */
|
|
7601
|
+
404: {
|
|
7602
|
+
headers: {
|
|
7603
|
+
[name: string]: unknown;
|
|
7604
|
+
};
|
|
7605
|
+
content: {
|
|
7606
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7607
|
+
};
|
|
7608
|
+
};
|
|
7609
|
+
/** @description Body did not match the tool's input schema. */
|
|
7610
|
+
422: {
|
|
7611
|
+
headers: {
|
|
7612
|
+
[name: string]: unknown;
|
|
7613
|
+
};
|
|
7614
|
+
content: {
|
|
7615
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7616
|
+
};
|
|
7617
|
+
};
|
|
7618
|
+
/** @description Server error. */
|
|
7619
|
+
500: {
|
|
7620
|
+
headers: {
|
|
7621
|
+
[name: string]: unknown;
|
|
7622
|
+
};
|
|
7623
|
+
content: {
|
|
7624
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7625
|
+
};
|
|
7626
|
+
};
|
|
7627
|
+
};
|
|
7628
|
+
};
|
|
7629
|
+
generateInWhiteboard: {
|
|
7630
|
+
parameters: {
|
|
7631
|
+
query?: never;
|
|
7632
|
+
header?: never;
|
|
7633
|
+
path?: never;
|
|
7634
|
+
cookie?: never;
|
|
7635
|
+
};
|
|
7636
|
+
requestBody?: {
|
|
7637
|
+
content: {
|
|
7638
|
+
"application/json": {
|
|
7639
|
+
/** @description The whiteboard to generate the asset into (the asset is placed on this board). */
|
|
7640
|
+
documentId: string;
|
|
7641
|
+
/** @description Plain-language description of the asset to generate (e.g. 'a friendly robot assistant helping a small team'). */
|
|
7642
|
+
prompt: string;
|
|
7643
|
+
/**
|
|
7644
|
+
* @description What to make. 'illustration' (default).
|
|
7645
|
+
* @enum {string}
|
|
7646
|
+
*/
|
|
7647
|
+
kind?: "illustration";
|
|
7648
|
+
/** @description Optional output width in px (rounded to a multiple of 64, 512 to 2048). Default 1024. */
|
|
7649
|
+
width?: number;
|
|
7650
|
+
/** @description Optional output height in px (rounded to a multiple of 64, 512 to 2048). Default 1024. */
|
|
7651
|
+
height?: number;
|
|
7652
|
+
/** @description Optional extra style hint appended to the prompt (e.g. 'isometric', 'soft gradients, pastel'). */
|
|
7653
|
+
style?: string;
|
|
7654
|
+
/** @description Optional brand kit id to colour-condition the asset. Defaults to the organisation's effective brand. */
|
|
7655
|
+
brandKitId?: string;
|
|
7656
|
+
/** @description Optional x position on the board. Omit to auto-place. */
|
|
7657
|
+
x?: number;
|
|
7658
|
+
/** @description Optional y position on the board. Omit to auto-place. */
|
|
7659
|
+
y?: number;
|
|
7660
|
+
};
|
|
7661
|
+
};
|
|
7662
|
+
};
|
|
7663
|
+
responses: {
|
|
7664
|
+
/** @description Tool result (shape varies per tool — refer to the tool's docs for the exact return value). */
|
|
7665
|
+
200: {
|
|
7666
|
+
headers: {
|
|
7667
|
+
[name: string]: unknown;
|
|
7668
|
+
};
|
|
7669
|
+
content: {
|
|
7670
|
+
"application/json": {
|
|
7671
|
+
[key: string]: unknown;
|
|
7672
|
+
};
|
|
7673
|
+
};
|
|
7674
|
+
};
|
|
7675
|
+
/** @description Validation error. */
|
|
7676
|
+
400: {
|
|
7677
|
+
headers: {
|
|
7678
|
+
[name: string]: unknown;
|
|
7679
|
+
};
|
|
7680
|
+
content: {
|
|
7681
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7682
|
+
};
|
|
7683
|
+
};
|
|
7684
|
+
/** @description Missing or invalid credentials. */
|
|
7685
|
+
401: {
|
|
7686
|
+
headers: {
|
|
7687
|
+
[name: string]: unknown;
|
|
7688
|
+
};
|
|
7689
|
+
content: {
|
|
7690
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7691
|
+
};
|
|
7692
|
+
};
|
|
7693
|
+
/** @description Authenticated but lacking the required permission or feature flag. */
|
|
7694
|
+
403: {
|
|
7695
|
+
headers: {
|
|
7696
|
+
[name: string]: unknown;
|
|
7697
|
+
};
|
|
7698
|
+
content: {
|
|
7699
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7700
|
+
};
|
|
7701
|
+
};
|
|
7702
|
+
/** @description Resource not found. */
|
|
7703
|
+
404: {
|
|
7704
|
+
headers: {
|
|
7705
|
+
[name: string]: unknown;
|
|
7706
|
+
};
|
|
7707
|
+
content: {
|
|
7708
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7709
|
+
};
|
|
7710
|
+
};
|
|
7711
|
+
/** @description Body did not match the tool's input schema. */
|
|
7712
|
+
422: {
|
|
7713
|
+
headers: {
|
|
7714
|
+
[name: string]: unknown;
|
|
7715
|
+
};
|
|
7716
|
+
content: {
|
|
7717
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7718
|
+
};
|
|
7719
|
+
};
|
|
7720
|
+
/** @description Server error. */
|
|
7721
|
+
500: {
|
|
7722
|
+
headers: {
|
|
7723
|
+
[name: string]: unknown;
|
|
7724
|
+
};
|
|
7725
|
+
content: {
|
|
7726
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7727
|
+
};
|
|
7728
|
+
};
|
|
7729
|
+
};
|
|
7730
|
+
};
|
|
7731
|
+
createWhiteboard: {
|
|
7732
|
+
parameters: {
|
|
7733
|
+
query?: never;
|
|
7734
|
+
header?: never;
|
|
7735
|
+
path?: never;
|
|
7736
|
+
cookie?: never;
|
|
7737
|
+
};
|
|
7738
|
+
requestBody?: {
|
|
7739
|
+
content: {
|
|
7740
|
+
"application/json": {
|
|
7741
|
+
projectId: string;
|
|
7742
|
+
/** @description REQUIRED. A clear, descriptive board name (e.g. 'Q3 GTM plan'). Programmatic boards must be titled — blank/'Untitled' titles are rejected. */
|
|
7743
|
+
title: string;
|
|
7744
|
+
/** @description Optional folder to file the whiteboard under. */
|
|
7745
|
+
folderId?: string;
|
|
7746
|
+
};
|
|
7747
|
+
};
|
|
7748
|
+
};
|
|
7749
|
+
responses: {
|
|
7750
|
+
/** @description Tool result (shape varies per tool — refer to the tool's docs for the exact return value). */
|
|
7751
|
+
200: {
|
|
7752
|
+
headers: {
|
|
7753
|
+
[name: string]: unknown;
|
|
7754
|
+
};
|
|
7755
|
+
content: {
|
|
7756
|
+
"application/json": {
|
|
7757
|
+
[key: string]: unknown;
|
|
7758
|
+
};
|
|
7759
|
+
};
|
|
7760
|
+
};
|
|
7761
|
+
/** @description Validation error. */
|
|
7762
|
+
400: {
|
|
7763
|
+
headers: {
|
|
7764
|
+
[name: string]: unknown;
|
|
7765
|
+
};
|
|
7766
|
+
content: {
|
|
7767
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7768
|
+
};
|
|
7769
|
+
};
|
|
7770
|
+
/** @description Missing or invalid credentials. */
|
|
7771
|
+
401: {
|
|
7772
|
+
headers: {
|
|
7773
|
+
[name: string]: unknown;
|
|
7774
|
+
};
|
|
7775
|
+
content: {
|
|
7776
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7777
|
+
};
|
|
7778
|
+
};
|
|
7779
|
+
/** @description Authenticated but lacking the required permission or feature flag. */
|
|
7780
|
+
403: {
|
|
7781
|
+
headers: {
|
|
7782
|
+
[name: string]: unknown;
|
|
7783
|
+
};
|
|
7784
|
+
content: {
|
|
7785
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7786
|
+
};
|
|
7787
|
+
};
|
|
7788
|
+
/** @description Resource not found. */
|
|
7789
|
+
404: {
|
|
7790
|
+
headers: {
|
|
7791
|
+
[name: string]: unknown;
|
|
7792
|
+
};
|
|
7793
|
+
content: {
|
|
7794
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7795
|
+
};
|
|
7796
|
+
};
|
|
7797
|
+
/** @description Body did not match the tool's input schema. */
|
|
7798
|
+
422: {
|
|
7799
|
+
headers: {
|
|
7800
|
+
[name: string]: unknown;
|
|
7801
|
+
};
|
|
7802
|
+
content: {
|
|
7803
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7804
|
+
};
|
|
7805
|
+
};
|
|
7806
|
+
/** @description Server error. */
|
|
7807
|
+
500: {
|
|
7808
|
+
headers: {
|
|
7809
|
+
[name: string]: unknown;
|
|
7810
|
+
};
|
|
7811
|
+
content: {
|
|
7812
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7813
|
+
};
|
|
7814
|
+
};
|
|
7815
|
+
};
|
|
7816
|
+
};
|
|
7817
|
+
listWhiteboards: {
|
|
7818
|
+
parameters: {
|
|
7819
|
+
query?: never;
|
|
7820
|
+
header?: never;
|
|
7821
|
+
path?: never;
|
|
7822
|
+
cookie?: never;
|
|
7823
|
+
};
|
|
7824
|
+
requestBody?: {
|
|
7825
|
+
content: {
|
|
7826
|
+
"application/json": {
|
|
7827
|
+
projectId: string;
|
|
7828
|
+
};
|
|
7829
|
+
};
|
|
7830
|
+
};
|
|
7831
|
+
responses: {
|
|
7832
|
+
/** @description Tool result (shape varies per tool — refer to the tool's docs for the exact return value). */
|
|
7833
|
+
200: {
|
|
7834
|
+
headers: {
|
|
7835
|
+
[name: string]: unknown;
|
|
7836
|
+
};
|
|
7837
|
+
content: {
|
|
7838
|
+
"application/json": {
|
|
7839
|
+
[key: string]: unknown;
|
|
7840
|
+
};
|
|
7841
|
+
};
|
|
7842
|
+
};
|
|
7843
|
+
/** @description Validation error. */
|
|
7844
|
+
400: {
|
|
7845
|
+
headers: {
|
|
7846
|
+
[name: string]: unknown;
|
|
7847
|
+
};
|
|
7848
|
+
content: {
|
|
7849
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7850
|
+
};
|
|
7851
|
+
};
|
|
7852
|
+
/** @description Missing or invalid credentials. */
|
|
7853
|
+
401: {
|
|
7854
|
+
headers: {
|
|
7855
|
+
[name: string]: unknown;
|
|
7856
|
+
};
|
|
7857
|
+
content: {
|
|
7858
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7859
|
+
};
|
|
7860
|
+
};
|
|
7861
|
+
/** @description Authenticated but lacking the required permission or feature flag. */
|
|
7862
|
+
403: {
|
|
7863
|
+
headers: {
|
|
7864
|
+
[name: string]: unknown;
|
|
7865
|
+
};
|
|
7866
|
+
content: {
|
|
7867
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7868
|
+
};
|
|
7869
|
+
};
|
|
7870
|
+
/** @description Resource not found. */
|
|
7871
|
+
404: {
|
|
7872
|
+
headers: {
|
|
7873
|
+
[name: string]: unknown;
|
|
7874
|
+
};
|
|
7875
|
+
content: {
|
|
7876
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7877
|
+
};
|
|
7878
|
+
};
|
|
7879
|
+
/** @description Body did not match the tool's input schema. */
|
|
7880
|
+
422: {
|
|
7881
|
+
headers: {
|
|
7882
|
+
[name: string]: unknown;
|
|
7883
|
+
};
|
|
7884
|
+
content: {
|
|
7885
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7886
|
+
};
|
|
7887
|
+
};
|
|
7888
|
+
/** @description Server error. */
|
|
7889
|
+
500: {
|
|
7890
|
+
headers: {
|
|
7891
|
+
[name: string]: unknown;
|
|
7892
|
+
};
|
|
7893
|
+
content: {
|
|
7894
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7895
|
+
};
|
|
7896
|
+
};
|
|
7897
|
+
};
|
|
7898
|
+
};
|
|
7899
|
+
getWhiteboard: {
|
|
7900
|
+
parameters: {
|
|
7901
|
+
query?: never;
|
|
7902
|
+
header?: never;
|
|
7903
|
+
path?: never;
|
|
7904
|
+
cookie?: never;
|
|
7905
|
+
};
|
|
7906
|
+
requestBody?: {
|
|
7907
|
+
content: {
|
|
7908
|
+
"application/json": {
|
|
7909
|
+
documentId: string;
|
|
7910
|
+
/** @description When true, returns the full Excalidraw scene so it can be modified and written back. */
|
|
7911
|
+
includeElements?: boolean;
|
|
7912
|
+
};
|
|
7913
|
+
};
|
|
7914
|
+
};
|
|
7915
|
+
responses: {
|
|
7916
|
+
/** @description Tool result (shape varies per tool — refer to the tool's docs for the exact return value). */
|
|
7917
|
+
200: {
|
|
7918
|
+
headers: {
|
|
7919
|
+
[name: string]: unknown;
|
|
7920
|
+
};
|
|
7921
|
+
content: {
|
|
7922
|
+
"application/json": {
|
|
7923
|
+
[key: string]: unknown;
|
|
7924
|
+
};
|
|
7925
|
+
};
|
|
7926
|
+
};
|
|
7927
|
+
/** @description Validation error. */
|
|
7928
|
+
400: {
|
|
7929
|
+
headers: {
|
|
7930
|
+
[name: string]: unknown;
|
|
7931
|
+
};
|
|
7932
|
+
content: {
|
|
7933
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7934
|
+
};
|
|
7935
|
+
};
|
|
7936
|
+
/** @description Missing or invalid credentials. */
|
|
7937
|
+
401: {
|
|
7938
|
+
headers: {
|
|
7939
|
+
[name: string]: unknown;
|
|
7940
|
+
};
|
|
7941
|
+
content: {
|
|
7942
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7943
|
+
};
|
|
7944
|
+
};
|
|
7945
|
+
/** @description Authenticated but lacking the required permission or feature flag. */
|
|
7946
|
+
403: {
|
|
7947
|
+
headers: {
|
|
7948
|
+
[name: string]: unknown;
|
|
7949
|
+
};
|
|
7950
|
+
content: {
|
|
7951
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7952
|
+
};
|
|
7953
|
+
};
|
|
7954
|
+
/** @description Resource not found. */
|
|
7955
|
+
404: {
|
|
7956
|
+
headers: {
|
|
7957
|
+
[name: string]: unknown;
|
|
7958
|
+
};
|
|
7959
|
+
content: {
|
|
7960
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7961
|
+
};
|
|
7962
|
+
};
|
|
7963
|
+
/** @description Body did not match the tool's input schema. */
|
|
7964
|
+
422: {
|
|
7965
|
+
headers: {
|
|
7966
|
+
[name: string]: unknown;
|
|
7967
|
+
};
|
|
7968
|
+
content: {
|
|
7969
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7970
|
+
};
|
|
7971
|
+
};
|
|
7972
|
+
/** @description Server error. */
|
|
7973
|
+
500: {
|
|
7974
|
+
headers: {
|
|
7975
|
+
[name: string]: unknown;
|
|
7976
|
+
};
|
|
7977
|
+
content: {
|
|
7978
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
7979
|
+
};
|
|
7980
|
+
};
|
|
7981
|
+
};
|
|
7982
|
+
};
|
|
7983
|
+
updateWhiteboardScene: {
|
|
7984
|
+
parameters: {
|
|
7985
|
+
query?: never;
|
|
7986
|
+
header?: never;
|
|
7987
|
+
path?: never;
|
|
7988
|
+
cookie?: never;
|
|
7989
|
+
};
|
|
7990
|
+
requestBody?: {
|
|
7991
|
+
content: {
|
|
7992
|
+
"application/json": {
|
|
7993
|
+
documentId: string;
|
|
7994
|
+
/** @description Elements to write. For mode 'patch', each may be a partial { id, ...changedFields } merged into the matching element by id; full Excalidraw elements for 'replace'/'append' (or new ids in 'patch'). */
|
|
7995
|
+
elements?: Record<string, never>[];
|
|
7996
|
+
/**
|
|
7997
|
+
* @description How to apply your `elements`. patch (DEFAULT — use this for ANY partial edit): merges each item into the element with the same id and leaves everything else untouched, like find-and-replace by id; new ids are added. append: only adds your items, changes nothing else. replace: OVERWRITES THE WHOLE CANVAS — every existing element you don't resend is DELETED — so use it ONLY to set an entire board at once. To change or rebuild just a SECTION, use patch (+ deleteIds to remove specific ids), NEVER replace. A replace that would drop any existing element is rejected unless confirmReplace:true.
|
|
7998
|
+
* @enum {string}
|
|
7999
|
+
*/
|
|
8000
|
+
mode?: "patch" | "append" | "replace";
|
|
8001
|
+
/** @description Element ids to remove from the scene. */
|
|
8002
|
+
deleteIds?: string[];
|
|
8003
|
+
/** @description Optional Excalidraw appState fields to merge (e.g. viewBackgroundColor). */
|
|
8004
|
+
appState?: Record<string, never>;
|
|
8005
|
+
/** @description Optional Excalidraw BinaryFiles map (for embedded images), merged in. */
|
|
8006
|
+
files?: Record<string, never>;
|
|
8007
|
+
/** @description Optional optimistic-locking token from getWhiteboard. Only used for mode 'replace': if the board changed since you read it, the replace is rejected so you don't overwrite a collaborator's newer edits — re-read with getWhiteboard and retry. Not needed for patch/append, which automatically merge onto the latest scene. */
|
|
8008
|
+
versionTimestamp?: number;
|
|
8009
|
+
/** @description Safety acknowledgement for mode 'replace' ONLY. A replace that would DELETE ANY existing element not present in your `elements` is rejected unless this is true. Leave it unset and use mode:'patch' to edit part of a board (it merges by id and keeps the rest); set true only when you truly intend to overwrite the WHOLE scene. */
|
|
8010
|
+
confirmReplace?: boolean;
|
|
8011
|
+
};
|
|
8012
|
+
};
|
|
8013
|
+
};
|
|
8014
|
+
responses: {
|
|
8015
|
+
/** @description Tool result (shape varies per tool — refer to the tool's docs for the exact return value). */
|
|
8016
|
+
200: {
|
|
8017
|
+
headers: {
|
|
8018
|
+
[name: string]: unknown;
|
|
8019
|
+
};
|
|
8020
|
+
content: {
|
|
8021
|
+
"application/json": {
|
|
8022
|
+
[key: string]: unknown;
|
|
8023
|
+
};
|
|
8024
|
+
};
|
|
8025
|
+
};
|
|
8026
|
+
/** @description Validation error. */
|
|
8027
|
+
400: {
|
|
8028
|
+
headers: {
|
|
8029
|
+
[name: string]: unknown;
|
|
8030
|
+
};
|
|
8031
|
+
content: {
|
|
8032
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
8033
|
+
};
|
|
8034
|
+
};
|
|
8035
|
+
/** @description Missing or invalid credentials. */
|
|
8036
|
+
401: {
|
|
8037
|
+
headers: {
|
|
8038
|
+
[name: string]: unknown;
|
|
8039
|
+
};
|
|
8040
|
+
content: {
|
|
8041
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
8042
|
+
};
|
|
8043
|
+
};
|
|
8044
|
+
/** @description Authenticated but lacking the required permission or feature flag. */
|
|
8045
|
+
403: {
|
|
8046
|
+
headers: {
|
|
8047
|
+
[name: string]: unknown;
|
|
8048
|
+
};
|
|
8049
|
+
content: {
|
|
8050
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
8051
|
+
};
|
|
8052
|
+
};
|
|
8053
|
+
/** @description Resource not found. */
|
|
8054
|
+
404: {
|
|
8055
|
+
headers: {
|
|
8056
|
+
[name: string]: unknown;
|
|
8057
|
+
};
|
|
8058
|
+
content: {
|
|
8059
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
8060
|
+
};
|
|
8061
|
+
};
|
|
8062
|
+
/** @description Body did not match the tool's input schema. */
|
|
8063
|
+
422: {
|
|
8064
|
+
headers: {
|
|
8065
|
+
[name: string]: unknown;
|
|
8066
|
+
};
|
|
8067
|
+
content: {
|
|
8068
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
8069
|
+
};
|
|
8070
|
+
};
|
|
8071
|
+
/** @description Server error. */
|
|
8072
|
+
500: {
|
|
8073
|
+
headers: {
|
|
8074
|
+
[name: string]: unknown;
|
|
8075
|
+
};
|
|
8076
|
+
content: {
|
|
8077
|
+
"application/json": components["schemas"]["ErrorResponse"];
|
|
8078
|
+
};
|
|
8079
|
+
};
|
|
8080
|
+
};
|
|
8081
|
+
};
|
|
8082
|
+
addWhiteboardElements: {
|
|
8083
|
+
parameters: {
|
|
8084
|
+
query?: never;
|
|
8085
|
+
header?: never;
|
|
8086
|
+
path?: never;
|
|
8087
|
+
cookie?: never;
|
|
8088
|
+
};
|
|
8089
|
+
requestBody?: {
|
|
8090
|
+
content: {
|
|
8091
|
+
"application/json": {
|
|
8092
|
+
documentId: string;
|
|
8093
|
+
/** @description Non-empty array of shape specs to append. Prefer stencils / sticky notes / architecture icons over raw rectangles wherever a standard form fits (see the `type` enum below and the tool description). */
|
|
8094
|
+
shapes: ({
|
|
8095
|
+
/**
|
|
8096
|
+
* @description Element kind. 'sticky' = a first-class sticky/post-it note (solid fill + auto-fitting bound label; set text + backgroundColor) — use this for sticky notes, NOT a stencil. 'stencil' = a hand-drawn library graphic from listWhiteboardStencils, of kind 'symbol' (one atomic labelled node — flowchart box, BPMN task, org node: set `id` + `text` + width/height, text auto-fits, connect arrows via start/end {id}) or 'template' (a multi-element layout — Alerts, Forms, Tables, Charts: place whole, then customise its returned children by id; do NOT set a single `text`). Set `stencil` (fuzzy name, one call) or `stencilKey` (exact). 'image' with `iconPath` = a software-architecture icon from listArchitectureIcons. 'chart' = a NATIVE, fully-editable data chart (column/bar/line/area/pie/donut/scatter/sparkline/combo/stackedColumn/groupedColumn/radar/gauge) built from real Excalidraw shapes — bars/lines/wedges plus axes, gridlines and a legend — for ANY data, metric, KPI, trend, comparison or breakdown: set chartType + series (+ categories + options). ALWAYS prefer a 'chart' over hand-drawing bars/lines or a wireframe 'chart' stencil. 'table' = a NATIVE, fully-editable GRID (real rectangles + bound, word-wrapped cells, auto-sized columns + rows, a header band, optional zebra striping / per-column colours) for ANY tabular data, list or matrix — set columns + rows (+ options). ALWAYS prefer a 'table' over hand-drawing a grid of boxes. Reserve rectangle/ellipse/diamond for when no standard form fits.
|
|
8097
|
+
* @enum {string}
|
|
8098
|
+
*/
|
|
8099
|
+
type?: "rectangle" | "ellipse" | "diamond" | "sticky" | "text" | "arrow" | "line" | "freedraw" | "doodle" | "frame" | "image" | "stencil" | "chart" | "table";
|
|
8100
|
+
/** @description For type:'stencil' — fuzzy-match a library stencil by name in ONE call, no prior listWhiteboardStencils needed (e.g. 'decision', 'actor', 'phone frame', 'kanban column'). NOTE: there is no sticky-note stencil — use type:'sticky' for sticky/post-it notes. */
|
|
8101
|
+
stencil?: string;
|
|
8102
|
+
/** @description For type:'stencil' — exact stencil key from listWhiteboardStencils (takes precedence over `stencil`). */
|
|
8103
|
+
stencilKey?: string;
|
|
8104
|
+
/** @description For type:'stencil' — optional pack to disambiguate a fuzzy `stencil` match (e.g. 'Flowchart', 'BPMN', 'UML & ER', 'Scrum Board'). */
|
|
8105
|
+
pack?: string;
|
|
8106
|
+
/** @description For type:'image' — a software-architecture icon path from listArchitectureIcons (e.g. 'dev/docker.svg'). */
|
|
8107
|
+
iconPath?: string;
|
|
8108
|
+
/** @description For type:'image' — any other public image URL (use iconPath for curated architecture icons). */
|
|
8109
|
+
imageUrl?: string;
|
|
8110
|
+
/** @description For type:'doodle' — a named hand-drawn accent rendered as a freehand stroke (no points needed): 'underline' | 'wave' | 'arrow' | 'check' | 'bolt' | 'scribble' | 'star' | 'sparkle' | 'circle' (a ring to encircle/emphasise) | 'heart'. Size it with x/y + width/height and colour it with strokeColor. Great for sketchy emphasis (underline a title, circle a stat, a star/sparkle accent). */
|
|
8111
|
+
doodle?: string;
|
|
8112
|
+
/** @description Optional id so connectors (arrows/lines) can reference this shape via start/end. On a type:'stencil' it adds a transparent bindable anchor covering the stencil, so an arrow's start/end {id} connects to the whole stencil as a unit. */
|
|
7319
8113
|
id?: string;
|
|
7320
8114
|
/** @description Join an existing group. Pass a placed stencil's `groupId` (returned in the placement result) on a type:'text' or shape spec to FILL that frame as part of the same unit — the text then moves, duplicates and renders together with the frame (e.g. a title in a UML class box's top band, members in its body). */
|
|
7321
8115
|
groupId?: string;
|
|
@@ -7376,6 +8170,10 @@ interface operations {
|
|
|
7376
8170
|
columns?: (string | Record<string, never>)[];
|
|
7377
8171
|
/** @description For type:'table' — data rows; each row is an array of cell values (string|number) aligned to columns, e.g. [['T-1','Sam','Done'],['T-2','Lee','WIP']]. */
|
|
7378
8172
|
rows?: (string | number)[][];
|
|
8173
|
+
/** @description Arbitrary Excalidraw customData stored on the element (e.g. a slide frame's { deckId } so a board frame resolves back to its source deck). Merged with any builder-set customData. */
|
|
8174
|
+
customData?: {
|
|
8175
|
+
[key: string]: unknown;
|
|
8176
|
+
};
|
|
7379
8177
|
} & {
|
|
7380
8178
|
[key: string]: unknown;
|
|
7381
8179
|
})[];
|
|
@@ -8435,8 +9233,8 @@ interface operations {
|
|
|
8435
9233
|
requestBody?: {
|
|
8436
9234
|
content: {
|
|
8437
9235
|
"application/json": {
|
|
8438
|
-
/** @description Which catalogs to sync. Defaults to all
|
|
8439
|
-
types?: ("tool" | "stencil" | "icon")[];
|
|
9236
|
+
/** @description Which catalogs to sync. Defaults to all six (tool, stencil, icon, infographic_template, whiteboard_component, skill). */
|
|
9237
|
+
types?: ("tool" | "stencil" | "icon" | "infographic_template" | "whiteboard_component" | "skill")[];
|
|
8440
9238
|
};
|
|
8441
9239
|
};
|
|
8442
9240
|
};
|