/*
* Linkbreakers API
*
* This is a documentation of all the APIs of Linkbreakers
*
* The version of the OpenAPI document: 1.118.3
*
* Generated by: https://openapi-generator.tech
*/
use reqwest;
use serde::{Deserialize, Serialize, de::Error as _};
use crate::{apis::ResponseContent, models};
use super::{Error, configuration, ContentType};
/// struct for typed errors of method [`workflow_steps_service_auto_layout_workflow`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum WorkflowStepsServiceAutoLayoutWorkflowError {
DefaultResponse(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`workflow_steps_service_connect_step`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum WorkflowStepsServiceConnectStepError {
DefaultResponse(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`workflow_steps_service_create`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum WorkflowStepsServiceCreateError {
DefaultResponse(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`workflow_steps_service_delete`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum WorkflowStepsServiceDeleteError {
DefaultResponse(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`workflow_steps_service_disconnect_step`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum WorkflowStepsServiceDisconnectStepError {
DefaultResponse(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`workflow_steps_service_get`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum WorkflowStepsServiceGetError {
DefaultResponse(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`workflow_steps_service_list`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum WorkflowStepsServiceListError {
DefaultResponse(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`workflow_steps_service_resolve_step_collisions`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum WorkflowStepsServiceResolveStepCollisionsError {
DefaultResponse(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`workflow_steps_service_update`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum WorkflowStepsServiceUpdateError {
DefaultResponse(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// struct for typed errors of method [`workflow_steps_service_validate_workflow`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum WorkflowStepsServiceValidateWorkflowError {
DefaultResponse(models::ErrorResponse),
UnknownValue(serde_json::Value),
}
/// Arranges all workflow steps in a clean left-to-right DAG layout. Useful after building a workflow from scratch.
pub async fn workflow_steps_service_auto_layout_workflow(configuration: &configuration::Configuration, link_id: &str, body: serde_json::Value) -> Result<models::AutoLayoutWorkflowResponse, Error<WorkflowStepsServiceAutoLayoutWorkflowError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_link_id = link_id;
let p_body_body = body;
let uri_str = format!("{}/v1/links/{linkId}/workflow-steps/auto-layout", configuration.base_path, linkId=crate::apis::urlencode(p_path_link_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_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::AutoLayoutWorkflowResponse`"))),
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::AutoLayoutWorkflowResponse`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<WorkflowStepsServiceAutoLayoutWorkflowError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent { status, content, entity }))
}
}
/// Every workflow step is connected the same way: name the branch it leaves from, and the step it leads to. Atomic steps (redirect, password, form, message page) have exactly one branch, \"next\". Composite steps (multi-link, conditions) have one branch per button, option or range, plus \"else\" for a condition's fallback. Exit steps end the journey and have no branches at all. Read a step to see its branches, their ids and their current destinations. Idempotent: connecting a branch to the step it already leads to is a no-op.
pub async fn workflow_steps_service_connect_step(configuration: &configuration::Configuration, link_id: &str, step_id: &str, branch_id: &str, workflow_steps_service_connect_step_body: models::WorkflowStepsServiceConnectStepBody) -> Result<models::ConnectWorkflowStepResponse, Error<WorkflowStepsServiceConnectStepError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_link_id = link_id;
let p_path_step_id = step_id;
let p_path_branch_id = branch_id;
let p_body_workflow_steps_service_connect_step_body = workflow_steps_service_connect_step_body;
let uri_str = format!("{}/v1/links/{linkId}/workflow-steps/{stepId}/branches/{branchId}/connection", configuration.base_path, linkId=crate::apis::urlencode(p_path_link_id), stepId=crate::apis::urlencode(p_path_step_id), branchId=crate::apis::urlencode(p_path_branch_id));
let mut req_builder = configuration.client.request(reqwest::Method::PUT, &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_workflow_steps_service_connect_step_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::ConnectWorkflowStepResponse`"))),
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::ConnectWorkflowStepResponse`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<WorkflowStepsServiceConnectStepError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent { status, content, entity }))
}
}
/// This endpoint allows users to create a new workflow step for a link. Workflow steps define the behavior of links, such as redirection destinations.
pub async fn workflow_steps_service_create(configuration: &configuration::Configuration, link_id: &str, workflow_steps_service_create_body: models::WorkflowStepsServiceCreateBody) -> Result<models::CreateWorkflowStepResponse, Error<WorkflowStepsServiceCreateError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_link_id = link_id;
let p_body_workflow_steps_service_create_body = workflow_steps_service_create_body;
let uri_str = format!("{}/v1/links/{linkId}/workflow-steps", configuration.base_path, linkId=crate::apis::urlencode(p_path_link_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_workflow_steps_service_create_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::CreateWorkflowStepResponse`"))),
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::CreateWorkflowStepResponse`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<WorkflowStepsServiceCreateError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent { status, content, entity }))
}
}
/// Removes a workflow step from the link. This operation cannot be undone.
pub async fn workflow_steps_service_delete(configuration: &configuration::Configuration, link_id: &str, id: &str) -> Result<serde_json::Value, Error<WorkflowStepsServiceDeleteError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_link_id = link_id;
let p_path_id = id;
let uri_str = format!("{}/v1/links/{linkId}/workflow-steps/{id}", configuration.base_path, linkId=crate::apis::urlencode(p_path_link_id), id=crate::apis::urlencode(p_path_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 `serde_json::Value`"))),
ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<WorkflowStepsServiceDeleteError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent { status, content, entity }))
}
}
/// Leaves the branch with no destination. Clearing a branch that is already clear succeeds. See ConnectStep for what a branch id is.
pub async fn workflow_steps_service_disconnect_step(configuration: &configuration::Configuration, link_id: &str, step_id: &str, branch_id: &str) -> Result<models::DisconnectWorkflowStepResponse, Error<WorkflowStepsServiceDisconnectStepError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_link_id = link_id;
let p_path_step_id = step_id;
let p_path_branch_id = branch_id;
let uri_str = format!("{}/v1/links/{linkId}/workflow-steps/{stepId}/branches/{branchId}/connection", configuration.base_path, linkId=crate::apis::urlencode(p_path_link_id), stepId=crate::apis::urlencode(p_path_step_id), branchId=crate::apis::urlencode(p_path_branch_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::DisconnectWorkflowStepResponse`"))),
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::DisconnectWorkflowStepResponse`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<WorkflowStepsServiceDisconnectStepError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent { status, content, entity }))
}
}
/// Retrieves information about a specific workflow step.
pub async fn workflow_steps_service_get(configuration: &configuration::Configuration, link_id: &str, id: &str) -> Result<models::GetWorkflowStepResponse, Error<WorkflowStepsServiceGetError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_link_id = link_id;
let p_path_id = id;
let uri_str = format!("{}/v1/links/{linkId}/workflow-steps/{id}", configuration.base_path, linkId=crate::apis::urlencode(p_path_link_id), id=crate::apis::urlencode(p_path_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::GetWorkflowStepResponse`"))),
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::GetWorkflowStepResponse`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<WorkflowStepsServiceGetError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent { status, content, entity }))
}
}
/// Retrieves all workflow steps for a specific link
pub async fn workflow_steps_service_list(configuration: &configuration::Configuration, link_id: &str, page_size: Option<i64>, page_token: Option<&str>) -> Result<models::ListWorkflowStepsResponse, Error<WorkflowStepsServiceListError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_link_id = link_id;
let p_query_page_size = page_size;
let p_query_page_token = page_token;
let uri_str = format!("{}/v1/links/{linkId}/workflow-steps", configuration.base_path, linkId=crate::apis::urlencode(p_path_link_id));
let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
if let Some(ref param_value) = p_query_page_size {
req_builder = req_builder.query(&[("pageSize", ¶m_value.to_string())]);
}
if let Some(ref param_value) = p_query_page_token {
req_builder = req_builder.query(&[("pageToken", ¶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::ListWorkflowStepsResponse`"))),
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::ListWorkflowStepsResponse`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<WorkflowStepsServiceListError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent { status, content, entity }))
}
}
/// Pushes overlapping steps away from a given anchor step using iterative radial repulsion. The anchor step stays fixed. Use after adding or moving individual steps to preserve the existing layout.
pub async fn workflow_steps_service_resolve_step_collisions(configuration: &configuration::Configuration, link_id: &str, step_id: &str, body: serde_json::Value) -> Result<models::ResolveStepCollisionsResponse, Error<WorkflowStepsServiceResolveStepCollisionsError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_link_id = link_id;
let p_path_step_id = step_id;
let p_body_body = body;
let uri_str = format!("{}/v1/links/{linkId}/workflow-steps/{stepId}/resolve-collisions", configuration.base_path, linkId=crate::apis::urlencode(p_path_link_id), stepId=crate::apis::urlencode(p_path_step_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_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::ResolveStepCollisionsResponse`"))),
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::ResolveStepCollisionsResponse`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<WorkflowStepsServiceResolveStepCollisionsError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent { status, content, entity }))
}
}
/// Updates an existing workflow step for a link.
pub async fn workflow_steps_service_update(configuration: &configuration::Configuration, link_id: &str, id: &str, workflow_steps_service_update_body: models::WorkflowStepsServiceUpdateBody) -> Result<models::UpdateWorkflowStepResponse, Error<WorkflowStepsServiceUpdateError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_link_id = link_id;
let p_path_id = id;
let p_body_workflow_steps_service_update_body = workflow_steps_service_update_body;
let uri_str = format!("{}/v1/links/{linkId}/workflow-steps/{id}", configuration.base_path, linkId=crate::apis::urlencode(p_path_link_id), id=crate::apis::urlencode(p_path_id));
let mut req_builder = configuration.client.request(reqwest::Method::PATCH, &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_workflow_steps_service_update_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::UpdateWorkflowStepResponse`"))),
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::UpdateWorkflowStepResponse`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<WorkflowStepsServiceUpdateError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent { status, content, entity }))
}
}
pub async fn workflow_steps_service_validate_workflow(configuration: &configuration::Configuration, link_id: &str) -> Result<models::ValidateWorkflowResponse, Error<WorkflowStepsServiceValidateWorkflowError>> {
// add a prefix to parameters to efficiently prevent name collisions
let p_path_link_id = link_id;
let uri_str = format!("{}/v1/links/{linkId}/workflow-steps/validate", configuration.base_path, linkId=crate::apis::urlencode(p_path_link_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::ValidateWorkflowResponse`"))),
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::ValidateWorkflowResponse`")))),
}
} else {
let content = resp.text().await?;
let entity: Option<WorkflowStepsServiceValidateWorkflowError> = serde_json::from_str(&content).ok();
Err(Error::ResponseError(ResponseContent { status, content, entity }))
}
}