/*
* OpenAI API
*
* The OpenAI REST API. Please see https://platform.openai.com/docs/api-reference for more details.
*
* The version of the OpenAPI document: 2.3.0
*
* Generated by: https://openapi-generator.tech
*/
#![allow(clippy::needless_return, clippy::into_iter_on_ref)]
use super::{configuration, ContentType, Error};
use crate::{apis::ResponseContent, models};
use reqwest;
use serde::{de::Error as _, Deserialize, Serialize};
/// struct for typed errors of method [`archive_project`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ArchiveProjectError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`create_project`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateProjectError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`create_project_service_account`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateProjectServiceAccountError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`create_project_user`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateProjectUserError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status409(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`delete_project_api_key`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteProjectApiKeyError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`delete_project_model_permissions`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteProjectModelPermissionsError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`delete_project_service_account`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteProjectServiceAccountError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`delete_project_user`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteProjectUserError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`list_project_api_keys`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListProjectApiKeysError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`list_project_rate_limits`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListProjectRateLimitsError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`list_project_service_accounts`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListProjectServiceAccountsError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`list_project_users`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListProjectUsersError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`list_projects`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListProjectsError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`modify_project`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ModifyProjectError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`modify_project_user`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ModifyProjectUserError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`retrieve_project`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RetrieveProjectError {
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`retrieve_project_api_key`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RetrieveProjectApiKeyError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`retrieve_project_model_permissions`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RetrieveProjectModelPermissionsError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`retrieve_project_service_account`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RetrieveProjectServiceAccountError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`retrieve_project_user`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RetrieveProjectUserError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`update_project_api_key`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UpdateProjectApiKeyError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`update_project_model_permissions`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UpdateProjectModelPermissionsError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`update_project_rate_limits`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UpdateProjectRateLimitsError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`update_project_service_account`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UpdateProjectServiceAccountError {
Status400(models::ErrorResponse),
Status403(models::PermissionErrorResponse),
Status404(models::ErrorResponse),
Status429(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// Archives a project in the organization. Archived projects cannot be used or updated.
#[bon::builder]
pub async fn archive_project(
configuration: &configuration::Configuration,
project_id: &str,
) -> Result<models::Project, Error<ArchiveProjectError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let uri_str = format!(
"{}/organization/projects/{project_id}/archive",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Project`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Project`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<ArchiveProjectError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Create a new project in the organization. Projects can be created and archived, but cannot be deleted.
#[bon::builder]
pub async fn create_project(
configuration: &configuration::Configuration,
project_create_request: models::ProjectCreateRequest,
) -> Result<models::Project, Error<CreateProjectError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_body_project_create_request = project_create_request;
let uri_str = format!("{}/organization/projects", configuration.base_path);
let mut req_builder = configuration
.client
.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
req_builder = req_builder.json(&p_body_project_create_request);
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Project`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Project`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<CreateProjectError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Creates a new service account in the project. By default, this also returns an unredacted API key for the service account.
#[bon::builder]
pub async fn create_project_service_account(
configuration: &configuration::Configuration,
project_id: &str,
project_service_account_create_request: models::ProjectServiceAccountCreateRequest,
) -> Result<models::ProjectServiceAccountCreateResponse, Error<CreateProjectServiceAccountError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let p_body_project_service_account_create_request = project_service_account_create_request;
let uri_str = format!(
"{}/organization/projects/{project_id}/service_accounts",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
req_builder = req_builder.json(&p_body_project_service_account_create_request);
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProjectServiceAccountCreateResponse`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProjectServiceAccountCreateResponse`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<CreateProjectServiceAccountError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Adds a user to the project. Users must already be members of the organization to be added to a project.
#[bon::builder]
pub async fn create_project_user(
configuration: &configuration::Configuration,
project_id: &str,
project_user_create_request: models::ProjectUserCreateRequest,
) -> Result<models::ProjectUser, Error<CreateProjectUserError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let p_body_project_user_create_request = project_user_create_request;
let uri_str = format!(
"{}/organization/projects/{project_id}/users",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
req_builder = req_builder.json(&p_body_project_user_create_request);
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProjectUser`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProjectUser`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<CreateProjectUserError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Deletes an API key from the project. Returns confirmation of the key deletion, or an error if the key belonged to a service account.
#[bon::builder]
pub async fn delete_project_api_key(
configuration: &configuration::Configuration,
project_id: &str,
api_key_id: &str,
) -> Result<models::ProjectApiKeyDeleteResponse, Error<DeleteProjectApiKeyError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let p_path_api_key_id = api_key_id;
let uri_str = format!(
"{}/organization/projects/{project_id}/api_keys/{api_key_id}",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id),
api_key_id = crate::apis::urlencode(p_path_api_key_id)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::DELETE, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProjectApiKeyDeleteResponse`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProjectApiKeyDeleteResponse`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<DeleteProjectApiKeyError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Deletes model permissions for a project.
#[bon::builder]
pub async fn delete_project_model_permissions(
configuration: &configuration::Configuration,
project_id: &str,
) -> Result<models::ProjectModelPermissionsDeleteResponse, Error<DeleteProjectModelPermissionsError>>
{
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let uri_str = format!(
"{}/organization/projects/{project_id}/model_permissions",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::DELETE, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProjectModelPermissionsDeleteResponse`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProjectModelPermissionsDeleteResponse`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<DeleteProjectModelPermissionsError> =
serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Deletes a service account from the project. Returns confirmation of service account deletion, or an error if the project is archived (archived projects have no service accounts).
#[bon::builder]
pub async fn delete_project_service_account(
configuration: &configuration::Configuration,
project_id: &str,
service_account_id: &str,
) -> Result<models::ProjectServiceAccountDeleteResponse, Error<DeleteProjectServiceAccountError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let p_path_service_account_id = service_account_id;
let uri_str = format!(
"{}/organization/projects/{project_id}/service_accounts/{service_account_id}",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id),
service_account_id = crate::apis::urlencode(p_path_service_account_id)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::DELETE, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProjectServiceAccountDeleteResponse`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProjectServiceAccountDeleteResponse`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<DeleteProjectServiceAccountError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Deletes a user from the project. Returns confirmation of project user deletion, or an error if the project is archived (archived projects have no users).
#[bon::builder]
pub async fn delete_project_user(
configuration: &configuration::Configuration,
project_id: &str,
user_id: &str,
) -> Result<models::ProjectUserDeleteResponse, Error<DeleteProjectUserError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let p_path_user_id = user_id;
let uri_str = format!(
"{}/organization/projects/{project_id}/users/{user_id}",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id),
user_id = crate::apis::urlencode(p_path_user_id)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::DELETE, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProjectUserDeleteResponse`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProjectUserDeleteResponse`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<DeleteProjectUserError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Returns a list of API keys in the project.
#[bon::builder]
pub async fn list_project_api_keys(
configuration: &configuration::Configuration,
project_id: &str,
limit: Option<i32>,
after: Option<&str>,
owner_project_access: Option<&str>,
) -> Result<models::ProjectApiKeyListResponse, Error<ListProjectApiKeysError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let p_query_limit = limit;
let p_query_after = after;
let p_query_owner_project_access = owner_project_access;
let uri_str = format!(
"{}/organization/projects/{project_id}/api_keys",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id)
);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref param_value) = p_query_limit {
req_builder = req_builder.query(&[("limit", ¶m_value.to_string())]);
}
if let Some(ref param_value) = p_query_after {
req_builder = req_builder.query(&[("after", ¶m_value.to_string())]);
}
if let Some(ref param_value) = p_query_owner_project_access {
req_builder = req_builder.query(&[("owner_project_access", ¶m_value.to_string())]);
}
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProjectApiKeyListResponse`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProjectApiKeyListResponse`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<ListProjectApiKeysError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Returns the rate limits per model for a project.
#[bon::builder]
pub async fn list_project_rate_limits(
configuration: &configuration::Configuration,
project_id: &str,
limit: Option<i32>,
after: Option<&str>,
before: Option<&str>,
) -> Result<models::ProjectRateLimitListResponse, Error<ListProjectRateLimitsError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let p_query_limit = limit;
let p_query_after = after;
let p_query_before = before;
let uri_str = format!(
"{}/organization/projects/{project_id}/rate_limits",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id)
);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref param_value) = p_query_limit {
req_builder = req_builder.query(&[("limit", ¶m_value.to_string())]);
}
if let Some(ref param_value) = p_query_after {
req_builder = req_builder.query(&[("after", ¶m_value.to_string())]);
}
if let Some(ref param_value) = p_query_before {
req_builder = req_builder.query(&[("before", ¶m_value.to_string())]);
}
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProjectRateLimitListResponse`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProjectRateLimitListResponse`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<ListProjectRateLimitsError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Returns a list of service accounts in the project.
#[bon::builder]
pub async fn list_project_service_accounts(
configuration: &configuration::Configuration,
project_id: &str,
limit: Option<i32>,
after: Option<&str>,
) -> Result<models::ProjectServiceAccountListResponse, Error<ListProjectServiceAccountsError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let p_query_limit = limit;
let p_query_after = after;
let uri_str = format!(
"{}/organization/projects/{project_id}/service_accounts",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id)
);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref param_value) = p_query_limit {
req_builder = req_builder.query(&[("limit", ¶m_value.to_string())]);
}
if let Some(ref param_value) = p_query_after {
req_builder = req_builder.query(&[("after", ¶m_value.to_string())]);
}
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProjectServiceAccountListResponse`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProjectServiceAccountListResponse`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<ListProjectServiceAccountsError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Returns a list of users in the project.
#[bon::builder]
pub async fn list_project_users(
configuration: &configuration::Configuration,
project_id: &str,
limit: Option<i32>,
after: Option<&str>,
) -> Result<models::ProjectUserListResponse, Error<ListProjectUsersError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let p_query_limit = limit;
let p_query_after = after;
let uri_str = format!(
"{}/organization/projects/{project_id}/users",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id)
);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref param_value) = p_query_limit {
req_builder = req_builder.query(&[("limit", ¶m_value.to_string())]);
}
if let Some(ref param_value) = p_query_after {
req_builder = req_builder.query(&[("after", ¶m_value.to_string())]);
}
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProjectUserListResponse`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProjectUserListResponse`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<ListProjectUsersError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Returns a list of projects.
#[bon::builder]
pub async fn list_projects(
configuration: &configuration::Configuration,
limit: Option<i32>,
after: Option<&str>,
include_archived: Option<bool>,
) -> Result<models::ProjectListResponse, Error<ListProjectsError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_query_limit = limit;
let p_query_after = after;
let p_query_include_archived = include_archived;
let uri_str = format!("{}/organization/projects", configuration.base_path);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref param_value) = p_query_limit {
req_builder = req_builder.query(&[("limit", ¶m_value.to_string())]);
}
if let Some(ref param_value) = p_query_after {
req_builder = req_builder.query(&[("after", ¶m_value.to_string())]);
}
if let Some(ref param_value) = p_query_include_archived {
req_builder = req_builder.query(&[("include_archived", ¶m_value.to_string())]);
}
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProjectListResponse`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProjectListResponse`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<ListProjectsError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Modifies a project in the organization.
#[bon::builder]
pub async fn modify_project(
configuration: &configuration::Configuration,
project_id: &str,
project_update_request: models::ProjectUpdateRequest,
) -> Result<models::Project, Error<ModifyProjectError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let p_body_project_update_request = project_update_request;
let uri_str = format!(
"{}/organization/projects/{project_id}",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
req_builder = req_builder.json(&p_body_project_update_request);
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Project`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Project`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<ModifyProjectError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Modifies a user's role in the project.
#[bon::builder]
pub async fn modify_project_user(
configuration: &configuration::Configuration,
project_id: &str,
user_id: &str,
project_user_update_request: models::ProjectUserUpdateRequest,
) -> Result<models::ProjectUser, Error<ModifyProjectUserError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let p_path_user_id = user_id;
let p_body_project_user_update_request = project_user_update_request;
let uri_str = format!(
"{}/organization/projects/{project_id}/users/{user_id}",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id),
user_id = crate::apis::urlencode(p_path_user_id)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
req_builder = req_builder.json(&p_body_project_user_update_request);
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProjectUser`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProjectUser`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<ModifyProjectUserError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Retrieves a project.
#[bon::builder]
pub async fn retrieve_project(
configuration: &configuration::Configuration,
project_id: &str,
) -> Result<models::Project, Error<RetrieveProjectError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let uri_str = format!(
"{}/organization/projects/{project_id}",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id)
);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Project`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Project`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<RetrieveProjectError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Retrieves an API key in the project.
#[bon::builder]
pub async fn retrieve_project_api_key(
configuration: &configuration::Configuration,
project_id: &str,
api_key_id: &str,
) -> Result<models::ProjectApiKey, Error<RetrieveProjectApiKeyError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let p_path_api_key_id = api_key_id;
let uri_str = format!(
"{}/organization/projects/{project_id}/api_keys/{api_key_id}",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id),
api_key_id = crate::apis::urlencode(p_path_api_key_id)
);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProjectApiKey`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProjectApiKey`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<RetrieveProjectApiKeyError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Returns model permissions for a project.
#[bon::builder]
pub async fn retrieve_project_model_permissions(
configuration: &configuration::Configuration,
project_id: &str,
) -> Result<models::ProjectModelPermissions, Error<RetrieveProjectModelPermissionsError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let uri_str = format!(
"{}/organization/projects/{project_id}/model_permissions",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id)
);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProjectModelPermissions`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProjectModelPermissions`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<RetrieveProjectModelPermissionsError> =
serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Retrieves a service account in the project.
#[bon::builder]
pub async fn retrieve_project_service_account(
configuration: &configuration::Configuration,
project_id: &str,
service_account_id: &str,
) -> Result<models::ProjectServiceAccount, Error<RetrieveProjectServiceAccountError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let p_path_service_account_id = service_account_id;
let uri_str = format!(
"{}/organization/projects/{project_id}/service_accounts/{service_account_id}",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id),
service_account_id = crate::apis::urlencode(p_path_service_account_id)
);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProjectServiceAccount`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProjectServiceAccount`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<RetrieveProjectServiceAccountError> =
serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Retrieves a user in the project.
#[bon::builder]
pub async fn retrieve_project_user(
configuration: &configuration::Configuration,
project_id: &str,
user_id: &str,
) -> Result<models::ProjectUser, Error<RetrieveProjectUserError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let p_path_user_id = user_id;
let uri_str = format!(
"{}/organization/projects/{project_id}/users/{user_id}",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id),
user_id = crate::apis::urlencode(p_path_user_id)
);
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProjectUser`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProjectUser`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<RetrieveProjectUserError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Updates the scopes and/or expiration of an existing API key in the project, including a service-account-owned key. Requires permission to write project API keys. Provide at least one of `scopes` or `expires_in_seconds`. Omitted fields stay unchanged; neither field accepts `null`. Both changes are saved together. `scopes` replaces the key's scope restrictions using the same scope identifiers as the dashboard. An empty array means All permissions, subject to the owner's effective access; it does not mean no access. Use `[\"api.all.read\"]` for read-only access or specific scopes such as `[\"api.files.read\"]` for restricted access. This does not change user or service-account roles or grant admin permissions. Scope changes follow the same authentication-cache propagation as dashboard edits. Provide `expires_in_seconds` to set the expiration relative to this request. The value must satisfy the organization's and project's expiry policies. Expired keys cannot be updated. Retrying resets the expiration relative to the new request. The response contains only the redacted key, not its secret.
#[bon::builder]
pub async fn update_project_api_key(
configuration: &configuration::Configuration,
project_id: &str,
api_key_id: &str,
update_project_api_key_body: models::UpdateProjectApiKeyBody,
) -> Result<models::ProjectApiKey, Error<UpdateProjectApiKeyError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let p_path_api_key_id = api_key_id;
let p_body_update_project_api_key_body = update_project_api_key_body;
let uri_str = format!(
"{}/organization/projects/{project_id}/api_keys/{api_key_id}",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id),
api_key_id = crate::apis::urlencode(p_path_api_key_id)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
req_builder = req_builder.json(&p_body_update_project_api_key_body);
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProjectApiKey`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProjectApiKey`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<UpdateProjectApiKeyError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Updates model permissions for a project.
#[bon::builder]
pub async fn update_project_model_permissions(
configuration: &configuration::Configuration,
project_id: &str,
project_model_permissions_update_request: models::ProjectModelPermissionsUpdateRequest,
) -> Result<models::ProjectModelPermissions, Error<UpdateProjectModelPermissionsError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let p_body_project_model_permissions_update_request = project_model_permissions_update_request;
let uri_str = format!(
"{}/organization/projects/{project_id}/model_permissions",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
req_builder = req_builder.json(&p_body_project_model_permissions_update_request);
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProjectModelPermissions`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProjectModelPermissions`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<UpdateProjectModelPermissionsError> =
serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Updates a project rate limit.
#[bon::builder]
pub async fn update_project_rate_limits(
configuration: &configuration::Configuration,
project_id: &str,
rate_limit_id: &str,
project_rate_limit_update_request: models::ProjectRateLimitUpdateRequest,
) -> Result<models::ProjectRateLimit, Error<UpdateProjectRateLimitsError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let p_path_rate_limit_id = rate_limit_id;
let p_body_project_rate_limit_update_request = project_rate_limit_update_request;
let uri_str = format!(
"{}/organization/projects/{project_id}/rate_limits/{rate_limit_id}",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id),
rate_limit_id = crate::apis::urlencode(p_path_rate_limit_id)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
req_builder = req_builder.json(&p_body_project_rate_limit_update_request);
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProjectRateLimit`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProjectRateLimit`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<UpdateProjectRateLimitsError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}
/// Updates a service account in the project.
#[bon::builder]
pub async fn update_project_service_account(
configuration: &configuration::Configuration,
project_id: &str,
service_account_id: &str,
update_project_service_account_body: models::UpdateProjectServiceAccountBody,
) -> Result<models::ProjectServiceAccount, Error<UpdateProjectServiceAccountError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_project_id = project_id;
let p_path_service_account_id = service_account_id;
let p_body_update_project_service_account_body = update_project_service_account_body;
let uri_str = format!(
"{}/organization/projects/{project_id}/service_accounts/{service_account_id}",
configuration.base_path,
project_id = crate::apis::urlencode(p_path_project_id),
service_account_id = crate::apis::urlencode(p_path_service_account_id)
);
let mut req_builder = configuration
.client
.request(reqwest::Method::POST, &uri_str);
if let Some(ref user_agent) = configuration.user_agent {
req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
}
if let Some(ref token) = configuration.bearer_access_token {
req_builder = req_builder.bearer_auth(token.to_owned());
};
req_builder = req_builder.json(&p_body_update_project_service_account_body);
let req = req_builder.build()?;
let resp = configuration.client.execute(req).await?;
let status = resp.status();
let content_type = resp
.headers()
.get("content-type")
.and_then(|v| v.to_str().ok())
.unwrap_or("application/octet-stream");
let content_type = super::ContentType::from(content_type);
if !status.is_client_error() && !status.is_server_error() {
let content = resp.text().await?;
match content_type {
ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProjectServiceAccount`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProjectServiceAccount`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<UpdateProjectServiceAccountError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(Box::new(ResponseContent {
status,
content,
entity,
})))
}
}