linkbreakers 1.104.0

/*
 * Linkbreakers API
 *
 * This is a documentation of all the APIs of Linkbreakers
 *
 * The version of the OpenAPI document: 1.104.0
 * 
 * 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_add_relationship`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum WorkflowStepsServiceAddRelationshipError {
    DefaultResponse(models::ErrorResponse),
    UnknownValue(serde_json::Value),
}

/// 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_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_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_remove_relationship`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum WorkflowStepsServiceRemoveRelationshipError {
    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),
}


/// Creates a parent-child relationship between two workflow steps.  IMPORTANT: This endpoint cannot be used to create connections FROM composite nodes (forms, multi-links, conditions). Composite nodes manage their own routing through their payload structure (e.g., button.next_step_id, option.next_step_id).  Connections TO composite nodes are allowed. Only atomic nodes (redirects, passwords, etc.) can use this endpoint as the parent.
pub async fn workflow_steps_service_add_relationship(configuration: &configuration::Configuration, link_id: &str, parent_step_id: &str, workflow_steps_service_add_relationship_body: models::WorkflowStepsServiceAddRelationshipBody) -> Result<models::AddWorkflowStepRelationshipResponse, Error<WorkflowStepsServiceAddRelationshipError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_link_id = link_id;
    let p_path_parent_step_id = parent_step_id;
    let p_body_workflow_steps_service_add_relationship_body = workflow_steps_service_add_relationship_body;

    let uri_str = format!("{}/v1/links/{linkId}/workflow-steps/{parentStepId}/relationships", configuration.base_path, linkId=crate::apis::urlencode(p_path_link_id), parentStepId=crate::apis::urlencode(p_path_parent_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_workflow_steps_service_add_relationship_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::AddWorkflowStepRelationshipResponse`"))),
            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::AddWorkflowStepRelationshipResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<WorkflowStepsServiceAddRelationshipError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// 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 }))
    }
}

/// 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 }))
    }
}

/// 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", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_page_token {
        req_builder = req_builder.query(&[("pageToken", &param_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 }))
    }
}

/// Removes a parent-child relationship between two workflow steps.  IMPORTANT: This endpoint cannot be used to remove connections FROM composite nodes (multi-links, conditions). Composite nodes manage their own routing through their payload structure. Use UpdateWorkflowStep to clear next_step_id in the payload instead.  Only atomic nodes (redirects, passwords, etc.) can use this endpoint as the parent.
pub async fn workflow_steps_service_remove_relationship(configuration: &configuration::Configuration, link_id: &str, parent_step_id: &str, child_step_id: &str) -> Result<models::RemoveWorkflowStepRelationshipResponse, Error<WorkflowStepsServiceRemoveRelationshipError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_link_id = link_id;
    let p_path_parent_step_id = parent_step_id;
    let p_path_child_step_id = child_step_id;

    let uri_str = format!("{}/v1/links/{linkId}/workflow-steps/{parentStepId}/relationships/{childStepId}", configuration.base_path, linkId=crate::apis::urlencode(p_path_link_id), parentStepId=crate::apis::urlencode(p_path_parent_step_id), childStepId=crate::apis::urlencode(p_path_child_step_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::RemoveWorkflowStepRelationshipResponse`"))),
            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::RemoveWorkflowStepRelationshipResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<WorkflowStepsServiceRemoveRelationshipError> = 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 }))
    }
}

/// Checks a workflow for disconnected steps, missing edges on composite nodes, and orphan steps not reachable from the entry point. Returns a list of issues.
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 }))
    }
}