anthropic_api/admin/workspace.rs
1//! # Workspaces Admin API
2//!
3//! This module provides a Rust interface to Anthropic's Admin API for managing workspaces and workspace members, which allows you to
4//! list, get, create, update, and archive workspaces, as well as manage workspace members.
5//!
6//! ## Key Features
7//!
8//! - List all workspaces with pagination and filtering support
9//! - Get detailed information about a specific workspace
10//! - Create new workspaces
11//! - Update workspace properties like name
12//! - Archive workspaces
13//! - List all members of a workspace with pagination support
14//! - Get detailed information about a specific workspace member
15//! - Add new members to a workspace
16//! - Update workspace member roles
17//! - Remove members from a workspace
18//!
19//! ## Basic Usage
20//!
21//! ```no_run
22//! use anthropic_api::{admin::workspace::*, Credentials};
23//!
24//! #[tokio::main]
25//! async fn main() {
26//! let credentials = Credentials::from_env();
27//!
28//! // List workspaces
29//! let workspaces = WorkspaceList::builder()
30//! .credentials(credentials.clone())
31//! .create()
32//! .await
33//! .unwrap();
34//!
35//! println!("Available workspaces: {:?}", workspaces.data);
36//!
37//! // Get a specific workspace
38//! if let Some(workspace) = workspaces.data.first() {
39//! let workspace_details = Workspace::builder(&workspace.id)
40//! .credentials(credentials.clone())
41//! .create()
42//! .await
43//! .unwrap();
44//!
45//! println!("Workspace details: {:?}", workspace_details);
46//!
47//! // List members of the workspace
48//! let members = WorkspaceMemberList::builder(&workspace.id)
49//! .credentials(credentials.clone())
50//! .create()
51//! .await
52//! .unwrap();
53//!
54//! println!("Workspace members: {:?}", members.data);
55//! }
56//! }
57//! ```
58
59use crate::{anthropic_request_json, ApiResponseOrError, Credentials};
60use derive_builder::Builder;
61use reqwest::Method;
62use serde::{Deserialize, Serialize};
63
64/// A workspace available through the Anthropic Admin API.
65#[derive(Deserialize, Debug, Clone, Eq, PartialEq)]
66pub struct Workspace {
67 /// Unique workspace identifier
68 pub id: String,
69 /// Name of the workspace
70 pub name: String,
71 /// RFC 3339 datetime string representing the time at which the workspace was created
72 pub created_at: String,
73 /// RFC 3339 datetime string indicating when the workspace was archived, or null if the workspace is not archived
74 pub archived_at: Option<String>,
75 /// Hex color code representing the workspace in the Anthropic Console
76 pub display_color: String,
77 /// Object type (always "workspace" for Workspaces)
78 #[serde(rename = "type")]
79 pub workspace_type: String,
80}
81
82/// Response from the List Workspaces API.
83#[derive(Deserialize, Debug, Clone, Eq, PartialEq)]
84pub struct WorkspaceList {
85 /// List of available workspaces
86 pub data: Vec<Workspace>,
87 /// First ID in the data list (for pagination)
88 pub first_id: Option<String>,
89 /// Last ID in the data list (for pagination)
90 pub last_id: Option<String>,
91 /// Indicates if there are more results in the requested page direction
92 pub has_more: bool,
93}
94
95/// Request parameters for listing workspaces.
96#[derive(Serialize, Builder, Debug, Clone)]
97#[builder(derive(Clone, Debug, PartialEq))]
98#[builder(pattern = "owned")]
99#[builder(name = "WorkspaceListBuilder")]
100#[builder(setter(strip_option, into))]
101pub struct WorkspaceListRequest {
102 /// Whether to include workspaces that have been archived in the response
103 #[builder(default)]
104 #[serde(skip_serializing_if = "Option::is_none")]
105 pub include_archived: Option<bool>,
106
107 /// ID of the object to use as a cursor for pagination (previous page)
108 #[builder(default)]
109 #[serde(skip_serializing_if = "Option::is_none")]
110 pub before_id: Option<String>,
111
112 /// ID of the object to use as a cursor for pagination (next page)
113 #[builder(default)]
114 #[serde(skip_serializing_if = "Option::is_none")]
115 pub after_id: Option<String>,
116
117 /// Number of items to return per page (1-1000)
118 #[builder(default)]
119 #[serde(skip_serializing_if = "Option::is_none")]
120 pub limit: Option<u32>,
121
122 /// Credentials for authentication (not serialized)
123 #[serde(skip_serializing)]
124 #[builder(default)]
125 pub credentials: Option<Credentials>,
126}
127
128/// Request parameters for getting a specific workspace.
129#[derive(Serialize, Builder, Debug, Clone)]
130#[builder(derive(Clone, Debug, PartialEq))]
131#[builder(pattern = "owned")]
132#[builder(name = "WorkspaceBuilder")]
133#[builder(setter(strip_option, into))]
134pub struct WorkspaceRequest {
135 /// Workspace identifier
136 pub workspace_id: String,
137
138 /// Credentials for authentication (not serialized)
139 #[serde(skip_serializing)]
140 #[builder(default)]
141 pub credentials: Option<Credentials>,
142}
143
144/// Request parameters for creating a workspace.
145#[derive(Serialize, Builder, Debug, Clone)]
146#[builder(derive(Clone, Debug, PartialEq))]
147#[builder(pattern = "owned")]
148#[builder(name = "WorkspaceCreateBuilder")]
149#[builder(setter(strip_option, into))]
150pub struct WorkspaceCreateRequest {
151 /// Name of the workspace
152 pub name: String,
153
154 /// Credentials for authentication (not serialized)
155 #[serde(skip_serializing)]
156 #[builder(default)]
157 pub credentials: Option<Credentials>,
158}
159
160/// Request parameters for updating a workspace.
161#[derive(Serialize, Builder, Debug, Clone)]
162#[builder(derive(Clone, Debug, PartialEq))]
163#[builder(pattern = "owned")]
164#[builder(name = "WorkspaceUpdateBuilder")]
165#[builder(setter(strip_option, into))]
166pub struct WorkspaceUpdateRequest {
167 /// Workspace identifier (not serialized)
168 #[serde(skip_serializing)]
169 pub workspace_id: String,
170
171 /// New name for the workspace
172 pub name: String,
173
174 /// Credentials for authentication (not serialized)
175 #[serde(skip_serializing)]
176 #[builder(default)]
177 pub credentials: Option<Credentials>,
178}
179
180/// Request parameters for archiving a workspace.
181#[derive(Serialize, Builder, Debug, Clone)]
182#[builder(derive(Clone, Debug, PartialEq))]
183#[builder(pattern = "owned")]
184#[builder(name = "WorkspaceArchiveBuilder")]
185#[builder(setter(strip_option, into))]
186pub struct WorkspaceArchiveRequest {
187 /// Workspace identifier
188 pub workspace_id: String,
189
190 /// Credentials for authentication (not serialized)
191 #[serde(skip_serializing)]
192 #[builder(default)]
193 pub credentials: Option<Credentials>,
194}
195
196impl WorkspaceList {
197 /// Creates a builder for listing workspaces.
198 ///
199 /// # Example
200 ///
201 /// ```no_run
202 /// # use anthropic_api::{admin::workspace::*, Credentials};
203 /// # #[tokio::main]
204 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
205 /// let credentials = Credentials::from_env();
206 ///
207 /// let workspaces = WorkspaceList::builder()
208 /// .credentials(credentials)
209 /// .limit(10u32)
210 /// .create()
211 /// .await?;
212 /// # Ok(())
213 /// # }
214 /// ```
215 pub fn builder() -> WorkspaceListBuilder {
216 WorkspaceListBuilder::create_empty()
217 }
218
219 /// Lists available workspaces with the given request parameters.
220 ///
221 /// # Example
222 ///
223 /// ```no_run
224 /// # use anthropic_api::{admin::workspace::*, Credentials};
225 /// # #[tokio::main]
226 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
227 /// let credentials = Credentials::from_env();
228 /// let request = WorkspaceListRequest {
229 /// include_archived: Some(true),
230 /// before_id: None,
231 /// after_id: None,
232 /// limit: Some(20),
233 /// credentials: Some(credentials),
234 /// };
235 ///
236 /// let workspaces = WorkspaceList::create(request).await?;
237 /// # Ok(())
238 /// # }
239 /// ```
240 pub async fn create(request: WorkspaceListRequest) -> ApiResponseOrError<Self> {
241 let credentials_opt = request.credentials.clone();
242
243 // Build query parameters
244 let mut query_params = Vec::new();
245 if let Some(include_archived) = request.include_archived {
246 query_params.push(("include_archived", include_archived.to_string()));
247 }
248 if let Some(before_id) = &request.before_id {
249 query_params.push(("before_id", before_id.clone()));
250 }
251 if let Some(after_id) = &request.after_id {
252 query_params.push(("after_id", after_id.clone()));
253 }
254 if let Some(limit) = request.limit {
255 query_params.push(("limit", limit.to_string()));
256 }
257
258 anthropic_request_json(
259 Method::GET,
260 "organizations/workspaces",
261 |r| r.query(&query_params),
262 credentials_opt,
263 )
264 .await
265 }
266}
267
268impl Workspace {
269 /// Creates a builder for getting a specific workspace.
270 ///
271 /// # Example
272 ///
273 /// ```no_run
274 /// # use anthropic_api::{admin::workspace::*, Credentials};
275 /// # #[tokio::main]
276 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
277 /// let credentials = Credentials::from_env();
278 ///
279 /// let workspace = Workspace::builder("workspace_123456789")
280 /// .credentials(credentials)
281 /// .create()
282 /// .await?;
283 /// # Ok(())
284 /// # }
285 /// ```
286 pub fn builder(workspace_id: impl Into<String>) -> WorkspaceBuilder {
287 WorkspaceBuilder::create_empty().workspace_id(workspace_id)
288 }
289
290 /// Gets information about a specific workspace.
291 ///
292 /// # Example
293 ///
294 /// ```no_run
295 /// # use anthropic_api::{admin::workspace::*, Credentials};
296 /// # #[tokio::main]
297 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
298 /// let credentials = Credentials::from_env();
299 /// let request = WorkspaceRequest {
300 /// workspace_id: "workspace_123456789".to_string(),
301 /// credentials: Some(credentials),
302 /// };
303 ///
304 /// let workspace = Workspace::create(request).await?;
305 /// # Ok(())
306 /// # }
307 /// ```
308 pub async fn create(request: WorkspaceRequest) -> ApiResponseOrError<Self> {
309 let credentials_opt = request.credentials.clone();
310 let route = format!("organizations/workspaces/{}", request.workspace_id);
311
312 anthropic_request_json(Method::GET, &route, |r| r, credentials_opt).await
313 }
314
315 /// Creates a builder for creating a new workspace.
316 ///
317 /// # Example
318 ///
319 /// ```no_run
320 /// # use anthropic_api::{admin::workspace::*, Credentials};
321 /// # #[tokio::main]
322 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
323 /// let credentials = Credentials::from_env();
324 ///
325 /// let new_workspace = Workspace::create_builder()
326 /// .credentials(credentials)
327 /// .name("My New Workspace")
328 /// .create()
329 /// .await?;
330 /// # Ok(())
331 /// # }
332 /// ```
333 pub fn create_builder() -> WorkspaceCreateBuilder {
334 WorkspaceCreateBuilder::create_empty()
335 }
336
337 /// Creates a new workspace with the given request parameters.
338 ///
339 /// # Example
340 ///
341 /// ```no_run
342 /// # use anthropic_api::{admin::workspace::*, Credentials};
343 /// # #[tokio::main]
344 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
345 /// let credentials = Credentials::from_env();
346 /// let request = WorkspaceCreateRequest {
347 /// name: "My New Workspace".to_string(),
348 /// credentials: Some(credentials),
349 /// };
350 ///
351 /// let new_workspace = Workspace::create_new(request).await?;
352 /// # Ok(())
353 /// # }
354 /// ```
355 pub async fn create_new(request: WorkspaceCreateRequest) -> ApiResponseOrError<Self> {
356 let credentials_opt = request.credentials.clone();
357
358 anthropic_request_json(
359 Method::POST,
360 "organizations/workspaces",
361 |r| r.json(&request),
362 credentials_opt,
363 )
364 .await
365 }
366
367 /// Creates a builder for updating a workspace.
368 ///
369 /// # Example
370 ///
371 /// ```no_run
372 /// # use anthropic_api::{admin::workspace::*, Credentials};
373 /// # #[tokio::main]
374 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
375 /// let credentials = Credentials::from_env();
376 ///
377 /// let updated_workspace = Workspace::update_builder("workspace_123456789")
378 /// .credentials(credentials)
379 /// .name("Updated Workspace Name")
380 /// .create()
381 /// .await?;
382 /// # Ok(())
383 /// # }
384 /// ```
385 pub fn update_builder(workspace_id: impl Into<String>) -> WorkspaceUpdateBuilder {
386 WorkspaceUpdateBuilder::create_empty().workspace_id(workspace_id)
387 }
388
389 /// Updates a workspace with the given request parameters.
390 ///
391 /// # Example
392 ///
393 /// ```no_run
394 /// # use anthropic_api::{admin::workspace::*, Credentials};
395 /// # #[tokio::main]
396 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
397 /// let credentials = Credentials::from_env();
398 /// let request = WorkspaceUpdateRequest {
399 /// workspace_id: "workspace_123456789".to_string(),
400 /// name: "Updated Workspace Name".to_string(),
401 /// credentials: Some(credentials),
402 /// };
403 ///
404 /// let updated_workspace = Workspace::update(request).await?;
405 /// # Ok(())
406 /// # }
407 /// ```
408 pub async fn update(request: WorkspaceUpdateRequest) -> ApiResponseOrError<Self> {
409 let credentials_opt = request.credentials.clone();
410 let route = format!("organizations/workspaces/{}", request.workspace_id);
411
412 anthropic_request_json(Method::POST, &route, |r| r.json(&request), credentials_opt).await
413 }
414
415 /// Creates a builder for archiving a workspace.
416 ///
417 /// # Example
418 ///
419 /// ```no_run
420 /// # use anthropic_api::{admin::workspace::*, Credentials};
421 /// # #[tokio::main]
422 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
423 /// let credentials = Credentials::from_env();
424 ///
425 /// let archived_workspace = Workspace::archive_builder("workspace_123456789")
426 /// .credentials(credentials)
427 /// .create()
428 /// .await?;
429 /// # Ok(())
430 /// # }
431 /// ```
432 pub fn archive_builder(workspace_id: impl Into<String>) -> WorkspaceArchiveBuilder {
433 WorkspaceArchiveBuilder::create_empty().workspace_id(workspace_id)
434 }
435
436 /// Archives a workspace with the given request parameters.
437 ///
438 /// # Example
439 ///
440 /// ```no_run
441 /// # use anthropic_api::{admin::workspace::*, Credentials};
442 /// # #[tokio::main]
443 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
444 /// let credentials = Credentials::from_env();
445 /// let request = WorkspaceArchiveRequest {
446 /// workspace_id: "workspace_123456789".to_string(),
447 /// credentials: Some(credentials),
448 /// };
449 ///
450 /// let archived_workspace = Workspace::archive(request).await?;
451 /// # Ok(())
452 /// # }
453 /// ```
454 pub async fn archive(request: WorkspaceArchiveRequest) -> ApiResponseOrError<Self> {
455 let credentials_opt = request.credentials.clone();
456 let route = format!("organizations/workspaces/{}/archive", request.workspace_id);
457
458 anthropic_request_json(Method::POST, &route, |r| r, credentials_opt).await
459 }
460}
461
462// Builder convenience methods
463impl WorkspaceListBuilder {
464 /// Creates a new workspace list request and returns the response.
465 ///
466 /// This is a convenience method that builds the request from the builder
467 /// and sends it to the Workspaces API.
468 ///
469 /// # Example
470 ///
471 /// ```no_run
472 /// # use anthropic_api::{admin::workspace::*, Credentials};
473 /// # #[tokio::main]
474 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
475 /// let credentials = Credentials::from_env();
476 ///
477 /// let workspaces = WorkspaceList::builder()
478 /// .credentials(credentials)
479 /// .limit(10u32)
480 /// .create()
481 /// .await?;
482 /// # Ok(())
483 /// # }
484 /// ```
485 pub async fn create(self) -> ApiResponseOrError<WorkspaceList> {
486 let request = self.build().unwrap();
487 WorkspaceList::create(request).await
488 }
489}
490
491impl WorkspaceBuilder {
492 /// Creates a new workspace request and returns the response.
493 ///
494 /// This is a convenience method that builds the request from the builder
495 /// and sends it to the Workspaces API.
496 ///
497 /// # Example
498 ///
499 /// ```no_run
500 /// # use anthropic_api::{admin::workspace::*, Credentials};
501 /// # #[tokio::main]
502 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
503 /// let credentials = Credentials::from_env();
504 ///
505 /// let workspace = Workspace::builder("workspace_123456789")
506 /// .credentials(credentials)
507 /// .create()
508 /// .await?;
509 /// # Ok(())
510 /// # }
511 /// ```
512 pub async fn create(self) -> ApiResponseOrError<Workspace> {
513 let request = self.build().unwrap();
514 Workspace::create(request).await
515 }
516}
517
518impl WorkspaceCreateBuilder {
519 /// Creates a new workspace create request and returns the response.
520 ///
521 /// This is a convenience method that builds the request from the builder
522 /// and sends it to the Workspaces API.
523 ///
524 /// # Example
525 ///
526 /// ```no_run
527 /// # use anthropic_api::{admin::workspace::*, Credentials};
528 /// # #[tokio::main]
529 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
530 /// let credentials = Credentials::from_env();
531 ///
532 /// let new_workspace = Workspace::create_builder()
533 /// .credentials(credentials)
534 /// .name("My New Workspace")
535 /// .create()
536 /// .await?;
537 /// # Ok(())
538 /// # }
539 /// ```
540 pub async fn create(self) -> ApiResponseOrError<Workspace> {
541 let request = self.build().unwrap();
542 Workspace::create_new(request).await
543 }
544}
545
546impl WorkspaceUpdateBuilder {
547 /// Creates a new workspace update request and returns the response.
548 ///
549 /// This is a convenience method that builds the request from the builder
550 /// and sends it to the Workspaces API.
551 ///
552 /// # Example
553 ///
554 /// ```no_run
555 /// # use anthropic_api::{admin::workspace::*, Credentials};
556 /// # #[tokio::main]
557 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
558 /// let credentials = Credentials::from_env();
559 ///
560 /// let updated_workspace = Workspace::update_builder("workspace_123456789")
561 /// .credentials(credentials)
562 /// .name("Updated Workspace Name")
563 /// .create()
564 /// .await?;
565 /// # Ok(())
566 /// # }
567 /// ```
568 pub async fn create(self) -> ApiResponseOrError<Workspace> {
569 let request = self.build().unwrap();
570 Workspace::update(request).await
571 }
572}
573
574impl WorkspaceArchiveBuilder {
575 /// Creates a new workspace archive request and returns the response.
576 ///
577 /// This is a convenience method that builds the request from the builder
578 /// and sends it to the Workspaces API.
579 ///
580 /// # Example
581 ///
582 /// ```no_run
583 /// # use anthropic_api::{admin::workspace::*, Credentials};
584 /// # #[tokio::main]
585 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
586 /// let credentials = Credentials::from_env();
587 ///
588 /// let archived_workspace = Workspace::archive_builder("workspace_123456789")
589 /// .credentials(credentials)
590 /// .create()
591 /// .await?;
592 /// # Ok(())
593 /// # }
594 /// ```
595 pub async fn create(self) -> ApiResponseOrError<Workspace> {
596 let request = self.build().unwrap();
597 Workspace::archive(request).await
598 }
599}
600
601/// A workspace member available through the Anthropic Admin API.
602#[derive(Deserialize, Debug, Clone, Eq, PartialEq)]
603pub struct WorkspaceMember {
604 /// Object type (always "workspace_member" for Workspace Members)
605 #[serde(rename = "type")]
606 pub member_type: String,
607 /// User identifier
608 pub user_id: String,
609 /// Workspace identifier
610 pub workspace_id: String,
611 /// Role of the workspace member
612 pub workspace_role: WorkspaceMemberRole,
613}
614
615/// Response from the List Workspace Members API.
616#[derive(Deserialize, Debug, Clone, Eq, PartialEq)]
617pub struct WorkspaceMemberList {
618 /// List of workspace members
619 pub data: Vec<WorkspaceMember>,
620 /// First ID in the data list (for pagination)
621 pub first_id: Option<String>,
622 /// Last ID in the data list (for pagination)
623 pub last_id: Option<String>,
624 /// Indicates if there are more results in the requested page direction
625 pub has_more: bool,
626}
627
628/// Response from the Delete Workspace Member API.
629#[derive(Deserialize, Debug, Clone, Eq, PartialEq)]
630pub struct WorkspaceMemberDeleted {
631 /// Object type (always "workspace_member_deleted" for deleted Workspace Members)
632 #[serde(rename = "type")]
633 pub member_type: String,
634 /// User identifier
635 pub user_id: String,
636 /// Workspace identifier
637 pub workspace_id: String,
638}
639
640/// Role of a workspace member.
641#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
642#[serde(rename_all = "snake_case")]
643pub enum WorkspaceMemberRole {
644 /// Regular workspace user
645 WorkspaceUser,
646 /// Workspace developer with additional permissions
647 WorkspaceDeveloper,
648 /// Workspace administrator with full control
649 WorkspaceAdmin,
650 /// Workspace billing administrator
651 WorkspaceBilling,
652}
653
654/// Request parameters for listing workspace members.
655#[derive(Serialize, Builder, Debug, Clone)]
656#[builder(derive(Clone, Debug, PartialEq))]
657#[builder(pattern = "owned")]
658#[builder(name = "WorkspaceMemberListBuilder")]
659#[builder(setter(strip_option, into))]
660pub struct WorkspaceMemberListRequest {
661 /// Workspace identifier
662 pub workspace_id: String,
663
664 /// ID of the object to use as a cursor for pagination (previous page)
665 #[builder(default)]
666 #[serde(skip_serializing_if = "Option::is_none")]
667 pub before_id: Option<String>,
668
669 /// ID of the object to use as a cursor for pagination (next page)
670 #[builder(default)]
671 #[serde(skip_serializing_if = "Option::is_none")]
672 pub after_id: Option<String>,
673
674 /// Number of items to return per page (1-1000)
675 #[builder(default)]
676 #[serde(skip_serializing_if = "Option::is_none")]
677 pub limit: Option<u32>,
678
679 /// Credentials for authentication (not serialized)
680 #[serde(skip_serializing)]
681 #[builder(default)]
682 pub credentials: Option<Credentials>,
683}
684
685/// Request parameters for getting a specific workspace member.
686#[derive(Serialize, Builder, Debug, Clone)]
687#[builder(derive(Clone, Debug, PartialEq))]
688#[builder(pattern = "owned")]
689#[builder(name = "WorkspaceMemberBuilder")]
690#[builder(setter(strip_option, into))]
691pub struct WorkspaceMemberRequest {
692 /// Workspace identifier
693 pub workspace_id: String,
694
695 /// User identifier
696 pub user_id: String,
697
698 /// Credentials for authentication (not serialized)
699 #[serde(skip_serializing)]
700 #[builder(default)]
701 pub credentials: Option<Credentials>,
702}
703
704/// Request parameters for adding a workspace member.
705#[derive(Serialize, Builder, Debug, Clone)]
706#[builder(derive(Clone, Debug, PartialEq))]
707#[builder(pattern = "owned")]
708#[builder(name = "WorkspaceMemberAddBuilder")]
709#[builder(setter(strip_option, into))]
710pub struct WorkspaceMemberAddRequest {
711 /// Workspace identifier (not serialized)
712 #[serde(skip_serializing)]
713 pub workspace_id: String,
714
715 /// User identifier
716 pub user_id: String,
717
718 /// Role of the new workspace member
719 pub workspace_role: WorkspaceMemberRole,
720
721 /// Credentials for authentication (not serialized)
722 #[serde(skip_serializing)]
723 #[builder(default)]
724 pub credentials: Option<Credentials>,
725}
726
727/// Request parameters for updating a workspace member.
728#[derive(Serialize, Builder, Debug, Clone)]
729#[builder(derive(Clone, Debug, PartialEq))]
730#[builder(pattern = "owned")]
731#[builder(name = "WorkspaceMemberUpdateBuilder")]
732#[builder(setter(strip_option, into))]
733pub struct WorkspaceMemberUpdateRequest {
734 /// Workspace identifier (not serialized)
735 #[serde(skip_serializing)]
736 pub workspace_id: String,
737
738 /// User identifier (not serialized)
739 #[serde(skip_serializing)]
740 pub user_id: String,
741
742 /// New role for the workspace member
743 pub workspace_role: WorkspaceMemberRole,
744
745 /// Credentials for authentication (not serialized)
746 #[serde(skip_serializing)]
747 #[builder(default)]
748 pub credentials: Option<Credentials>,
749}
750
751/// Request parameters for deleting a workspace member.
752#[derive(Serialize, Builder, Debug, Clone)]
753#[builder(derive(Clone, Debug, PartialEq))]
754#[builder(pattern = "owned")]
755#[builder(name = "WorkspaceMemberDeleteBuilder")]
756#[builder(setter(strip_option, into))]
757pub struct WorkspaceMemberDeleteRequest {
758 /// Workspace identifier
759 pub workspace_id: String,
760
761 /// User identifier
762 pub user_id: String,
763
764 /// Credentials for authentication (not serialized)
765 #[serde(skip_serializing)]
766 #[builder(default)]
767 pub credentials: Option<Credentials>,
768}
769
770impl WorkspaceMemberList {
771 /// Creates a builder for listing workspace members.
772 ///
773 /// # Example
774 ///
775 /// ```no_run
776 /// # use anthropic_api::{admin::workspace::*, Credentials};
777 /// # #[tokio::main]
778 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
779 /// let credentials = Credentials::from_env();
780 ///
781 /// let members = WorkspaceMemberList::builder("workspace_123456789")
782 /// .credentials(credentials)
783 /// .limit(10u32)
784 /// .create()
785 /// .await?;
786 /// # Ok(())
787 /// # }
788 /// ```
789 pub fn builder(workspace_id: impl Into<String>) -> WorkspaceMemberListBuilder {
790 WorkspaceMemberListBuilder::create_empty().workspace_id(workspace_id)
791 }
792
793 /// Lists workspace members with the given request parameters.
794 ///
795 /// # Example
796 ///
797 /// ```no_run
798 /// # use anthropic_api::{admin::workspace::*, Credentials};
799 /// # #[tokio::main]
800 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
801 /// let credentials = Credentials::from_env();
802 /// let request = WorkspaceMemberListRequest {
803 /// workspace_id: "workspace_123456789".to_string(),
804 /// before_id: None,
805 /// after_id: None,
806 /// limit: Some(20),
807 /// credentials: Some(credentials),
808 /// };
809 ///
810 /// let members = WorkspaceMemberList::create(request).await?;
811 /// # Ok(())
812 /// # }
813 /// ```
814 pub async fn create(request: WorkspaceMemberListRequest) -> ApiResponseOrError<Self> {
815 let credentials_opt = request.credentials.clone();
816 let route = format!("organizations/workspaces/{}/members", request.workspace_id);
817
818 // Build query parameters
819 let mut query_params = Vec::new();
820 if let Some(before_id) = &request.before_id {
821 query_params.push(("before_id", before_id.clone()));
822 }
823 if let Some(after_id) = &request.after_id {
824 query_params.push(("after_id", after_id.clone()));
825 }
826 if let Some(limit) = request.limit {
827 query_params.push(("limit", limit.to_string()));
828 }
829
830 anthropic_request_json(
831 Method::GET,
832 &route,
833 |r| r.query(&query_params),
834 credentials_opt,
835 )
836 .await
837 }
838}
839
840impl WorkspaceMember {
841 /// Creates a builder for getting a specific workspace member.
842 ///
843 /// # Example
844 ///
845 /// ```no_run
846 /// # use anthropic_api::{admin::workspace::*, Credentials};
847 /// # #[tokio::main]
848 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
849 /// let credentials = Credentials::from_env();
850 ///
851 /// let member = WorkspaceMember::builder("workspace_123456789", "user_123456789")
852 /// .credentials(credentials)
853 /// .create()
854 /// .await?;
855 /// # Ok(())
856 /// # }
857 /// ```
858 pub fn builder(
859 workspace_id: impl Into<String>,
860 user_id: impl Into<String>,
861 ) -> WorkspaceMemberBuilder {
862 WorkspaceMemberBuilder::create_empty()
863 .workspace_id(workspace_id)
864 .user_id(user_id)
865 }
866
867 /// Gets information about a specific workspace member.
868 ///
869 /// # Example
870 ///
871 /// ```no_run
872 /// # use anthropic_api::{admin::workspace::*, Credentials};
873 /// # #[tokio::main]
874 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
875 /// let credentials = Credentials::from_env();
876 /// let request = WorkspaceMemberRequest {
877 /// workspace_id: "workspace_123456789".to_string(),
878 /// user_id: "user_123456789".to_string(),
879 /// credentials: Some(credentials),
880 /// };
881 ///
882 /// let member = WorkspaceMember::create(request).await?;
883 /// # Ok(())
884 /// # }
885 /// ```
886 pub async fn create(request: WorkspaceMemberRequest) -> ApiResponseOrError<Self> {
887 let credentials_opt = request.credentials.clone();
888 let route = format!(
889 "organizations/workspaces/{}/members/{}",
890 request.workspace_id, request.user_id
891 );
892
893 anthropic_request_json(Method::GET, &route, |r| r, credentials_opt).await
894 }
895
896 /// Creates a builder for adding a new workspace member.
897 ///
898 /// # Example
899 ///
900 /// ```no_run
901 /// # use anthropic_api::{admin::workspace::*, Credentials};
902 /// # #[tokio::main]
903 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
904 /// let credentials = Credentials::from_env();
905 ///
906 /// let new_member = WorkspaceMember::add_builder("workspace_123456789")
907 /// .credentials(credentials)
908 /// .user_id("user_123456789")
909 /// .workspace_role(WorkspaceMemberRole::WorkspaceDeveloper)
910 /// .create()
911 /// .await?;
912 /// # Ok(())
913 /// # }
914 /// ```
915 pub fn add_builder(workspace_id: impl Into<String>) -> WorkspaceMemberAddBuilder {
916 WorkspaceMemberAddBuilder::create_empty().workspace_id(workspace_id)
917 }
918
919 /// Adds a new workspace member with the given request parameters.
920 ///
921 /// # Example
922 ///
923 /// ```no_run
924 /// # use anthropic_api::{admin::workspace::*, Credentials};
925 /// # #[tokio::main]
926 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
927 /// let credentials = Credentials::from_env();
928 /// let request = WorkspaceMemberAddRequest {
929 /// workspace_id: "workspace_123456789".to_string(),
930 /// user_id: "user_123456789".to_string(),
931 /// workspace_role: WorkspaceMemberRole::WorkspaceDeveloper,
932 /// credentials: Some(credentials),
933 /// };
934 ///
935 /// let new_member = WorkspaceMember::add(request).await?;
936 /// # Ok(())
937 /// # }
938 /// ```
939 pub async fn add(request: WorkspaceMemberAddRequest) -> ApiResponseOrError<Self> {
940 let credentials_opt = request.credentials.clone();
941 let route = format!("organizations/workspaces/{}/members", request.workspace_id);
942
943 // Create the request body
944 let body = serde_json::json!({
945 "user_id": request.user_id,
946 "workspace_role": request.workspace_role,
947 });
948
949 anthropic_request_json(Method::POST, &route, |r| r.json(&body), credentials_opt).await
950 }
951
952 /// Creates a builder for updating a workspace member.
953 ///
954 /// # Example
955 ///
956 /// ```no_run
957 /// # use anthropic_api::{admin::workspace::*, Credentials};
958 /// # #[tokio::main]
959 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
960 /// let credentials = Credentials::from_env();
961 ///
962 /// let updated_member = WorkspaceMember::update_builder("workspace_123456789", "user_123456789")
963 /// .credentials(credentials)
964 /// .workspace_role(WorkspaceMemberRole::WorkspaceAdmin)
965 /// .create()
966 /// .await?;
967 /// # Ok(())
968 /// # }
969 /// ```
970 pub fn update_builder(
971 workspace_id: impl Into<String>,
972 user_id: impl Into<String>,
973 ) -> WorkspaceMemberUpdateBuilder {
974 WorkspaceMemberUpdateBuilder::create_empty()
975 .workspace_id(workspace_id)
976 .user_id(user_id)
977 }
978
979 /// Updates a workspace member with the given request parameters.
980 ///
981 /// # Example
982 ///
983 /// ```no_run
984 /// # use anthropic_api::{admin::workspace::*, Credentials};
985 /// # #[tokio::main]
986 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
987 /// let credentials = Credentials::from_env();
988 /// let request = WorkspaceMemberUpdateRequest {
989 /// workspace_id: "workspace_123456789".to_string(),
990 /// user_id: "user_123456789".to_string(),
991 /// workspace_role: WorkspaceMemberRole::WorkspaceAdmin,
992 /// credentials: Some(credentials),
993 /// };
994 ///
995 /// let updated_member = WorkspaceMember::update(request).await?;
996 /// # Ok(())
997 /// # }
998 /// ```
999 pub async fn update(request: WorkspaceMemberUpdateRequest) -> ApiResponseOrError<Self> {
1000 let credentials_opt = request.credentials.clone();
1001 let route = format!(
1002 "organizations/workspaces/{}/members/{}",
1003 request.workspace_id, request.user_id
1004 );
1005
1006 // Create the request body
1007 let body = serde_json::json!({
1008 "workspace_role": request.workspace_role,
1009 });
1010
1011 anthropic_request_json(Method::POST, &route, |r| r.json(&body), credentials_opt).await
1012 }
1013
1014 /// Creates a builder for deleting a workspace member.
1015 ///
1016 /// # Example
1017 ///
1018 /// ```no_run
1019 /// # use anthropic_api::{admin::workspace::*, Credentials};
1020 /// # #[tokio::main]
1021 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
1022 /// let credentials = Credentials::from_env();
1023 ///
1024 /// let deleted_member = WorkspaceMember::delete_builder("workspace_123456789", "user_123456789")
1025 /// .credentials(credentials)
1026 /// .create()
1027 /// .await?;
1028 /// # Ok(())
1029 /// # }
1030 /// ```
1031 pub fn delete_builder(
1032 workspace_id: impl Into<String>,
1033 user_id: impl Into<String>,
1034 ) -> WorkspaceMemberDeleteBuilder {
1035 WorkspaceMemberDeleteBuilder::create_empty()
1036 .workspace_id(workspace_id)
1037 .user_id(user_id)
1038 }
1039
1040 /// Deletes a workspace member with the given request parameters.
1041 ///
1042 /// # Example
1043 ///
1044 /// ```no_run
1045 /// # use anthropic_api::{admin::workspace::*, Credentials};
1046 /// # #[tokio::main]
1047 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
1048 /// let credentials = Credentials::from_env();
1049 /// let request = WorkspaceMemberDeleteRequest {
1050 /// workspace_id: "workspace_123456789".to_string(),
1051 /// user_id: "user_123456789".to_string(),
1052 /// credentials: Some(credentials),
1053 /// };
1054 ///
1055 /// let deleted_member = WorkspaceMember::delete(request).await?;
1056 /// # Ok(())
1057 /// # }
1058 /// ```
1059 pub async fn delete(
1060 request: WorkspaceMemberDeleteRequest,
1061 ) -> ApiResponseOrError<WorkspaceMemberDeleted> {
1062 let credentials_opt = request.credentials.clone();
1063 let route = format!(
1064 "organizations/workspaces/{}/members/{}",
1065 request.workspace_id, request.user_id
1066 );
1067
1068 anthropic_request_json(Method::DELETE, &route, |r| r, credentials_opt).await
1069 }
1070}
1071
1072// Builder convenience methods
1073impl WorkspaceMemberListBuilder {
1074 /// Creates a new workspace member list request and returns the response.
1075 ///
1076 /// This is a convenience method that builds the request from the builder
1077 /// and sends it to the Workspace Members API.
1078 ///
1079 /// # Example
1080 ///
1081 /// ```no_run
1082 /// # use anthropic_api::{admin::workspace::*, Credentials};
1083 /// # #[tokio::main]
1084 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
1085 /// let credentials = Credentials::from_env();
1086 ///
1087 /// let members = WorkspaceMemberList::builder("workspace_123456789")
1088 /// .credentials(credentials)
1089 /// .limit(10u32)
1090 /// .create()
1091 /// .await?;
1092 /// # Ok(())
1093 /// # }
1094 /// ```
1095 pub async fn create(self) -> ApiResponseOrError<WorkspaceMemberList> {
1096 let request = self.build().unwrap();
1097 WorkspaceMemberList::create(request).await
1098 }
1099}
1100
1101impl WorkspaceMemberBuilder {
1102 /// Creates a new workspace member request and returns the response.
1103 ///
1104 /// This is a convenience method that builds the request from the builder
1105 /// and sends it to the Workspace Members API.
1106 ///
1107 /// # Example
1108 ///
1109 /// ```no_run
1110 /// # use anthropic_api::{admin::workspace::*, Credentials};
1111 /// # #[tokio::main]
1112 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
1113 /// let credentials = Credentials::from_env();
1114 ///
1115 /// let member = WorkspaceMember::builder("workspace_123456789", "user_123456789")
1116 /// .credentials(credentials)
1117 /// .create()
1118 /// .await?;
1119 /// # Ok(())
1120 /// # }
1121 /// ```
1122 pub async fn create(self) -> ApiResponseOrError<WorkspaceMember> {
1123 let request = self.build().unwrap();
1124 WorkspaceMember::create(request).await
1125 }
1126}
1127
1128impl WorkspaceMemberAddBuilder {
1129 /// Creates a new workspace member add request and returns the response.
1130 ///
1131 /// This is a convenience method that builds the request from the builder
1132 /// and sends it to the Workspace Members API.
1133 ///
1134 /// # Example
1135 ///
1136 /// ```no_run
1137 /// # use anthropic_api::{admin::workspace::*, Credentials};
1138 /// # #[tokio::main]
1139 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
1140 /// let credentials = Credentials::from_env();
1141 ///
1142 /// let new_member = WorkspaceMember::add_builder("workspace_123456789")
1143 /// .credentials(credentials)
1144 /// .user_id("user_123456789")
1145 /// .workspace_role(WorkspaceMemberRole::WorkspaceDeveloper)
1146 /// .create()
1147 /// .await?;
1148 /// # Ok(())
1149 /// # }
1150 /// ```
1151 pub async fn create(self) -> ApiResponseOrError<WorkspaceMember> {
1152 let request = self.build().unwrap();
1153 WorkspaceMember::add(request).await
1154 }
1155}
1156
1157impl WorkspaceMemberUpdateBuilder {
1158 /// Creates a new workspace member update request and returns the response.
1159 ///
1160 /// This is a convenience method that builds the request from the builder
1161 /// and sends it to the Workspace Members API.
1162 ///
1163 /// # Example
1164 ///
1165 /// ```no_run
1166 /// # use anthropic_api::{admin::workspace::*, Credentials};
1167 /// # #[tokio::main]
1168 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
1169 /// let credentials = Credentials::from_env();
1170 ///
1171 /// let updated_member = WorkspaceMember::update_builder("workspace_123456789", "user_123456789")
1172 /// .credentials(credentials)
1173 /// .workspace_role(WorkspaceMemberRole::WorkspaceAdmin)
1174 /// .create()
1175 /// .await?;
1176 /// # Ok(())
1177 /// # }
1178 /// ```
1179 pub async fn create(self) -> ApiResponseOrError<WorkspaceMember> {
1180 let request = self.build().unwrap();
1181 WorkspaceMember::update(request).await
1182 }
1183}
1184
1185impl WorkspaceMemberDeleteBuilder {
1186 /// Creates a new workspace member delete request and returns the response.
1187 ///
1188 /// This is a convenience method that builds the request from the builder
1189 /// and sends it to the Workspace Members API.
1190 ///
1191 /// # Example
1192 ///
1193 /// ```no_run
1194 /// # use anthropic_api::{admin::workspace::*, Credentials};
1195 /// # #[tokio::main]
1196 /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
1197 /// let credentials = Credentials::from_env();
1198 ///
1199 /// let deleted_member = WorkspaceMember::delete_builder("workspace_123456789", "user_123456789")
1200 /// .credentials(credentials)
1201 /// .create()
1202 /// .await?;
1203 /// # Ok(())
1204 /// # }
1205 /// ```
1206 pub async fn create(self) -> ApiResponseOrError<WorkspaceMemberDeleted> {
1207 let request = self.build().unwrap();
1208 WorkspaceMember::delete(request).await
1209 }
1210}
1211
1212#[cfg(test)]
1213mod tests {
1214 use super::*;
1215 use crate::Credentials;
1216
1217 #[tokio::test]
1218 #[ignore] // Requires admin API key
1219 async fn test_list_workspaces() {
1220 let credentials = Credentials::from_env();
1221
1222 let workspaces = WorkspaceList::builder()
1223 .credentials(credentials)
1224 .create()
1225 .await
1226 .unwrap();
1227
1228 assert!(workspaces.data.len() > 0);
1229 }
1230
1231 #[tokio::test]
1232 #[ignore] // Requires admin API key
1233 async fn test_get_workspace() {
1234 let credentials = Credentials::from_env();
1235
1236 // First get a workspace ID from the list
1237 let workspaces = WorkspaceList::builder()
1238 .credentials(credentials.clone())
1239 .create()
1240 .await
1241 .unwrap();
1242
1243 if let Some(workspace) = workspaces.data.first() {
1244 let workspace_id = &workspace.id;
1245
1246 // Then get that specific workspace
1247 let workspace_details = Workspace::builder(workspace_id)
1248 .credentials(credentials)
1249 .create()
1250 .await
1251 .unwrap();
1252
1253 assert_eq!(workspace_details.id, *workspace_id);
1254 }
1255 }
1256
1257 #[tokio::test]
1258 #[ignore] // Requires admin API key
1259 async fn test_list_workspace_members() {
1260 let credentials = Credentials::from_env();
1261
1262 // First get a workspace ID from the list
1263 let workspaces = crate::admin::workspace::WorkspaceList::builder()
1264 .credentials(credentials.clone())
1265 .create()
1266 .await
1267 .unwrap();
1268
1269 if let Some(workspace) = workspaces.data.first() {
1270 let workspace_id = &workspace.id;
1271
1272 // Then list members for that workspace
1273 let members = WorkspaceMemberList::builder(workspace_id)
1274 .credentials(credentials)
1275 .create()
1276 .await
1277 .unwrap();
1278
1279 // Just verify we got a response, may be empty if no members
1280 assert!(!members.data.is_empty() || (members.data.is_empty() && !members.has_more));
1281 }
1282 }
1283
1284 #[tokio::test]
1285 #[ignore] // Requires admin API key
1286 async fn test_get_workspace_member() {
1287 let credentials = Credentials::from_env();
1288
1289 // First get a workspace ID from the list
1290 let workspaces = crate::admin::workspace::WorkspaceList::builder()
1291 .credentials(credentials.clone())
1292 .create()
1293 .await
1294 .unwrap();
1295
1296 if let Some(workspace) = workspaces.data.first() {
1297 let workspace_id = &workspace.id;
1298
1299 // Then list members for that workspace
1300 let members = WorkspaceMemberList::builder(workspace_id)
1301 .credentials(credentials.clone())
1302 .create()
1303 .await
1304 .unwrap();
1305
1306 // If there are members, get details for the first one
1307 if let Some(member) = members.data.first() {
1308 let user_id = &member.user_id;
1309
1310 let member_details = WorkspaceMember::builder(workspace_id, user_id)
1311 .credentials(credentials)
1312 .create()
1313 .await
1314 .unwrap();
1315
1316 assert_eq!(member_details.user_id, *user_id);
1317 assert_eq!(member_details.workspace_id, *workspace_id);
1318 }
1319 }
1320 }
1321}