1#![forbid(unsafe_code)]
2#![allow(clippy::too_many_arguments)]
3#![allow(unused_mut)]
4#![allow(unused_variables)]
5#![allow(unused_imports)]
6
7mod api_client;
8pub mod builder;
9pub mod clients;
10
11use anyhow::{Context as _, Result};
12pub use api_client::{ApiClient, ApiClientError};
13use reqwest::Method;
14
15pub(crate) mod models {
16 pub(crate) use fiberplane_models::blobs::*;
17 pub(crate) use fiberplane_models::comments::*;
18 pub(crate) use fiberplane_models::data_sources::*;
19 pub(crate) use fiberplane_models::events::*;
20 pub(crate) use fiberplane_models::files::*;
21 pub(crate) use fiberplane_models::formatting::*;
22 pub(crate) use fiberplane_models::front_matter_schemas::*;
23 pub(crate) use fiberplane_models::integrations::*;
24 pub(crate) use fiberplane_models::labels::*;
25 pub(crate) use fiberplane_models::names::*;
26 pub(crate) use fiberplane_models::notebooks::front_matter::*;
27 pub(crate) use fiberplane_models::notebooks::operations::*;
28 pub(crate) use fiberplane_models::notebooks::*;
29 pub(crate) use fiberplane_models::pagerduty::*;
30 pub(crate) use fiberplane_models::paging::*;
31 pub(crate) use fiberplane_models::proxies::*;
32 pub(crate) use fiberplane_models::query_data::*;
33 pub(crate) use fiberplane_models::realtime::*;
34 pub(crate) use fiberplane_models::snippets::*;
35 pub(crate) use fiberplane_models::sorting::*;
36 pub(crate) use fiberplane_models::templates::*;
37 pub(crate) use fiberplane_models::timestamps::*;
38 pub(crate) use fiberplane_models::tokens::*;
39 pub(crate) use fiberplane_models::users::*;
40 pub(crate) use fiberplane_models::views::*;
41 pub(crate) use fiberplane_models::webhooks::*;
42 pub(crate) use fiberplane_models::workspaces::*;
43}
44
45impl ApiClient {
46 #[doc = r#"Retrieves a comment from a discussion thread by comment ID"#]
47 pub async fn comment_get(&self, comment_id: base64uuid::Base64Uuid) -> Result<models::Comment> {
48 let mut builder = self.request(
49 Method::GET,
50 &format!("/api/comments/{commentId}", commentId = comment_id,),
51 )?;
52 let response = builder.send().await?.error_for_status()?.json().await?;
53
54 Ok(response)
55 }
56
57 #[doc = r#"Deletes a comment in a discussion thread by comment ID"#]
58 pub async fn comment_delete(&self, comment_id: base64uuid::Base64Uuid) -> Result<()> {
59 let mut builder = self.request(
60 Method::DELETE,
61 &format!("/api/comments/{commentId}", commentId = comment_id,),
62 )?;
63 let response = builder.send().await?.error_for_status()?;
64
65 Ok(())
66 }
67
68 #[doc = r#"Updates a comment in a discussion thread by comment ID"#]
69 pub async fn comment_update(
70 &self,
71 comment_id: base64uuid::Base64Uuid,
72 payload: models::UpdateComment,
73 ) -> Result<models::Comment> {
74 let mut builder = self.request(
75 Method::PATCH,
76 &format!("/api/comments/{commentId}", commentId = comment_id,),
77 )?;
78 builder = builder.json(&payload);
79 let response = builder.send().await?.error_for_status()?.json().await?;
80
81 Ok(response)
82 }
83
84 #[doc = r#"Deletes a event"#]
85 pub async fn event_delete(&self, event_id: base64uuid::Base64Uuid) -> Result<()> {
86 let mut builder = self.request(
87 Method::DELETE,
88 &format!("/api/events/{eventId}", eventId = event_id,),
89 )?;
90 let response = builder.send().await?.error_for_status()?;
91
92 Ok(())
93 }
94
95 #[doc = r#"Deletes a pending workspace invitation"#]
96 pub async fn workspace_invite_delete(
97 &self,
98 invitation_id: base64uuid::Base64Uuid,
99 ) -> Result<()> {
100 let mut builder = self.request(
101 Method::DELETE,
102 &format!(
103 "/api/invitations/{invitationId}",
104 invitationId = invitation_id,
105 ),
106 )?;
107 let response = builder.send().await?.error_for_status()?;
108
109 Ok(())
110 }
111
112 #[doc = r#"Accepts the workspace invitation"#]
113 pub async fn workspace_invite_accept(
114 &self,
115 invitation_id: base64uuid::Base64Uuid,
116 invitation_secret: &str,
117 ) -> Result<models::Workspace> {
118 let mut builder = self.request(
119 Method::POST,
120 &format!(
121 "/api/invitations/{invitationId}/{invitationSecret}/accept",
122 invitationId = invitation_id,
123 invitationSecret = invitation_secret,
124 ),
125 )?;
126 let response = builder.send().await?.error_for_status()?.json().await?;
127
128 Ok(response)
129 }
130
131 #[doc = r#"Declines the workspace invitation"#]
132 pub async fn workspace_invite_decline(
133 &self,
134 invitation_id: base64uuid::Base64Uuid,
135 invitation_secret: &str,
136 ) -> Result<()> {
137 let mut builder = self.request(
138 Method::POST,
139 &format!(
140 "/api/invitations/{invitationId}/{invitationSecret}/decline",
141 invitationId = invitation_id,
142 invitationSecret = invitation_secret,
143 ),
144 )?;
145 let response = builder.send().await?.error_for_status()?;
146
147 Ok(())
148 }
149
150 #[doc = r#"Log out of Fiberplane"#]
151 pub async fn logout(&self) -> Result<()> {
152 let mut builder = self.request(Method::POST, "/api/logout")?;
153 let response = builder.send().await?.error_for_status()?;
154
155 Ok(())
156 }
157
158 #[doc = r#"Retrieves a single notebook (both its metadata and content)"#]
159 pub async fn notebook_get(
160 &self,
161 notebook_id: base64uuid::Base64Uuid,
162 ) -> Result<models::Notebook> {
163 let mut builder = self.request(
164 Method::GET,
165 &format!("/api/notebooks/{notebookId}", notebookId = notebook_id,),
166 )?;
167 let response = builder.send().await?.error_for_status()?.json().await?;
168
169 Ok(response)
170 }
171
172 #[doc = r#"Deletes a notebook"#]
173 pub async fn notebook_delete(&self, notebook_id: base64uuid::Base64Uuid) -> Result<()> {
174 let mut builder = self.request(
175 Method::DELETE,
176 &format!("/api/notebooks/{notebookId}", notebookId = notebook_id,),
177 )?;
178 let response = builder.send().await?.error_for_status()?;
179
180 Ok(())
181 }
182
183 #[doc = r#"Modifies individual properties of a single notebook"#]
184 pub async fn notebook_update(
185 &self,
186 notebook_id: base64uuid::Base64Uuid,
187 payload: models::UpdateNotebook,
188 ) -> Result<()> {
189 let mut builder = self.request(
190 Method::PATCH,
191 &format!("/api/notebooks/{notebookId}", notebookId = notebook_id,),
192 )?;
193 builder = builder.json(&payload);
194 let response = builder.send().await?.error_for_status()?;
195
196 Ok(())
197 }
198
199 #[doc = r#"Append the given cells to the notebook. Any cells that have their ID missing will be set on the server."#]
200 pub async fn notebook_cells_append(
201 &self,
202 notebook_id: base64uuid::Base64Uuid,
203 after: Option<&str>,
204 before: Option<&str>,
205 payload: Vec<models::Cell>,
206 ) -> Result<Vec<models::Cell>> {
207 let mut builder = self.request(
208 Method::POST,
209 &format!(
210 "/api/notebooks/{notebookId}/cells",
211 notebookId = notebook_id,
212 ),
213 )?;
214 if let Some(after) = after {
215 builder = builder.query(&[("after", after)]);
216 }
217 if let Some(before) = before {
218 builder = builder.query(&[("before", before)]);
219 }
220 builder = builder.json(&payload);
221 let response = builder.send().await?.error_for_status()?.json().await?;
222
223 Ok(response)
224 }
225
226 #[doc = r#"Append the given text and optional formatting to the specified cell"#]
227 pub async fn notebook_cell_append_text(
228 &self,
229 notebook_id: base64uuid::Base64Uuid,
230 cell_id: &str,
231 payload: models::CellAppendText,
232 ) -> Result<models::Cell> {
233 let mut builder = self.request(
234 Method::POST,
235 &format!(
236 "/api/notebooks/{notebookId}/cells/{cellId}/append",
237 notebookId = notebook_id,
238 cellId = cell_id,
239 ),
240 )?;
241 builder = builder.json(&payload);
242 let response = builder.send().await?.error_for_status()?.json().await?;
243
244 Ok(response)
245 }
246
247 #[doc = r#"Replace some text and formatting in the specified cell"#]
248 pub async fn notebook_cell_replace_text(
249 &self,
250 notebook_id: base64uuid::Base64Uuid,
251 cell_id: &str,
252 payload: models::CellReplaceText,
253 ) -> Result<models::Cell> {
254 let mut builder = self.request(
255 Method::POST,
256 &format!(
257 "/api/notebooks/{notebookId}/cells/{cellId}/replaceText",
258 notebookId = notebook_id,
259 cellId = cell_id,
260 ),
261 )?;
262 builder = builder.json(&payload);
263 let response = builder.send().await?.error_for_status()?.json().await?;
264
265 Ok(response)
266 }
267
268 #[doc = r#"Creates a copy of the specified notebook"#]
269 pub async fn notebook_duplicate(
270 &self,
271 notebook_id: base64uuid::Base64Uuid,
272 payload: models::NotebookCopyDestination,
273 ) -> Result<models::Notebook> {
274 let mut builder = self.request(
275 Method::POST,
276 &format!(
277 "/api/notebooks/{notebookId}/duplicate",
278 notebookId = notebook_id,
279 ),
280 )?;
281 builder = builder.json(&payload);
282 let response = builder.send().await?.error_for_status()?.json().await?;
283
284 Ok(response)
285 }
286
287 #[doc = r#"upload a file"#]
288 pub async fn notebook_upload_file(
289 &self,
290 notebook_id: base64uuid::Base64Uuid,
291 payload: models::UploadData,
292 ) -> Result<models::FileSummary> {
293 let mut builder = self.request(
294 Method::POST,
295 &format!(
296 "/api/notebooks/{notebookId}/files",
297 notebookId = notebook_id,
298 ),
299 )?;
300 builder = builder.form(&payload);
301 let response = builder.send().await?.error_for_status()?.json().await?;
302
303 Ok(response)
304 }
305
306 #[doc = r#"Get a file from a notebook"#]
307 pub async fn notebook_get_file(
308 &self,
309 notebook_id: base64uuid::Base64Uuid,
310 file_id: &str,
311 ) -> Result<bytes::Bytes> {
312 let mut builder = self.request(
313 Method::GET,
314 &format!(
315 "/api/notebooks/{notebookId}/files/{fileId}",
316 notebookId = notebook_id,
317 fileId = file_id,
318 ),
319 )?;
320 let response = builder.send().await?.error_for_status()?.bytes().await?;
321
322 Ok(response)
323 }
324
325 #[doc = r#"Delete a file from a notebook"#]
326 pub async fn notebook_delete_file(
327 &self,
328 notebook_id: base64uuid::Base64Uuid,
329 file_id: &str,
330 ) -> Result<()> {
331 let mut builder = self.request(
332 Method::DELETE,
333 &format!(
334 "/api/notebooks/{notebookId}/files/{fileId}",
335 notebookId = notebook_id,
336 fileId = file_id,
337 ),
338 )?;
339 let response = builder.send().await?.error_for_status()?;
340
341 Ok(())
342 }
343
344 #[doc = r#"Adds rows to the front matter of a notebook.
345If the requested position is out of bounds or is not specified, will append the rows to the existing front matter.
346"#]
347 pub async fn front_matter_add_keys(
348 &self,
349 notebook_id: base64uuid::Base64Uuid,
350 payload: models::FrontMatterAddRows,
351 ) -> Result<()> {
352 let mut builder = self.request(
353 Method::POST,
354 &format!(
355 "/api/notebooks/{notebookId}/front_matter",
356 notebookId = notebook_id,
357 ),
358 )?;
359 builder = builder.json(&payload);
360 let response = builder.send().await?.error_for_status()?;
361
362 Ok(())
363 }
364
365 #[doc = r#"Deletes *all* front matter data for notebook.
366If you wish to delete a single key instead of the whole object, use the `patch` endpoint with value: `null`
367"#]
368 pub async fn front_matter_delete(&self, notebook_id: base64uuid::Base64Uuid) -> Result<()> {
369 let mut builder = self.request(
370 Method::DELETE,
371 &format!(
372 "/api/notebooks/{notebookId}/front_matter",
373 notebookId = notebook_id,
374 ),
375 )?;
376 let response = builder.send().await?.error_for_status()?;
377
378 Ok(())
379 }
380
381 #[doc = r#"Updates front matter for a given notebook"#]
382 pub async fn front_matter_update(
383 &self,
384 notebook_id: base64uuid::Base64Uuid,
385 payload: models::FrontMatter,
386 ) -> Result<()> {
387 let mut builder = self.request(
388 Method::PATCH,
389 &format!(
390 "/api/notebooks/{notebookId}/front_matter",
391 notebookId = notebook_id,
392 ),
393 )?;
394 builder = builder.json(&payload);
395 let response = builder.send().await?.error_for_status()?;
396
397 Ok(())
398 }
399
400 #[doc = r#"Deletes a row of the front matter for a notebook.
401"#]
402 pub async fn front_matter_delete_key(
403 &self,
404 notebook_id: base64uuid::Base64Uuid,
405 front_matter_key: &str,
406 ) -> Result<()> {
407 let mut builder = self.request(
408 Method::DELETE,
409 &format!(
410 "/api/notebooks/{notebookId}/front_matter/{frontMatterKey}",
411 notebookId = notebook_id,
412 frontMatterKey = front_matter_key,
413 ),
414 )?;
415 let response = builder.send().await?.error_for_status()?;
416
417 Ok(())
418 }
419
420 #[doc = r#"Updates a front matter row of a given notebook"#]
421 pub async fn front_matter_update_key(
422 &self,
423 notebook_id: base64uuid::Base64Uuid,
424 front_matter_key: &str,
425 payload: models::FrontMatterUpdateRow,
426 ) -> Result<()> {
427 let mut builder = self.request(
428 Method::PATCH,
429 &format!(
430 "/api/notebooks/{notebookId}/front_matter/{frontMatterKey}",
431 notebookId = notebook_id,
432 frontMatterKey = front_matter_key,
433 ),
434 )?;
435 builder = builder.json(&payload);
436 let response = builder.send().await?.error_for_status()?;
437
438 Ok(())
439 }
440
441 #[doc = r#"Expand the snippet and insert the cells into the notebook"#]
442 pub async fn notebook_snippet_insert(
443 &self,
444 notebook_id: base64uuid::Base64Uuid,
445 snippet_name: &fiberplane_models::names::Name,
446 cell_id: Option<&str>,
447 ) -> Result<Vec<models::Cell>> {
448 let mut builder = self.request(
449 Method::POST,
450 &format!(
451 "/api/notebooks/{notebookId}/insert_snippet/{snippetName}",
452 notebookId = notebook_id,
453 snippetName = snippet_name,
454 ),
455 )?;
456 if let Some(cell_id) = cell_id {
457 builder = builder.query(&[("cell_id", cell_id)]);
458 }
459 let response = builder.send().await?.error_for_status()?.json().await?;
460
461 Ok(response)
462 }
463
464 #[doc = r#"Convert the notebook cells to a snippet"#]
465 pub async fn notebook_convert_to_snippet(
466 &self,
467 notebook_id: base64uuid::Base64Uuid,
468 start_cell_id: Option<&str>,
469 end_cell_id: Option<&str>,
470 ) -> Result<String> {
471 let mut builder = self.request(
472 Method::GET,
473 &format!(
474 "/api/notebooks/{notebookId}/snippet.jsonnet",
475 notebookId = notebook_id,
476 ),
477 )?;
478 if let Some(start_cell_id) = start_cell_id {
479 builder = builder.query(&[("start_cell_id", start_cell_id)]);
480 }
481 if let Some(end_cell_id) = end_cell_id {
482 builder = builder.query(&[("end_cell_id", end_cell_id)]);
483 }
484 let response = builder.send().await?.error_for_status()?.text().await?;
485
486 Ok(response)
487 }
488
489 #[doc = r#"Downloads the specified notebooks as a Jsonnet template."#]
490 pub async fn notebook_convert_to_template(
491 &self,
492 notebook_id: base64uuid::Base64Uuid,
493 ) -> Result<String> {
494 let mut builder = self.request(
495 Method::GET,
496 &format!(
497 "/api/notebooks/{notebookId}/template.jsonnet",
498 notebookId = notebook_id,
499 ),
500 )?;
501 let response = builder.send().await?.error_for_status()?.text().await?;
502
503 Ok(response)
504 }
505
506 #[doc = r#"List the threads in the given notebook"#]
507 pub async fn threads_list(
508 &self,
509 notebook_id: base64uuid::Base64Uuid,
510 status: Option<models::ThreadStatus>,
511 ) -> Result<Vec<models::ThreadSummary>> {
512 let mut builder = self.request(
513 Method::GET,
514 &format!(
515 "/api/notebooks/{notebookId}/threads",
516 notebookId = notebook_id,
517 ),
518 )?;
519 if let Some(status) = status {
520 builder = builder.query(&[("status", status)]);
521 }
522 let response = builder.send().await?.error_for_status()?.json().await?;
523
524 Ok(response)
525 }
526
527 #[doc = r#"Creates a new comment thread in a notebook"#]
528 pub async fn thread_create(
529 &self,
530 notebook_id: base64uuid::Base64Uuid,
531 payload: models::NewThread,
532 ) -> Result<models::Thread> {
533 let mut builder = self.request(
534 Method::POST,
535 &format!(
536 "/api/notebooks/{notebookId}/threads",
537 notebookId = notebook_id,
538 ),
539 )?;
540 builder = builder.json(&payload);
541 let response = builder.send().await?.error_for_status()?.json().await?;
542
543 Ok(response)
544 }
545
546 #[doc = r#"Start the auth flow to authenticate a user (used only with the Studio).
547For authenticating with the API see the Authentication section in the docs
548"#]
549 pub async fn oidc_authorize(
550 &self,
551 provider: &str,
552 cli_redirect_port: Option<i32>,
553 redirect: Option<&str>,
554 ) -> Result<()> {
555 let mut builder = self.request(
556 Method::GET,
557 &format!("/api/oidc/authorize/{provider}", provider = provider,),
558 )?;
559 let response = builder.send().await?.error_for_status()?;
560
561 Ok(())
562 }
563
564 #[doc = r#"Start the auth flow for linking an existing Fiberplane account with a new OID identity (used only with the Studio).
565For authenticating with the API see the Authentication section in the docs
566"#]
567 pub async fn oid_linkup(
568 &self,
569 provider: &str,
570 cli_redirect_port: Option<i32>,
571 redirect: Option<&str>,
572 ) -> Result<models::OidLinkupLocation> {
573 let mut builder = self.request(
574 Method::POST,
575 &format!("/api/oidc/linkup/{provider}", provider = provider,),
576 )?;
577 let response = builder.send().await?.error_for_status()?.json().await?;
578
579 Ok(response)
580 }
581
582 #[doc = r#"Pins a notebook"#]
583 pub async fn pinned_notebook_create(&self, payload: models::NewPinnedNotebook) -> Result<()> {
584 let mut builder = self.request(Method::POST, "/api/pinnednotebooks")?;
585 builder = builder.json(&payload);
586 let response = builder.send().await?.error_for_status()?;
587
588 Ok(())
589 }
590
591 #[doc = r#"Unpins a notebook"#]
592 pub async fn pinned_notebook_delete(&self, notebook_id: base64uuid::Base64Uuid) -> Result<()> {
593 let mut builder = self.request(
594 Method::DELETE,
595 &format!(
596 "/api/pinnednotebooks/{notebookId}",
597 notebookId = notebook_id,
598 ),
599 )?;
600 let response = builder.send().await?.error_for_status()?;
601
602 Ok(())
603 }
604
605 #[doc = r#"Fetch the profile of the authenticated user"#]
606 pub async fn profile_get(&self) -> Result<models::Profile> {
607 let mut builder = self.request(Method::GET, "/api/profile")?;
608 let response = builder.send().await?.error_for_status()?.json().await?;
609
610 Ok(response)
611 }
612
613 #[doc = r#"List of all available providers and if they're linked to the current user"#]
614 pub async fn oid_connections_list(&self) -> Result<Vec<models::OidConnection>> {
615 let mut builder = self.request(Method::GET, "/api/profile/connections")?;
616 let response = builder.send().await?.error_for_status()?.json().await?;
617
618 Ok(response)
619 }
620
621 #[doc = r#"Get a list of all integrations and their status for the current user"#]
622 pub async fn integrations_get_by_user(
623 &self,
624 ) -> Result<Vec<models::PersonalIntegrationSummary>> {
625 let mut builder = self.request(Method::GET, "/api/profile/integrations")?;
626 let response = builder.send().await?.error_for_status()?.json().await?;
627
628 Ok(response)
629 }
630
631 #[doc = r#"Retrieve profile image"#]
632 pub async fn profile_picture_get(&self) -> Result<bytes::Bytes> {
633 let mut builder = self.request(Method::GET, "/api/profile/picture")?;
634 let response = builder.send().await?.error_for_status()?.bytes().await?;
635
636 Ok(response)
637 }
638
639 #[doc = r#"Upload profile image"#]
640 pub async fn profile_picture_update(&self, payload: models::ProfileUploadData) -> Result<()> {
641 let mut builder = self.request(Method::POST, "/api/profile/picture")?;
642 builder = builder.form(&payload);
643 let response = builder.send().await?.error_for_status()?;
644
645 Ok(())
646 }
647
648 #[doc = r#"Retrieves a discussion thread by ID"#]
649 pub async fn thread_get(&self, thread_id: base64uuid::Base64Uuid) -> Result<models::Thread> {
650 let mut builder = self.request(
651 Method::GET,
652 &format!("/api/threads/{threadId}", threadId = thread_id,),
653 )?;
654 let response = builder.send().await?.error_for_status()?.json().await?;
655
656 Ok(response)
657 }
658
659 #[doc = r#"Deletes a discussion thread by ID"#]
660 pub async fn thread_delete(&self, thread_id: base64uuid::Base64Uuid) -> Result<()> {
661 let mut builder = self.request(
662 Method::DELETE,
663 &format!("/api/threads/{threadId}", threadId = thread_id,),
664 )?;
665 let response = builder.send().await?.error_for_status()?;
666
667 Ok(())
668 }
669
670 #[doc = r#"Creates a comment in a discussion thread by ID"#]
671 pub async fn comment_create(
672 &self,
673 thread_id: base64uuid::Base64Uuid,
674 payload: models::NewComment,
675 ) -> Result<models::Comment> {
676 let mut builder = self.request(
677 Method::POST,
678 &format!("/api/threads/{threadId}/comments", threadId = thread_id,),
679 )?;
680 builder = builder.json(&payload);
681 let response = builder.send().await?.error_for_status()?.json().await?;
682
683 Ok(response)
684 }
685
686 #[doc = r#"Reopens a discussion thread by ID"#]
687 pub async fn thread_reopen(&self, thread_id: base64uuid::Base64Uuid) -> Result<models::Thread> {
688 let mut builder = self.request(
689 Method::POST,
690 &format!("/api/threads/{threadId}/reopen", threadId = thread_id,),
691 )?;
692 let response = builder.send().await?.error_for_status()?.json().await?;
693
694 Ok(response)
695 }
696
697 #[doc = r#"Resolves a discussion thread by ID"#]
698 pub async fn thread_resolve(
699 &self,
700 thread_id: base64uuid::Base64Uuid,
701 ) -> Result<models::Thread> {
702 let mut builder = self.request(
703 Method::POST,
704 &format!("/api/threads/{threadId}/resolve", threadId = thread_id,),
705 )?;
706 let response = builder.send().await?.error_for_status()?.json().await?;
707
708 Ok(response)
709 }
710
711 #[doc = r#"Retrieves a list of all API tokens"#]
712 pub async fn token_list(
713 &self,
714 sort_by: Option<&str>,
715 sort_direction: Option<&str>,
716 page: Option<i32>,
717 limit: Option<i32>,
718 ) -> Result<Vec<models::TokenSummary>> {
719 let mut builder = self.request(Method::GET, "/api/tokens")?;
720 if let Some(sort_by) = sort_by {
721 builder = builder.query(&[("sort_by", sort_by)]);
722 }
723 if let Some(sort_direction) = sort_direction {
724 builder = builder.query(&[("sort_direction", sort_direction)]);
725 }
726 if let Some(page) = page {
727 builder = builder.query(&[("page", page)]);
728 }
729 if let Some(limit) = limit {
730 builder = builder.query(&[("limit", limit)]);
731 }
732 let response = builder.send().await?.error_for_status()?.json().await?;
733
734 Ok(response)
735 }
736
737 #[doc = r#"Creates a new token"#]
738 pub async fn token_create(&self, payload: models::NewToken) -> Result<models::Token> {
739 let mut builder = self.request(Method::POST, "/api/tokens")?;
740 builder = builder.json(&payload);
741 let response = builder.send().await?.error_for_status()?.json().await?;
742
743 Ok(response)
744 }
745
746 #[doc = r#"Deletes a token"#]
747 pub async fn token_delete(&self, id: base64uuid::Base64Uuid) -> Result<()> {
748 let mut builder = self.request(Method::DELETE, &format!("/api/tokens/{id}", id = id,))?;
749 let response = builder.send().await?.error_for_status()?;
750
751 Ok(())
752 }
753
754 #[doc = r#"Retrieves a trigger from a workspace by its ID"#]
755 pub async fn trigger_get(&self, trigger_id: base64uuid::Base64Uuid) -> Result<models::Trigger> {
756 let mut builder = self.request(
757 Method::GET,
758 &format!("/api/triggers/{triggerId}", triggerId = trigger_id,),
759 )?;
760 let response = builder.send().await?.error_for_status()?.json().await?;
761
762 Ok(response)
763 }
764
765 #[doc = r#"Deletes a trigger from a workspace by its ID"#]
766 pub async fn trigger_delete(&self, trigger_id: base64uuid::Base64Uuid) -> Result<()> {
767 let mut builder = self.request(
768 Method::DELETE,
769 &format!("/api/triggers/{triggerId}", triggerId = trigger_id,),
770 )?;
771 let response = builder.send().await?.error_for_status()?;
772
773 Ok(())
774 }
775
776 #[doc = r#"Invoke a trigger to create a notebook from the associated template"#]
777 pub async fn trigger_invoke(
778 &self,
779 trigger_id: base64uuid::Base64Uuid,
780 secret_key: &str,
781 payload: models::TemplateExpandPayload,
782 ) -> Result<models::TriggerInvokeResponse> {
783 let mut builder = self.request(
784 Method::POST,
785 &format!(
786 "/api/triggers/{triggerId}/{secretKey}",
787 triggerId = trigger_id,
788 secretKey = secret_key,
789 ),
790 )?;
791 builder = builder.json(&payload);
792 let response = builder.send().await?.error_for_status()?.json().await?;
793
794 Ok(response)
795 }
796
797 #[doc = r#"List all workspaces authenticated user has access to"#]
798 pub async fn workspace_list(
799 &self,
800 sort_by: Option<&str>,
801 sort_direction: Option<&str>,
802 ) -> Result<Vec<models::Workspace>> {
803 let mut builder = self.request(Method::GET, "/api/workspaces")?;
804 if let Some(sort_by) = sort_by {
805 builder = builder.query(&[("sort_by", sort_by)]);
806 }
807 if let Some(sort_direction) = sort_direction {
808 builder = builder.query(&[("sort_direction", sort_direction)]);
809 }
810 let response = builder.send().await?.error_for_status()?.json().await?;
811
812 Ok(response)
813 }
814
815 #[doc = r#"Creates a new workspace"#]
816 pub async fn workspace_create(
817 &self,
818 payload: models::NewWorkspace,
819 ) -> Result<models::Workspace> {
820 let mut builder = self.request(Method::POST, "/api/workspaces")?;
821 builder = builder.json(&payload);
822 let response = builder.send().await?.error_for_status()?.json().await?;
823
824 Ok(response)
825 }
826
827 #[doc = r#"Get the workspace details"#]
828 pub async fn workspace_get(
829 &self,
830 workspace_id: base64uuid::Base64Uuid,
831 ) -> Result<models::Workspace> {
832 let mut builder = self.request(
833 Method::GET,
834 &format!("/api/workspaces/{workspaceId}", workspaceId = workspace_id,),
835 )?;
836 let response = builder.send().await?.error_for_status()?.json().await?;
837
838 Ok(response)
839 }
840
841 #[doc = r#"Permanently deletes a specified workspace"#]
842 pub async fn workspace_delete(&self, workspace_id: base64uuid::Base64Uuid) -> Result<()> {
843 let mut builder = self.request(
844 Method::DELETE,
845 &format!("/api/workspaces/{workspaceId}", workspaceId = workspace_id,),
846 )?;
847 let response = builder.send().await?.error_for_status()?;
848
849 Ok(())
850 }
851
852 #[doc = r#"Update workspace settings"#]
853 pub async fn workspace_update(
854 &self,
855 workspace_id: base64uuid::Base64Uuid,
856 payload: models::UpdateWorkspace,
857 ) -> Result<models::Workspace> {
858 let mut builder = self.request(
859 Method::PATCH,
860 &format!("/api/workspaces/{workspaceId}", workspaceId = workspace_id,),
861 )?;
862 builder = builder.json(&payload);
863 let response = builder.send().await?.error_for_status()?.json().await?;
864
865 Ok(response)
866 }
867
868 #[doc = r#"Get all workspace data sources"#]
869 pub async fn data_source_list(
870 &self,
871 workspace_id: base64uuid::Base64Uuid,
872 ) -> Result<Vec<models::DataSource>> {
873 let mut builder = self.request(
874 Method::GET,
875 &format!(
876 "/api/workspaces/{workspaceId}/data_sources",
877 workspaceId = workspace_id,
878 ),
879 )?;
880 let response = builder.send().await?.error_for_status()?.json().await?;
881
882 Ok(response)
883 }
884
885 #[doc = r#"Creates a workspace data source"#]
886 pub async fn data_source_create(
887 &self,
888 workspace_id: base64uuid::Base64Uuid,
889 payload: models::NewDataSource,
890 ) -> Result<models::DataSource> {
891 let mut builder = self.request(
892 Method::POST,
893 &format!(
894 "/api/workspaces/{workspaceId}/data_sources",
895 workspaceId = workspace_id,
896 ),
897 )?;
898 builder = builder.json(&payload);
899 let response = builder.send().await?.error_for_status()?.json().await?;
900
901 Ok(response)
902 }
903
904 #[doc = r#"Get the data source's details"#]
905 pub async fn data_source_get(
906 &self,
907 workspace_id: base64uuid::Base64Uuid,
908 data_source_name: &fiberplane_models::names::Name,
909 ) -> Result<models::DataSource> {
910 let mut builder = self.request(
911 Method::GET,
912 &format!(
913 "/api/workspaces/{workspaceId}/data_sources/{dataSourceName}",
914 workspaceId = workspace_id,
915 dataSourceName = data_source_name,
916 ),
917 )?;
918 let response = builder.send().await?.error_for_status()?.json().await?;
919
920 Ok(response)
921 }
922
923 #[doc = r#"Delete a data source"#]
924 pub async fn data_source_delete(
925 &self,
926 workspace_id: base64uuid::Base64Uuid,
927 data_source_name: &fiberplane_models::names::Name,
928 ) -> Result<()> {
929 let mut builder = self.request(
930 Method::DELETE,
931 &format!(
932 "/api/workspaces/{workspaceId}/data_sources/{dataSourceName}",
933 workspaceId = workspace_id,
934 dataSourceName = data_source_name,
935 ),
936 )?;
937 let response = builder.send().await?.error_for_status()?;
938
939 Ok(())
940 }
941
942 #[doc = r#"Update a data source"#]
943 pub async fn data_source_update(
944 &self,
945 workspace_id: base64uuid::Base64Uuid,
946 data_source_name: &fiberplane_models::names::Name,
947 payload: models::UpdateDataSource,
948 ) -> Result<models::DataSource> {
949 let mut builder = self.request(
950 Method::PATCH,
951 &format!(
952 "/api/workspaces/{workspaceId}/data_sources/{dataSourceName}",
953 workspaceId = workspace_id,
954 dataSourceName = data_source_name,
955 ),
956 )?;
957 builder = builder.json(&payload);
958 let response = builder.send().await?.error_for_status()?.json().await?;
959
960 Ok(response)
961 }
962
963 #[doc = r#"Get a list of all events matching the query"#]
964 pub async fn event_list(
965 &self,
966 workspace_id: base64uuid::Base64Uuid,
967 occurrence_time_start: fiberplane_models::timestamps::Timestamp,
968 occurrence_time_end: fiberplane_models::timestamps::Timestamp,
969 labels: Option<std::collections::HashMap<String, String>>,
970 sort_by: Option<&str>,
971 sort_direction: Option<&str>,
972 page: Option<i32>,
973 limit: Option<i32>,
974 ) -> Result<Vec<models::Event>> {
975 let mut builder = self.request(
976 Method::GET,
977 &format!(
978 "/api/workspaces/{workspaceId}/events",
979 workspaceId = workspace_id,
980 ),
981 )?;
982 builder = builder.query(&[("occurrence_time_start", occurrence_time_start.to_string())]);
983 builder = builder.query(&[("occurrence_time_end", occurrence_time_end.to_string())]);
984 if let Some(labels) = labels {
985 builder = builder.query(&[("labels", serde_json::to_string(&labels)?)]);
986 }
987 if let Some(sort_by) = sort_by {
988 builder = builder.query(&[("sort_by", sort_by)]);
989 }
990 if let Some(sort_direction) = sort_direction {
991 builder = builder.query(&[("sort_direction", sort_direction)]);
992 }
993 if let Some(page) = page {
994 builder = builder.query(&[("page", page)]);
995 }
996 if let Some(limit) = limit {
997 builder = builder.query(&[("limit", limit)]);
998 }
999 let response = builder.send().await?.error_for_status()?.json().await?;
1000
1001 Ok(response)
1002 }
1003
1004 #[doc = r#"Creates a new event"#]
1005 pub async fn event_create(
1006 &self,
1007 workspace_id: base64uuid::Base64Uuid,
1008 payload: models::NewEvent,
1009 ) -> Result<models::Event> {
1010 let mut builder = self.request(
1011 Method::POST,
1012 &format!(
1013 "/api/workspaces/{workspaceId}/events",
1014 workspaceId = workspace_id,
1015 ),
1016 )?;
1017 builder = builder.json(&payload);
1018 let response = builder.send().await?.error_for_status()?.json().await?;
1019
1020 Ok(response)
1021 }
1022
1023 #[doc = r#"Retrieve all front matter schemas defined in the workspace"#]
1024 pub async fn workspace_front_matter_schema_get(
1025 &self,
1026 workspace_id: base64uuid::Base64Uuid,
1027 ) -> Result<models::WorkspaceFrontMatterSchemas> {
1028 let mut builder = self.request(
1029 Method::GET,
1030 &format!(
1031 "/api/workspaces/{workspaceId}/front_matter_schemas",
1032 workspaceId = workspace_id,
1033 ),
1034 )?;
1035 let response = builder.send().await?.error_for_status()?.json().await?;
1036
1037 Ok(response)
1038 }
1039
1040 #[doc = r#"Retrieve a front matter schema defined in the workspace"#]
1041 pub async fn workspace_front_matter_schema_create(
1042 &self,
1043 workspace_id: base64uuid::Base64Uuid,
1044 payload: models::NewWorkspaceFrontMatterSchema,
1045 ) -> Result<()> {
1046 let mut builder = self.request(
1047 Method::POST,
1048 &format!(
1049 "/api/workspaces/{workspaceId}/front_matter_schemas",
1050 workspaceId = workspace_id,
1051 ),
1052 )?;
1053 builder = builder.json(&payload);
1054 let response = builder.send().await?.error_for_status()?;
1055
1056 Ok(())
1057 }
1058
1059 #[doc = r#"Retrieve a front matter schema defined in the workspace"#]
1060 pub async fn workspace_front_matter_schema_get_by_name(
1061 &self,
1062 workspace_id: base64uuid::Base64Uuid,
1063 front_matter_schema_name: &str,
1064 ) -> Result<models::FrontMatterSchema> {
1065 let mut builder = self.request(
1066 Method::GET,
1067 &format!(
1068 "/api/workspaces/{workspaceId}/front_matter_schemas/{frontMatterSchemaName}",
1069 workspaceId = workspace_id,
1070 frontMatterSchemaName = front_matter_schema_name,
1071 ),
1072 )?;
1073 let response = builder.send().await?.error_for_status()?.json().await?;
1074
1075 Ok(response)
1076 }
1077
1078 #[doc = r#"Delete a front matter schema defined in the workspace"#]
1079 pub async fn workspace_front_matter_schema_delete(
1080 &self,
1081 workspace_id: base64uuid::Base64Uuid,
1082 front_matter_schema_name: &str,
1083 ) -> Result<()> {
1084 let mut builder = self.request(
1085 Method::DELETE,
1086 &format!(
1087 "/api/workspaces/{workspaceId}/front_matter_schemas/{frontMatterSchemaName}",
1088 workspaceId = workspace_id,
1089 frontMatterSchemaName = front_matter_schema_name,
1090 ),
1091 )?;
1092 let response = builder.send().await?.error_for_status()?;
1093
1094 Ok(())
1095 }
1096
1097 #[doc = r#"Get a list of al integrations and their status for the specified workspace"#]
1098 pub async fn integrations_get_by_workspace(
1099 &self,
1100 workspace_id: base64uuid::Base64Uuid,
1101 ) -> Result<Vec<models::WorkspaceIntegrationSummary>> {
1102 let mut builder = self.request(
1103 Method::GET,
1104 &format!(
1105 "/api/workspaces/{workspaceId}/integrations",
1106 workspaceId = workspace_id,
1107 ),
1108 )?;
1109 let response = builder.send().await?.error_for_status()?.json().await?;
1110
1111 Ok(response)
1112 }
1113
1114 #[doc = r#"Retrieves a list of pending workspace invitations"#]
1115 pub async fn workspace_invite_get(
1116 &self,
1117 workspace_id: base64uuid::Base64Uuid,
1118 sort_by: Option<&str>,
1119 sort_direction: Option<&str>,
1120 page: Option<i32>,
1121 limit: Option<i32>,
1122 ) -> Result<Vec<models::WorkspaceInvite>> {
1123 let mut builder = self.request(
1124 Method::GET,
1125 &format!(
1126 "/api/workspaces/{workspaceId}/invitations",
1127 workspaceId = workspace_id,
1128 ),
1129 )?;
1130 if let Some(sort_by) = sort_by {
1131 builder = builder.query(&[("sort_by", sort_by)]);
1132 }
1133 if let Some(sort_direction) = sort_direction {
1134 builder = builder.query(&[("sort_direction", sort_direction)]);
1135 }
1136 if let Some(page) = page {
1137 builder = builder.query(&[("page", page)]);
1138 }
1139 if let Some(limit) = limit {
1140 builder = builder.query(&[("limit", limit)]);
1141 }
1142 let response = builder.send().await?.error_for_status()?.json().await?;
1143
1144 Ok(response)
1145 }
1146
1147 #[doc = r#"Invites a user to a workspace"#]
1148 pub async fn workspace_invite_create(
1149 &self,
1150 workspace_id: base64uuid::Base64Uuid,
1151 payload: models::NewWorkspaceInvite,
1152 ) -> Result<models::WorkspaceInviteResponse> {
1153 let mut builder = self.request(
1154 Method::POST,
1155 &format!(
1156 "/api/workspaces/{workspaceId}/invitations",
1157 workspaceId = workspace_id,
1158 ),
1159 )?;
1160 builder = builder.json(&payload);
1161 let response = builder.send().await?.error_for_status()?.json().await?;
1162
1163 Ok(response)
1164 }
1165
1166 #[doc = r#"Retrieve all label keys"#]
1167 pub async fn label_keys_list(
1168 &self,
1169 workspace_id: base64uuid::Base64Uuid,
1170 prefix: Option<&str>,
1171 ) -> Result<Vec<String>> {
1172 let mut builder = self.request(
1173 Method::GET,
1174 &format!(
1175 "/api/workspaces/{workspaceId}/labels/keys",
1176 workspaceId = workspace_id,
1177 ),
1178 )?;
1179 if let Some(prefix) = prefix {
1180 builder = builder.query(&[("prefix", prefix)]);
1181 }
1182 let response = builder.send().await?.error_for_status()?.json().await?;
1183
1184 Ok(response)
1185 }
1186
1187 #[doc = r#"Retrieve all label values"#]
1188 pub async fn label_values_list(
1189 &self,
1190 workspace_id: base64uuid::Base64Uuid,
1191 label_key: &str,
1192 prefix: Option<&str>,
1193 ) -> Result<Vec<String>> {
1194 let mut builder = self.request(
1195 Method::GET,
1196 &format!(
1197 "/api/workspaces/{workspaceId}/labels/values/{labelKey}",
1198 workspaceId = workspace_id,
1199 labelKey = label_key,
1200 ),
1201 )?;
1202 if let Some(prefix) = prefix {
1203 builder = builder.query(&[("prefix", prefix)]);
1204 }
1205 let response = builder.send().await?.error_for_status()?.json().await?;
1206
1207 Ok(response)
1208 }
1209
1210 #[doc = r#"Leaves a workspace"#]
1211 pub async fn workspace_leave(&self, workspace_id: base64uuid::Base64Uuid) -> Result<()> {
1212 let mut builder = self.request(
1213 Method::POST,
1214 &format!(
1215 "/api/workspaces/{workspaceId}/leave",
1216 workspaceId = workspace_id,
1217 ),
1218 )?;
1219 let response = builder.send().await?.error_for_status()?;
1220
1221 Ok(())
1222 }
1223
1224 #[doc = r#"Retrieves all Notebooks available to the workspace"#]
1225 pub async fn notebook_list(
1226 &self,
1227 workspace_id: base64uuid::Base64Uuid,
1228 ) -> Result<Vec<models::NotebookSummary>> {
1229 let mut builder = self.request(
1230 Method::GET,
1231 &format!(
1232 "/api/workspaces/{workspaceId}/notebooks",
1233 workspaceId = workspace_id,
1234 ),
1235 )?;
1236 let response = builder.send().await?.error_for_status()?.json().await?;
1237
1238 Ok(response)
1239 }
1240
1241 #[doc = r#"Create a new notebook"#]
1242 pub async fn notebook_create(
1243 &self,
1244 workspace_id: base64uuid::Base64Uuid,
1245 payload: models::NewNotebook,
1246 ) -> Result<models::Notebook> {
1247 let mut builder = self.request(
1248 Method::POST,
1249 &format!(
1250 "/api/workspaces/{workspaceId}/notebooks",
1251 workspaceId = workspace_id,
1252 ),
1253 )?;
1254 builder = builder.json(&payload);
1255 let response = builder.send().await?.error_for_status()?.json().await?;
1256
1257 Ok(response)
1258 }
1259
1260 #[doc = r#"TODO"#]
1261 pub async fn pagerduty_receiver_list(
1262 &self,
1263 workspace_id: base64uuid::Base64Uuid,
1264 page: Option<i32>,
1265 limit: Option<i32>,
1266 sort_by: Option<&str>,
1267 sort_direction: Option<&str>,
1268 ) -> Result<
1269 models::PagedVec<models::PagerDutyReceiver>,
1270 ApiClientError<models::PagerDutyReceiverListError>,
1271 > {
1272 let path = &format!(
1273 "/api/workspaces/{workspaceId}/pagerduty/receivers",
1274 workspaceId = workspace_id,
1275 );
1276 let mut req = self.request(Method::GET, path)?;
1277
1278 if let Some(page) = page {
1279 req = req.query(&[("page", page)]);
1280 }
1281 if let Some(limit) = limit {
1282 req = req.query(&[("limit", limit)]);
1283 }
1284 if let Some(sort_by) = sort_by {
1285 req = req.query(&[("sort_by", sort_by)]);
1286 }
1287 if let Some(sort_direction) = sort_direction {
1288 req = req.query(&[("sort_direction", sort_direction)]);
1289 }
1290
1291 self.do_req_paged(req).await
1292 }
1293
1294 #[doc = r#"TODO"#]
1295 pub async fn pagerduty_receiver_get(
1296 &self,
1297 workspace_id: base64uuid::Base64Uuid,
1298 pager_duty_receiver_name: &fiberplane_models::names::Name,
1299 ) -> Result<models::PagerDutyReceiver, ApiClientError<models::PagerDutyReceiverGetError>> {
1300 let path = &format!(
1301 "/api/workspaces/{workspaceId}/pagerduty/receivers/{pagerDutyReceiverName}",
1302 workspaceId = workspace_id,
1303 pagerDutyReceiverName = pager_duty_receiver_name,
1304 );
1305 let mut req = self.request(Method::GET, path)?;
1306
1307 self.do_req(req).await
1308 }
1309
1310 #[doc = r#"TODO"#]
1311 pub async fn pagerduty_receiver_create(
1312 &self,
1313 workspace_id: base64uuid::Base64Uuid,
1314 pager_duty_receiver_name: &fiberplane_models::names::Name,
1315 payload: models::NewPagerDutyReceiver,
1316 ) -> Result<models::PagerDutyReceiver, ApiClientError<models::PagerDutyReceiverCreateError>>
1317 {
1318 let path = &format!(
1319 "/api/workspaces/{workspaceId}/pagerduty/receivers/{pagerDutyReceiverName}",
1320 workspaceId = workspace_id,
1321 pagerDutyReceiverName = pager_duty_receiver_name,
1322 );
1323 let mut req = self.request(Method::POST, path)?;
1324
1325 let req = req.json(&payload);
1326
1327 self.do_req(req).await
1328 }
1329
1330 #[doc = r#"TODO"#]
1331 pub async fn pagerduty_receiver_delete(
1332 &self,
1333 workspace_id: base64uuid::Base64Uuid,
1334 pager_duty_receiver_name: &fiberplane_models::names::Name,
1335 ) -> Result<(), ApiClientError<models::PagerDutyReceiverDeleteError>> {
1336 let path = &format!(
1337 "/api/workspaces/{workspaceId}/pagerduty/receivers/{pagerDutyReceiverName}",
1338 workspaceId = workspace_id,
1339 pagerDutyReceiverName = pager_duty_receiver_name,
1340 );
1341 let mut req = self.request(Method::DELETE, path)?;
1342
1343 self.do_req(req).await
1344 }
1345
1346 #[doc = r#"TODO"#]
1347 pub async fn pagerduty_receiver_update(
1348 &self,
1349 workspace_id: base64uuid::Base64Uuid,
1350 pager_duty_receiver_name: &fiberplane_models::names::Name,
1351 payload: models::UpdatePagerDutyReceiver,
1352 ) -> Result<models::PagerDutyReceiver, ApiClientError<models::PagerDutyReceiverUpdateError>>
1353 {
1354 let path = &format!(
1355 "/api/workspaces/{workspaceId}/pagerduty/receivers/{pagerDutyReceiverName}",
1356 workspaceId = workspace_id,
1357 pagerDutyReceiverName = pager_duty_receiver_name,
1358 );
1359 let mut req = self.request(Method::PATCH, path)?;
1360
1361 let req = req.json(&payload);
1362
1363 self.do_req(req).await
1364 }
1365
1366 #[doc = r#"Retrieves a workspace image"#]
1367 pub async fn workspace_picture_get(
1368 &self,
1369 workspace_id: base64uuid::Base64Uuid,
1370 ) -> Result<bytes::Bytes> {
1371 let mut builder = self.request(
1372 Method::GET,
1373 &format!(
1374 "/api/workspaces/{workspaceId}/picture",
1375 workspaceId = workspace_id,
1376 ),
1377 )?;
1378 let response = builder.send().await?.error_for_status()?.bytes().await?;
1379
1380 Ok(response)
1381 }
1382
1383 #[doc = r#"Uploads a workspace image"#]
1384 pub async fn workspace_picture_update(
1385 &self,
1386 workspace_id: base64uuid::Base64Uuid,
1387 payload: models::ProfileUploadData,
1388 ) -> Result<()> {
1389 let mut builder = self.request(
1390 Method::POST,
1391 &format!(
1392 "/api/workspaces/{workspaceId}/picture",
1393 workspaceId = workspace_id,
1394 ),
1395 )?;
1396 builder = builder.form(&payload);
1397 let response = builder.send().await?.error_for_status()?;
1398
1399 Ok(())
1400 }
1401
1402 #[doc = r#"Get all pinned views for the current user"#]
1403 pub async fn pinned_view_get(
1404 &self,
1405 workspace_id: base64uuid::Base64Uuid,
1406 ) -> Result<Vec<models::View>> {
1407 let mut builder = self.request(
1408 Method::GET,
1409 &format!(
1410 "/api/workspaces/{workspaceId}/pinned_views",
1411 workspaceId = workspace_id,
1412 ),
1413 )?;
1414 let response = builder.send().await?.error_for_status()?.json().await?;
1415
1416 Ok(response)
1417 }
1418
1419 #[doc = r#"Add an existing view to the pinned views list"#]
1420 pub async fn pinned_view_add(
1421 &self,
1422 workspace_id: base64uuid::Base64Uuid,
1423 payload: models::PinnedView,
1424 ) -> Result<()> {
1425 let mut builder = self.request(
1426 Method::POST,
1427 &format!(
1428 "/api/workspaces/{workspaceId}/pinned_views",
1429 workspaceId = workspace_id,
1430 ),
1431 )?;
1432 builder = builder.json(&payload);
1433 let response = builder.send().await?.error_for_status()?;
1434
1435 Ok(())
1436 }
1437
1438 #[doc = r#"Remove view from the pinned views list"#]
1439 pub async fn pinned_view_remove(
1440 &self,
1441 workspace_id: base64uuid::Base64Uuid,
1442 view_name: &fiberplane_models::names::Name,
1443 ) -> Result<()> {
1444 let mut builder = self.request(
1445 Method::DELETE,
1446 &format!(
1447 "/api/workspaces/{workspaceId}/pinned_views/{viewName}",
1448 workspaceId = workspace_id,
1449 viewName = view_name,
1450 ),
1451 )?;
1452 let response = builder.send().await?.error_for_status()?;
1453
1454 Ok(())
1455 }
1456
1457 #[doc = r#"List all pinned notebooks for a specific workspace"#]
1458 pub async fn pinned_notebook_list(
1459 &self,
1460 workspace_id: base64uuid::Base64Uuid,
1461 ) -> Result<Vec<models::NotebookSummary>> {
1462 let mut builder = self.request(
1463 Method::GET,
1464 &format!(
1465 "/api/workspaces/{workspaceId}/pinnednotebooks",
1466 workspaceId = workspace_id,
1467 ),
1468 )?;
1469 let response = builder.send().await?.error_for_status()?.json().await?;
1470
1471 Ok(response)
1472 }
1473
1474 #[doc = r#"List all proxies"#]
1475 pub async fn proxy_list(
1476 &self,
1477 workspace_id: base64uuid::Base64Uuid,
1478 ) -> Result<Vec<models::ProxySummary>> {
1479 let mut builder = self.request(
1480 Method::GET,
1481 &format!(
1482 "/api/workspaces/{workspaceId}/proxies",
1483 workspaceId = workspace_id,
1484 ),
1485 )?;
1486 let response = builder.send().await?.error_for_status()?.json().await?;
1487
1488 Ok(response)
1489 }
1490
1491 #[doc = r#"Create a new proxy"#]
1492 pub async fn proxy_create(
1493 &self,
1494 workspace_id: base64uuid::Base64Uuid,
1495 payload: models::NewProxy,
1496 ) -> Result<models::Proxy> {
1497 let mut builder = self.request(
1498 Method::POST,
1499 &format!(
1500 "/api/workspaces/{workspaceId}/proxies",
1501 workspaceId = workspace_id,
1502 ),
1503 )?;
1504 builder = builder.json(&payload);
1505 let response = builder.send().await?.error_for_status()?.json().await?;
1506
1507 Ok(response)
1508 }
1509
1510 #[doc = r#"Retrieve a single proxy"#]
1511 pub async fn proxy_get(
1512 &self,
1513 workspace_id: base64uuid::Base64Uuid,
1514 proxy_name: &fiberplane_models::names::Name,
1515 ) -> Result<models::Proxy> {
1516 let mut builder = self.request(
1517 Method::GET,
1518 &format!(
1519 "/api/workspaces/{workspaceId}/proxies/{proxyName}",
1520 workspaceId = workspace_id,
1521 proxyName = proxy_name,
1522 ),
1523 )?;
1524 let response = builder.send().await?.error_for_status()?.json().await?;
1525
1526 Ok(response)
1527 }
1528
1529 #[doc = r#"Deletes a single proxy"#]
1530 pub async fn proxy_delete(
1531 &self,
1532 workspace_id: base64uuid::Base64Uuid,
1533 proxy_name: &fiberplane_models::names::Name,
1534 ) -> Result<()> {
1535 let mut builder = self.request(
1536 Method::DELETE,
1537 &format!(
1538 "/api/workspaces/{workspaceId}/proxies/{proxyName}",
1539 workspaceId = workspace_id,
1540 proxyName = proxy_name,
1541 ),
1542 )?;
1543 let response = builder.send().await?.error_for_status()?;
1544
1545 Ok(())
1546 }
1547
1548 #[doc = r#"Relays a query to invoke a provider on a remote proxy"#]
1549 pub async fn proxy_relay(
1550 &self,
1551 workspace_id: base64uuid::Base64Uuid,
1552 proxy_name: &fiberplane_models::names::Name,
1553 data_source_name: &fiberplane_models::names::Name,
1554 provider_protocol_version: &str,
1555 payload: Vec<u8>,
1556 ) -> Result<bytes::Bytes> {
1557 let mut builder = self.request(
1558 Method::POST,
1559 &format!("/api/workspaces/{workspaceId}/proxies/{proxyName}/data_sources/{dataSourceName}/relay", workspaceId = workspace_id, proxyName = proxy_name, dataSourceName = data_source_name, )
1560 )?;
1561 builder = builder.body(payload);
1562 let response = builder.send().await?.error_for_status()?.bytes().await?;
1563
1564 Ok(response)
1565 }
1566
1567 #[doc = r#"Relay a query to call 'get_config_schema' from a provider on a remote proxy"#]
1568 pub async fn proxy_config_schema(
1569 &self,
1570 workspace_id: base64uuid::Base64Uuid,
1571 proxy_name: &fiberplane_models::names::Name,
1572 data_source_name: &fiberplane_models::names::Name,
1573 ) -> Result<bytes::Bytes> {
1574 let mut builder = self.request(
1575 Method::GET,
1576 &format!("/api/workspaces/{workspaceId}/proxies/{proxyName}/data_sources/{dataSourceName}/relay/v2/config_schema", workspaceId = workspace_id, proxyName = proxy_name, dataSourceName = data_source_name, )
1577 )?;
1578 let response = builder.send().await?.error_for_status()?.bytes().await?;
1579
1580 Ok(response)
1581 }
1582
1583 #[doc = r#"Relay a query to call 'create_cells' from a provider on a remote proxy"#]
1584 pub async fn proxy_create_cells(
1585 &self,
1586 workspace_id: base64uuid::Base64Uuid,
1587 proxy_name: &fiberplane_models::names::Name,
1588 data_source_name: &fiberplane_models::names::Name,
1589 payload: Vec<u8>,
1590 ) -> Result<bytes::Bytes> {
1591 let mut builder = self.request(
1592 Method::POST,
1593 &format!("/api/workspaces/{workspaceId}/proxies/{proxyName}/data_sources/{dataSourceName}/relay/v2/create_cells", workspaceId = workspace_id, proxyName = proxy_name, dataSourceName = data_source_name, )
1594 )?;
1595 builder = builder.body(payload);
1596 let response = builder.send().await?.error_for_status()?.bytes().await?;
1597
1598 Ok(response)
1599 }
1600
1601 #[doc = r#"Relay a query to call 'extract_data' from a provider on a remote proxy"#]
1602 pub async fn proxy_extract_data(
1603 &self,
1604 workspace_id: base64uuid::Base64Uuid,
1605 proxy_name: &fiberplane_models::names::Name,
1606 data_source_name: &fiberplane_models::names::Name,
1607 payload: Vec<u8>,
1608 ) -> Result<bytes::Bytes> {
1609 let mut builder = self.request(
1610 Method::POST,
1611 &format!("/api/workspaces/{workspaceId}/proxies/{proxyName}/data_sources/{dataSourceName}/relay/v2/extract_data", workspaceId = workspace_id, proxyName = proxy_name, dataSourceName = data_source_name, )
1612 )?;
1613 builder = builder.body(payload);
1614 let response = builder.send().await?.error_for_status()?.bytes().await?;
1615
1616 Ok(response)
1617 }
1618
1619 #[doc = r#"Relays a query to invoke a provider on a remote proxy"#]
1620 pub async fn proxy_invoke(
1621 &self,
1622 workspace_id: base64uuid::Base64Uuid,
1623 proxy_name: &fiberplane_models::names::Name,
1624 data_source_name: &fiberplane_models::names::Name,
1625 payload: Vec<u8>,
1626 ) -> Result<bytes::Bytes> {
1627 let mut builder = self.request(
1628 Method::POST,
1629 &format!("/api/workspaces/{workspaceId}/proxies/{proxyName}/data_sources/{dataSourceName}/relay/v2/invoke", workspaceId = workspace_id, proxyName = proxy_name, dataSourceName = data_source_name, )
1630 )?;
1631 builder = builder.body(payload);
1632 let response = builder.send().await?.error_for_status()?.bytes().await?;
1633
1634 Ok(response)
1635 }
1636
1637 #[doc = r#"Relay a query to call 'get_supported_query_types' from a provider on a remote proxy"#]
1638 pub async fn proxy_supported_query_types(
1639 &self,
1640 workspace_id: base64uuid::Base64Uuid,
1641 proxy_name: &fiberplane_models::names::Name,
1642 data_source_name: &fiberplane_models::names::Name,
1643 ) -> Result<bytes::Bytes> {
1644 let mut builder = self.request(
1645 Method::GET,
1646 &format!("/api/workspaces/{workspaceId}/proxies/{proxyName}/data_sources/{dataSourceName}/relay/v2/supported_query_types", workspaceId = workspace_id, proxyName = proxy_name, dataSourceName = data_source_name, )
1647 )?;
1648 let response = builder.send().await?.error_for_status()?.bytes().await?;
1649
1650 Ok(response)
1651 }
1652
1653 #[doc = r#"Search for notebooks"#]
1654 pub async fn notebook_search(
1655 &self,
1656 workspace_id: base64uuid::Base64Uuid,
1657 sort_by: Option<&str>,
1658 sort_direction: Option<&str>,
1659 payload: models::NotebookSearch,
1660 ) -> Result<Vec<models::NotebookSummary>> {
1661 let mut builder = self.request(
1662 Method::POST,
1663 &format!(
1664 "/api/workspaces/{workspaceId}/search/notebooks",
1665 workspaceId = workspace_id,
1666 ),
1667 )?;
1668 if let Some(sort_by) = sort_by {
1669 builder = builder.query(&[("sort_by", sort_by)]);
1670 }
1671 if let Some(sort_direction) = sort_direction {
1672 builder = builder.query(&[("sort_direction", sort_direction)]);
1673 }
1674 builder = builder.json(&payload);
1675 let response = builder.send().await?.error_for_status()?.json().await?;
1676
1677 Ok(response)
1678 }
1679
1680 #[doc = r#"List the snippets that have been uploaded"#]
1681 pub async fn snippet_list(
1682 &self,
1683 workspace_id: base64uuid::Base64Uuid,
1684 sort_by: Option<&str>,
1685 sort_direction: Option<&str>,
1686 ) -> Result<Vec<models::SnippetSummary>> {
1687 let mut builder = self.request(
1688 Method::GET,
1689 &format!(
1690 "/api/workspaces/{workspaceId}/snippets",
1691 workspaceId = workspace_id,
1692 ),
1693 )?;
1694 if let Some(sort_by) = sort_by {
1695 builder = builder.query(&[("sort_by", sort_by)]);
1696 }
1697 if let Some(sort_direction) = sort_direction {
1698 builder = builder.query(&[("sort_direction", sort_direction)]);
1699 }
1700 let response = builder.send().await?.error_for_status()?.json().await?;
1701
1702 Ok(response)
1703 }
1704
1705 #[doc = r#"Create a new snippet"#]
1706 pub async fn snippet_create(
1707 &self,
1708 workspace_id: base64uuid::Base64Uuid,
1709 payload: models::NewSnippet,
1710 ) -> Result<models::Snippet> {
1711 let mut builder = self.request(
1712 Method::POST,
1713 &format!(
1714 "/api/workspaces/{workspaceId}/snippets",
1715 workspaceId = workspace_id,
1716 ),
1717 )?;
1718 builder = builder.json(&payload);
1719 let response = builder.send().await?.error_for_status()?.json().await?;
1720
1721 Ok(response)
1722 }
1723
1724 #[doc = r#"Retrieves a specified snippet from a workspace"#]
1725 pub async fn snippet_get(
1726 &self,
1727 workspace_id: base64uuid::Base64Uuid,
1728 snippet_name: &fiberplane_models::names::Name,
1729 ) -> Result<models::Snippet> {
1730 let mut builder = self.request(
1731 Method::GET,
1732 &format!(
1733 "/api/workspaces/{workspaceId}/snippets/{snippetName}",
1734 workspaceId = workspace_id,
1735 snippetName = snippet_name,
1736 ),
1737 )?;
1738 let response = builder.send().await?.error_for_status()?.json().await?;
1739
1740 Ok(response)
1741 }
1742
1743 #[doc = r#"Deletes a specified snippet from a workspace"#]
1744 pub async fn snippet_delete(
1745 &self,
1746 workspace_id: base64uuid::Base64Uuid,
1747 snippet_name: &fiberplane_models::names::Name,
1748 ) -> Result<()> {
1749 let mut builder = self.request(
1750 Method::DELETE,
1751 &format!(
1752 "/api/workspaces/{workspaceId}/snippets/{snippetName}",
1753 workspaceId = workspace_id,
1754 snippetName = snippet_name,
1755 ),
1756 )?;
1757 let response = builder.send().await?.error_for_status()?;
1758
1759 Ok(())
1760 }
1761
1762 #[doc = r#"Updates a specified snippet from a workspace"#]
1763 pub async fn snippet_update(
1764 &self,
1765 workspace_id: base64uuid::Base64Uuid,
1766 snippet_name: &fiberplane_models::names::Name,
1767 payload: models::UpdateSnippet,
1768 ) -> Result<models::Snippet> {
1769 let mut builder = self.request(
1770 Method::PATCH,
1771 &format!(
1772 "/api/workspaces/{workspaceId}/snippets/{snippetName}",
1773 workspaceId = workspace_id,
1774 snippetName = snippet_name,
1775 ),
1776 )?;
1777 builder = builder.json(&payload);
1778 let response = builder.send().await?.error_for_status()?.json().await?;
1779
1780 Ok(response)
1781 }
1782
1783 #[doc = r#"Expand the snippet and return the array of cells (without inserting them into a specific notebook)"#]
1784 pub async fn snippet_expand(
1785 &self,
1786 workspace_id: base64uuid::Base64Uuid,
1787 snippet_name: &fiberplane_models::names::Name,
1788 ) -> Result<Vec<models::Cell>> {
1789 let mut builder = self.request(
1790 Method::GET,
1791 &format!(
1792 "/api/workspaces/{workspaceId}/snippets/{snippetName}/expand",
1793 workspaceId = workspace_id,
1794 snippetName = snippet_name,
1795 ),
1796 )?;
1797 let response = builder.send().await?.error_for_status()?.json().await?;
1798
1799 Ok(response)
1800 }
1801
1802 #[doc = r#"Retrieve all the templates that have been uploaded"#]
1803 pub async fn template_list(
1804 &self,
1805 workspace_id: base64uuid::Base64Uuid,
1806 sort_by: Option<&str>,
1807 sort_direction: Option<&str>,
1808 ) -> Result<Vec<models::TemplateSummary>> {
1809 let mut builder = self.request(
1810 Method::GET,
1811 &format!(
1812 "/api/workspaces/{workspaceId}/templates",
1813 workspaceId = workspace_id,
1814 ),
1815 )?;
1816 if let Some(sort_by) = sort_by {
1817 builder = builder.query(&[("sort_by", sort_by)]);
1818 }
1819 if let Some(sort_direction) = sort_direction {
1820 builder = builder.query(&[("sort_direction", sort_direction)]);
1821 }
1822 let response = builder.send().await?.error_for_status()?.json().await?;
1823
1824 Ok(response)
1825 }
1826
1827 #[doc = r#"Create a new template"#]
1828 pub async fn template_create(
1829 &self,
1830 workspace_id: base64uuid::Base64Uuid,
1831 payload: models::NewTemplate,
1832 ) -> Result<models::Template> {
1833 let mut builder = self.request(
1834 Method::POST,
1835 &format!(
1836 "/api/workspaces/{workspaceId}/templates",
1837 workspaceId = workspace_id,
1838 ),
1839 )?;
1840 builder = builder.json(&payload);
1841 let response = builder.send().await?.error_for_status()?.json().await?;
1842
1843 Ok(response)
1844 }
1845
1846 #[doc = r#"Retrieves a specified template"#]
1847 pub async fn template_get(
1848 &self,
1849 workspace_id: base64uuid::Base64Uuid,
1850 template_name: &fiberplane_models::names::Name,
1851 ) -> Result<models::Template> {
1852 let mut builder = self.request(
1853 Method::GET,
1854 &format!(
1855 "/api/workspaces/{workspaceId}/templates/{templateName}",
1856 workspaceId = workspace_id,
1857 templateName = template_name,
1858 ),
1859 )?;
1860 let response = builder.send().await?.error_for_status()?.json().await?;
1861
1862 Ok(response)
1863 }
1864
1865 #[doc = r#"Deletes a specified template"#]
1866 pub async fn template_delete(
1867 &self,
1868 workspace_id: base64uuid::Base64Uuid,
1869 template_name: &fiberplane_models::names::Name,
1870 ) -> Result<()> {
1871 let mut builder = self.request(
1872 Method::DELETE,
1873 &format!(
1874 "/api/workspaces/{workspaceId}/templates/{templateName}",
1875 workspaceId = workspace_id,
1876 templateName = template_name,
1877 ),
1878 )?;
1879 let response = builder.send().await?.error_for_status()?;
1880
1881 Ok(())
1882 }
1883
1884 #[doc = r#"Updates a specified template"#]
1885 pub async fn template_update(
1886 &self,
1887 workspace_id: base64uuid::Base64Uuid,
1888 template_name: &fiberplane_models::names::Name,
1889 payload: models::UpdateTemplate,
1890 ) -> Result<models::Template> {
1891 let mut builder = self.request(
1892 Method::PATCH,
1893 &format!(
1894 "/api/workspaces/{workspaceId}/templates/{templateName}",
1895 workspaceId = workspace_id,
1896 templateName = template_name,
1897 ),
1898 )?;
1899 builder = builder.json(&payload);
1900 let response = builder.send().await?.error_for_status()?.json().await?;
1901
1902 Ok(response)
1903 }
1904
1905 #[doc = r#"Expand the template into a notebook"#]
1906 pub async fn template_expand(
1907 &self,
1908 workspace_id: base64uuid::Base64Uuid,
1909 template_name: &fiberplane_models::names::Name,
1910 payload: models::TemplateExpandPayload,
1911 ) -> Result<models::Notebook> {
1912 let mut builder = self.request(
1913 Method::POST,
1914 &format!(
1915 "/api/workspaces/{workspaceId}/templates/{templateName}/expand",
1916 workspaceId = workspace_id,
1917 templateName = template_name,
1918 ),
1919 )?;
1920 builder = builder.json(&payload);
1921 let response = builder.send().await?.error_for_status()?.json().await?;
1922
1923 Ok(response)
1924 }
1925
1926 #[doc = r#"List all created triggers in the workspace"#]
1927 pub async fn trigger_list(
1928 &self,
1929 workspace_id: base64uuid::Base64Uuid,
1930 ) -> Result<Vec<models::Trigger>> {
1931 let mut builder = self.request(
1932 Method::GET,
1933 &format!(
1934 "/api/workspaces/{workspaceId}/triggers",
1935 workspaceId = workspace_id,
1936 ),
1937 )?;
1938 let response = builder.send().await?.error_for_status()?.json().await?;
1939
1940 Ok(response)
1941 }
1942
1943 #[doc = r#"Creates a new trigger for a template"#]
1944 pub async fn trigger_create(
1945 &self,
1946 workspace_id: base64uuid::Base64Uuid,
1947 payload: models::NewTrigger,
1948 ) -> Result<models::Trigger> {
1949 let mut builder = self.request(
1950 Method::POST,
1951 &format!(
1952 "/api/workspaces/{workspaceId}/triggers",
1953 workspaceId = workspace_id,
1954 ),
1955 )?;
1956 builder = builder.json(&payload);
1957 let response = builder.send().await?.error_for_status()?.json().await?;
1958
1959 Ok(response)
1960 }
1961
1962 #[doc = r#"List all users for a workspace"#]
1963 pub async fn workspace_user_list(
1964 &self,
1965 workspace_id: base64uuid::Base64Uuid,
1966 sort_by: Option<&str>,
1967 sort_direction: Option<&str>,
1968 ) -> Result<Vec<models::Membership>> {
1969 let mut builder = self.request(
1970 Method::GET,
1971 &format!(
1972 "/api/workspaces/{workspaceId}/users",
1973 workspaceId = workspace_id,
1974 ),
1975 )?;
1976 if let Some(sort_by) = sort_by {
1977 builder = builder.query(&[("sort_by", sort_by)]);
1978 }
1979 if let Some(sort_direction) = sort_direction {
1980 builder = builder.query(&[("sort_direction", sort_direction)]);
1981 }
1982 let response = builder.send().await?.error_for_status()?.json().await?;
1983
1984 Ok(response)
1985 }
1986
1987 #[doc = r#"Removes a user from the workspace"#]
1988 pub async fn workspace_user_remove(
1989 &self,
1990 workspace_id: base64uuid::Base64Uuid,
1991 user_id: base64uuid::Base64Uuid,
1992 ) -> Result<()> {
1993 let mut builder = self.request(
1994 Method::DELETE,
1995 &format!(
1996 "/api/workspaces/{workspaceId}/users/{userId}",
1997 workspaceId = workspace_id,
1998 userId = user_id,
1999 ),
2000 )?;
2001 let response = builder.send().await?.error_for_status()?;
2002
2003 Ok(())
2004 }
2005
2006 #[doc = r#"Updates the user within a workspace"#]
2007 pub async fn workspace_user_update(
2008 &self,
2009 workspace_id: base64uuid::Base64Uuid,
2010 user_id: base64uuid::Base64Uuid,
2011 payload: models::UpdateWorkspaceUser,
2012 ) -> Result<models::User> {
2013 let mut builder = self.request(
2014 Method::PATCH,
2015 &format!(
2016 "/api/workspaces/{workspaceId}/users/{userId}",
2017 workspaceId = workspace_id,
2018 userId = user_id,
2019 ),
2020 )?;
2021 builder = builder.json(&payload);
2022 let response = builder.send().await?.error_for_status()?.json().await?;
2023
2024 Ok(response)
2025 }
2026
2027 #[doc = r#"Retrieves all views"#]
2028 pub async fn view_list(
2029 &self,
2030 workspace_id: base64uuid::Base64Uuid,
2031 sort_by: Option<&str>,
2032 sort_direction: Option<&str>,
2033 page: Option<i32>,
2034 limit: Option<i32>,
2035 ) -> Result<Vec<models::View>> {
2036 let mut builder = self.request(
2037 Method::GET,
2038 &format!(
2039 "/api/workspaces/{workspaceId}/views",
2040 workspaceId = workspace_id,
2041 ),
2042 )?;
2043 if let Some(sort_by) = sort_by {
2044 builder = builder.query(&[("sort_by", sort_by)]);
2045 }
2046 if let Some(sort_direction) = sort_direction {
2047 builder = builder.query(&[("sort_direction", sort_direction)]);
2048 }
2049 if let Some(page) = page {
2050 builder = builder.query(&[("page", page)]);
2051 }
2052 if let Some(limit) = limit {
2053 builder = builder.query(&[("limit", limit)]);
2054 }
2055 let response = builder.send().await?.error_for_status()?.json().await?;
2056
2057 Ok(response)
2058 }
2059
2060 #[doc = r#"Creates a new view"#]
2061 pub async fn view_create(
2062 &self,
2063 workspace_id: base64uuid::Base64Uuid,
2064 payload: models::NewView,
2065 ) -> Result<models::View> {
2066 let mut builder = self.request(
2067 Method::POST,
2068 &format!(
2069 "/api/workspaces/{workspaceId}/views",
2070 workspaceId = workspace_id,
2071 ),
2072 )?;
2073 builder = builder.json(&payload);
2074 let response = builder.send().await?.error_for_status()?.json().await?;
2075
2076 Ok(response)
2077 }
2078
2079 #[doc = r#"Retrieves a single view"#]
2080 pub async fn view_get(
2081 &self,
2082 workspace_id: base64uuid::Base64Uuid,
2083 view_name: &fiberplane_models::names::Name,
2084 ) -> Result<models::View> {
2085 let mut builder = self.request(
2086 Method::GET,
2087 &format!(
2088 "/api/workspaces/{workspaceId}/views/{viewName}",
2089 workspaceId = workspace_id,
2090 viewName = view_name,
2091 ),
2092 )?;
2093 let response = builder.send().await?.error_for_status()?.json().await?;
2094
2095 Ok(response)
2096 }
2097
2098 #[doc = r#"Deletes an existing view"#]
2099 pub async fn view_delete(
2100 &self,
2101 workspace_id: base64uuid::Base64Uuid,
2102 view_name: &fiberplane_models::names::Name,
2103 ) -> Result<()> {
2104 let mut builder = self.request(
2105 Method::DELETE,
2106 &format!(
2107 "/api/workspaces/{workspaceId}/views/{viewName}",
2108 workspaceId = workspace_id,
2109 viewName = view_name,
2110 ),
2111 )?;
2112 let response = builder.send().await?.error_for_status()?;
2113
2114 Ok(())
2115 }
2116
2117 #[doc = r#"Updates an existing view"#]
2118 pub async fn view_update(
2119 &self,
2120 workspace_id: base64uuid::Base64Uuid,
2121 view_name: &fiberplane_models::names::Name,
2122 payload: models::UpdateView,
2123 ) -> Result<models::View> {
2124 let mut builder = self.request(
2125 Method::PATCH,
2126 &format!(
2127 "/api/workspaces/{workspaceId}/views/{viewName}",
2128 workspaceId = workspace_id,
2129 viewName = view_name,
2130 ),
2131 )?;
2132 builder = builder.json(&payload);
2133 let response = builder.send().await?.error_for_status()?.json().await?;
2134
2135 Ok(response)
2136 }
2137
2138 #[doc = r#"Retrieve all webhooks for a specific workspace"#]
2139 pub async fn webhook_list(
2140 &self,
2141 workspace_id: base64uuid::Base64Uuid,
2142 page: Option<i32>,
2143 limit: Option<i32>,
2144 ) -> Result<Vec<models::Webhook>> {
2145 let mut builder = self.request(
2146 Method::GET,
2147 &format!(
2148 "/api/workspaces/{workspaceId}/webhooks",
2149 workspaceId = workspace_id,
2150 ),
2151 )?;
2152 if let Some(page) = page {
2153 builder = builder.query(&[("page", page)]);
2154 }
2155 if let Some(limit) = limit {
2156 builder = builder.query(&[("limit", limit)]);
2157 }
2158 let response = builder.send().await?.error_for_status()?.json().await?;
2159
2160 Ok(response)
2161 }
2162
2163 #[doc = r#"Create a new webhook. Upon execution of this route, a test event ("ping") will be sent to the endpoint.
2164If sending the ping event fails, the webhook will still be created, but it will be disabled.
2165Please check the response of this endpoint to see whenever `enabled` = `false`,
2166and if that is the case, check the latest delivery to see why. Once the endpoint has been fixed, you
2167can re-deliver the ping payload and if that works, manually re-enable the webhook again.
2168"#]
2169 pub async fn webhook_create(
2170 &self,
2171 workspace_id: base64uuid::Base64Uuid,
2172 payload: models::NewWebhook,
2173 ) -> Result<models::Webhook> {
2174 let mut builder = self.request(
2175 Method::POST,
2176 &format!(
2177 "/api/workspaces/{workspaceId}/webhooks",
2178 workspaceId = workspace_id,
2179 ),
2180 )?;
2181 builder = builder.json(&payload);
2182 let response = builder.send().await?.error_for_status()?.json().await?;
2183
2184 Ok(response)
2185 }
2186
2187 #[doc = r#"Deletes an existing webhook"#]
2188 pub async fn webhook_delete(
2189 &self,
2190 workspace_id: base64uuid::Base64Uuid,
2191 webhook_id: base64uuid::Base64Uuid,
2192 ) -> Result<()> {
2193 let mut builder = self.request(
2194 Method::DELETE,
2195 &format!(
2196 "/api/workspaces/{workspaceId}/webhooks/{webhookId}",
2197 workspaceId = workspace_id,
2198 webhookId = webhook_id,
2199 ),
2200 )?;
2201 let response = builder.send().await?.error_for_status()?;
2202
2203 Ok(())
2204 }
2205
2206 #[doc = r#"Updates an existing webhook. Upon execution of this route, a test event ("ping") will be sent to the endpoint.
2207If sending the ping event fails, the webhook will still be updated, but will be disabled.
2208Please check the response of this endpoint to see whenever `enabled` = `false`, and if that is the case
2209(and not manually requested), check the latest delivery to see why. Once the endpoint has been fixed, you
2210can re-deliver the ping payload and if that works, manually re-enable the webhook again.
2211"#]
2212 pub async fn webhook_update(
2213 &self,
2214 workspace_id: base64uuid::Base64Uuid,
2215 webhook_id: base64uuid::Base64Uuid,
2216 payload: models::UpdateWebhook,
2217 ) -> Result<models::Webhook> {
2218 let mut builder = self.request(
2219 Method::PATCH,
2220 &format!(
2221 "/api/workspaces/{workspaceId}/webhooks/{webhookId}",
2222 workspaceId = workspace_id,
2223 webhookId = webhook_id,
2224 ),
2225 )?;
2226 builder = builder.json(&payload);
2227 let response = builder.send().await?.error_for_status()?.json().await?;
2228
2229 Ok(response)
2230 }
2231
2232 #[doc = r#"Retrieve a list of deliveries for a specific webhook"#]
2233 pub async fn webhook_delivery_list(
2234 &self,
2235 workspace_id: base64uuid::Base64Uuid,
2236 webhook_id: base64uuid::Base64Uuid,
2237 page: Option<i32>,
2238 limit: Option<i32>,
2239 ) -> Result<Vec<models::WebhookDeliverySummary>> {
2240 let mut builder = self.request(
2241 Method::GET,
2242 &format!(
2243 "/api/workspaces/{workspaceId}/webhooks/{webhookId}/deliveries",
2244 workspaceId = workspace_id,
2245 webhookId = webhook_id,
2246 ),
2247 )?;
2248 if let Some(page) = page {
2249 builder = builder.query(&[("page", page)]);
2250 }
2251 if let Some(limit) = limit {
2252 builder = builder.query(&[("limit", limit)]);
2253 }
2254 let response = builder.send().await?.error_for_status()?.json().await?;
2255
2256 Ok(response)
2257 }
2258
2259 #[doc = r#"Retrieve information about a specific delivery for a specific webhook"#]
2260 pub async fn webhook_delivery_get(
2261 &self,
2262 workspace_id: base64uuid::Base64Uuid,
2263 webhook_id: base64uuid::Base64Uuid,
2264 delivery_id: base64uuid::Base64Uuid,
2265 ) -> Result<models::WebhookDelivery> {
2266 let mut builder = self.request(
2267 Method::GET,
2268 &format!(
2269 "/api/workspaces/{workspaceId}/webhooks/{webhookId}/deliveries/{deliveryId}",
2270 workspaceId = workspace_id,
2271 webhookId = webhook_id,
2272 deliveryId = delivery_id,
2273 ),
2274 )?;
2275 let response = builder.send().await?.error_for_status()?.json().await?;
2276
2277 Ok(response)
2278 }
2279
2280 #[doc = r#"Resend a specific delivery"#]
2281 pub async fn webhook_delivery_resend(
2282 &self,
2283 workspace_id: base64uuid::Base64Uuid,
2284 webhook_id: base64uuid::Base64Uuid,
2285 delivery_id: base64uuid::Base64Uuid,
2286 ) -> Result<()> {
2287 let mut builder = self.request(
2288 Method::POST,
2289 &format!(
2290 "/api/workspaces/{workspaceId}/webhooks/{webhookId}/deliveries/{deliveryId}/resend",
2291 workspaceId = workspace_id,
2292 webhookId = webhook_id,
2293 deliveryId = delivery_id,
2294 ),
2295 )?;
2296 let response = builder.send().await?.error_for_status()?;
2297
2298 Ok(())
2299 }
2300}