pub enum GetInstanceOfIdError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status504,
    Status404 {
        error: String,
    },
    Status403 {
        error: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status500 {
        golem_error: crate::model::GolemError,
    },
    Status409 {
        error: String,
    },
}

impl From<reqwest::Error> for GetInstanceOfIdError {
    fn from(error: reqwest::Error) -> GetInstanceOfIdError {
        GetInstanceOfIdError::RequestFailure(error)
    }
}

impl From<reqwest::header::InvalidHeaderValue> for GetInstanceOfIdError {
    fn from(error: reqwest::header::InvalidHeaderValue) -> GetInstanceOfIdError {
        GetInstanceOfIdError::InvalidHeaderValue(error)
    }
}

impl GetInstanceOfIdError {
    pub fn to_instance_endpoint_error(&self) -> Option<crate::model::InstanceEndpointError> {
        match self {
            GetInstanceOfIdError::Status500 { golem_error } => Some(crate::model::InstanceEndpointError::Golem { golem_error: golem_error.clone() }), 
            GetInstanceOfIdError::Status404 { error } => Some(crate::model::InstanceEndpointError::NotFound { error: error.clone() }), 
            GetInstanceOfIdError::Status504 => Some(crate::model::InstanceEndpointError::GatewayTimeout), 
            GetInstanceOfIdError::Status403 { error } => Some(crate::model::InstanceEndpointError::LimitExceeded { error: error.clone() }), 
            GetInstanceOfIdError::Status409 { error } => Some(crate::model::InstanceEndpointError::AlreadyExists { error: error.clone() }), 
            GetInstanceOfIdError::Status400 { errors } => Some(crate::model::InstanceEndpointError::BadRequest { errors: errors.clone() }), 
            _ => None
        }
    }
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct InstanceEndpointErrorNotFoundPayload {
    pub error: String,
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct InstanceEndpointErrorLimitExceededPayload {
    pub error: String,
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct InstanceEndpointErrorBadRequestPayload {
    pub errors: Vec<String>,
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct InstanceEndpointErrorGolemPayload {
    #[serde(rename = "golemError")]
    pub golem_error: crate::model::GolemError,
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct InstanceEndpointErrorAlreadyExistsPayload {
    pub error: String,
}

pub enum LaunchNewInstanceError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status504,
    Status404 {
        error: String,
    },
    Status403 {
        error: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status500 {
        golem_error: crate::model::GolemError,
    },
    Status409 {
        error: String,
    },
}

impl From<reqwest::Error> for LaunchNewInstanceError {
    fn from(error: reqwest::Error) -> LaunchNewInstanceError {
        LaunchNewInstanceError::RequestFailure(error)
    }
}

impl From<reqwest::header::InvalidHeaderValue> for LaunchNewInstanceError {
    fn from(error: reqwest::header::InvalidHeaderValue) -> LaunchNewInstanceError {
        LaunchNewInstanceError::InvalidHeaderValue(error)
    }
}

impl LaunchNewInstanceError {
    pub fn to_instance_endpoint_error(&self) -> Option<crate::model::InstanceEndpointError> {
        match self {
            LaunchNewInstanceError::Status500 { golem_error } => Some(crate::model::InstanceEndpointError::Golem { golem_error: golem_error.clone() }), 
            LaunchNewInstanceError::Status404 { error } => Some(crate::model::InstanceEndpointError::NotFound { error: error.clone() }), 
            LaunchNewInstanceError::Status504 => Some(crate::model::InstanceEndpointError::GatewayTimeout), 
            LaunchNewInstanceError::Status403 { error } => Some(crate::model::InstanceEndpointError::LimitExceeded { error: error.clone() }), 
            LaunchNewInstanceError::Status409 { error } => Some(crate::model::InstanceEndpointError::AlreadyExists { error: error.clone() }), 
            LaunchNewInstanceError::Status400 { errors } => Some(crate::model::InstanceEndpointError::BadRequest { errors: errors.clone() }), 
            _ => None
        }
    }
}

pub enum DeleteInstanceError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status504,
    Status404 {
        error: String,
    },
    Status403 {
        error: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status500 {
        golem_error: crate::model::GolemError,
    },
    Status409 {
        error: String,
    },
}

impl From<reqwest::Error> for DeleteInstanceError {
    fn from(error: reqwest::Error) -> DeleteInstanceError {
        DeleteInstanceError::RequestFailure(error)
    }
}

impl From<reqwest::header::InvalidHeaderValue> for DeleteInstanceError {
    fn from(error: reqwest::header::InvalidHeaderValue) -> DeleteInstanceError {
        DeleteInstanceError::InvalidHeaderValue(error)
    }
}

impl DeleteInstanceError {
    pub fn to_instance_endpoint_error(&self) -> Option<crate::model::InstanceEndpointError> {
        match self {
            DeleteInstanceError::Status500 { golem_error } => Some(crate::model::InstanceEndpointError::Golem { golem_error: golem_error.clone() }), 
            DeleteInstanceError::Status404 { error } => Some(crate::model::InstanceEndpointError::NotFound { error: error.clone() }), 
            DeleteInstanceError::Status504 => Some(crate::model::InstanceEndpointError::GatewayTimeout), 
            DeleteInstanceError::Status403 { error } => Some(crate::model::InstanceEndpointError::LimitExceeded { error: error.clone() }), 
            DeleteInstanceError::Status409 { error } => Some(crate::model::InstanceEndpointError::AlreadyExists { error: error.clone() }), 
            DeleteInstanceError::Status400 { errors } => Some(crate::model::InstanceEndpointError::BadRequest { errors: errors.clone() }), 
            _ => None
        }
    }
}

pub enum GetInvocationKeyError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status504,
    Status404 {
        error: String,
    },
    Status403 {
        error: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status500 {
        golem_error: crate::model::GolemError,
    },
    Status409 {
        error: String,
    },
}

impl From<reqwest::Error> for GetInvocationKeyError {
    fn from(error: reqwest::Error) -> GetInvocationKeyError {
        GetInvocationKeyError::RequestFailure(error)
    }
}

impl From<reqwest::header::InvalidHeaderValue> for GetInvocationKeyError {
    fn from(error: reqwest::header::InvalidHeaderValue) -> GetInvocationKeyError {
        GetInvocationKeyError::InvalidHeaderValue(error)
    }
}

impl GetInvocationKeyError {
    pub fn to_instance_endpoint_error(&self) -> Option<crate::model::InstanceEndpointError> {
        match self {
            GetInvocationKeyError::Status500 { golem_error } => Some(crate::model::InstanceEndpointError::Golem { golem_error: golem_error.clone() }), 
            GetInvocationKeyError::Status404 { error } => Some(crate::model::InstanceEndpointError::NotFound { error: error.clone() }), 
            GetInvocationKeyError::Status504 => Some(crate::model::InstanceEndpointError::GatewayTimeout), 
            GetInvocationKeyError::Status403 { error } => Some(crate::model::InstanceEndpointError::LimitExceeded { error: error.clone() }), 
            GetInvocationKeyError::Status409 { error } => Some(crate::model::InstanceEndpointError::AlreadyExists { error: error.clone() }), 
            GetInvocationKeyError::Status400 { errors } => Some(crate::model::InstanceEndpointError::BadRequest { errors: errors.clone() }), 
            _ => None
        }
    }
}

pub enum InvokeAndAwaitFunctionError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status504,
    Status404 {
        error: String,
    },
    Status403 {
        error: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status500 {
        golem_error: crate::model::GolemError,
    },
    Status409 {
        error: String,
    },
}

impl From<reqwest::Error> for InvokeAndAwaitFunctionError {
    fn from(error: reqwest::Error) -> InvokeAndAwaitFunctionError {
        InvokeAndAwaitFunctionError::RequestFailure(error)
    }
}

impl From<reqwest::header::InvalidHeaderValue> for InvokeAndAwaitFunctionError {
    fn from(error: reqwest::header::InvalidHeaderValue) -> InvokeAndAwaitFunctionError {
        InvokeAndAwaitFunctionError::InvalidHeaderValue(error)
    }
}

impl InvokeAndAwaitFunctionError {
    pub fn to_instance_endpoint_error(&self) -> Option<crate::model::InstanceEndpointError> {
        match self {
            InvokeAndAwaitFunctionError::Status500 { golem_error } => Some(crate::model::InstanceEndpointError::Golem { golem_error: golem_error.clone() }), 
            InvokeAndAwaitFunctionError::Status404 { error } => Some(crate::model::InstanceEndpointError::NotFound { error: error.clone() }), 
            InvokeAndAwaitFunctionError::Status504 => Some(crate::model::InstanceEndpointError::GatewayTimeout), 
            InvokeAndAwaitFunctionError::Status403 { error } => Some(crate::model::InstanceEndpointError::LimitExceeded { error: error.clone() }), 
            InvokeAndAwaitFunctionError::Status409 { error } => Some(crate::model::InstanceEndpointError::AlreadyExists { error: error.clone() }), 
            InvokeAndAwaitFunctionError::Status400 { errors } => Some(crate::model::InstanceEndpointError::BadRequest { errors: errors.clone() }), 
            _ => None
        }
    }
}

pub enum InvokeFunctionError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status504,
    Status404 {
        error: String,
    },
    Status403 {
        error: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status500 {
        golem_error: crate::model::GolemError,
    },
    Status409 {
        error: String,
    },
}

impl From<reqwest::Error> for InvokeFunctionError {
    fn from(error: reqwest::Error) -> InvokeFunctionError {
        InvokeFunctionError::RequestFailure(error)
    }
}

impl From<reqwest::header::InvalidHeaderValue> for InvokeFunctionError {
    fn from(error: reqwest::header::InvalidHeaderValue) -> InvokeFunctionError {
        InvokeFunctionError::InvalidHeaderValue(error)
    }
}

impl InvokeFunctionError {
    pub fn to_instance_endpoint_error(&self) -> Option<crate::model::InstanceEndpointError> {
        match self {
            InvokeFunctionError::Status500 { golem_error } => Some(crate::model::InstanceEndpointError::Golem { golem_error: golem_error.clone() }), 
            InvokeFunctionError::Status404 { error } => Some(crate::model::InstanceEndpointError::NotFound { error: error.clone() }), 
            InvokeFunctionError::Status504 => Some(crate::model::InstanceEndpointError::GatewayTimeout), 
            InvokeFunctionError::Status403 { error } => Some(crate::model::InstanceEndpointError::LimitExceeded { error: error.clone() }), 
            InvokeFunctionError::Status409 { error } => Some(crate::model::InstanceEndpointError::AlreadyExists { error: error.clone() }), 
            InvokeFunctionError::Status400 { errors } => Some(crate::model::InstanceEndpointError::BadRequest { errors: errors.clone() }), 
            _ => None
        }
    }
}

pub enum CompleteInstancePromiseError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status504,
    Status404 {
        error: String,
    },
    Status403 {
        error: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status500 {
        golem_error: crate::model::GolemError,
    },
    Status409 {
        error: String,
    },
}

impl From<reqwest::Error> for CompleteInstancePromiseError {
    fn from(error: reqwest::Error) -> CompleteInstancePromiseError {
        CompleteInstancePromiseError::RequestFailure(error)
    }
}

impl From<reqwest::header::InvalidHeaderValue> for CompleteInstancePromiseError {
    fn from(error: reqwest::header::InvalidHeaderValue) -> CompleteInstancePromiseError {
        CompleteInstancePromiseError::InvalidHeaderValue(error)
    }
}

impl CompleteInstancePromiseError {
    pub fn to_instance_endpoint_error(&self) -> Option<crate::model::InstanceEndpointError> {
        match self {
            CompleteInstancePromiseError::Status500 { golem_error } => Some(crate::model::InstanceEndpointError::Golem { golem_error: golem_error.clone() }), 
            CompleteInstancePromiseError::Status404 { error } => Some(crate::model::InstanceEndpointError::NotFound { error: error.clone() }), 
            CompleteInstancePromiseError::Status504 => Some(crate::model::InstanceEndpointError::GatewayTimeout), 
            CompleteInstancePromiseError::Status403 { error } => Some(crate::model::InstanceEndpointError::LimitExceeded { error: error.clone() }), 
            CompleteInstancePromiseError::Status409 { error } => Some(crate::model::InstanceEndpointError::AlreadyExists { error: error.clone() }), 
            CompleteInstancePromiseError::Status400 { errors } => Some(crate::model::InstanceEndpointError::BadRequest { errors: errors.clone() }), 
            _ => None
        }
    }
}

pub enum InterruptInstanceError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status504,
    Status404 {
        error: String,
    },
    Status403 {
        error: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status500 {
        golem_error: crate::model::GolemError,
    },
    Status409 {
        error: String,
    },
}

impl From<reqwest::Error> for InterruptInstanceError {
    fn from(error: reqwest::Error) -> InterruptInstanceError {
        InterruptInstanceError::RequestFailure(error)
    }
}

impl From<reqwest::header::InvalidHeaderValue> for InterruptInstanceError {
    fn from(error: reqwest::header::InvalidHeaderValue) -> InterruptInstanceError {
        InterruptInstanceError::InvalidHeaderValue(error)
    }
}

impl InterruptInstanceError {
    pub fn to_instance_endpoint_error(&self) -> Option<crate::model::InstanceEndpointError> {
        match self {
            InterruptInstanceError::Status500 { golem_error } => Some(crate::model::InstanceEndpointError::Golem { golem_error: golem_error.clone() }), 
            InterruptInstanceError::Status404 { error } => Some(crate::model::InstanceEndpointError::NotFound { error: error.clone() }), 
            InterruptInstanceError::Status504 => Some(crate::model::InstanceEndpointError::GatewayTimeout), 
            InterruptInstanceError::Status403 { error } => Some(crate::model::InstanceEndpointError::LimitExceeded { error: error.clone() }), 
            InterruptInstanceError::Status409 { error } => Some(crate::model::InstanceEndpointError::AlreadyExists { error: error.clone() }), 
            InterruptInstanceError::Status400 { errors } => Some(crate::model::InstanceEndpointError::BadRequest { errors: errors.clone() }), 
            _ => None
        }
    }
}

pub enum GetInstanceMetadataError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status504,
    Status404 {
        error: String,
    },
    Status403 {
        error: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status500 {
        golem_error: crate::model::GolemError,
    },
    Status409 {
        error: String,
    },
}

impl From<reqwest::Error> for GetInstanceMetadataError {
    fn from(error: reqwest::Error) -> GetInstanceMetadataError {
        GetInstanceMetadataError::RequestFailure(error)
    }
}

impl From<reqwest::header::InvalidHeaderValue> for GetInstanceMetadataError {
    fn from(error: reqwest::header::InvalidHeaderValue) -> GetInstanceMetadataError {
        GetInstanceMetadataError::InvalidHeaderValue(error)
    }
}

impl GetInstanceMetadataError {
    pub fn to_instance_endpoint_error(&self) -> Option<crate::model::InstanceEndpointError> {
        match self {
            GetInstanceMetadataError::Status500 { golem_error } => Some(crate::model::InstanceEndpointError::Golem { golem_error: golem_error.clone() }), 
            GetInstanceMetadataError::Status404 { error } => Some(crate::model::InstanceEndpointError::NotFound { error: error.clone() }), 
            GetInstanceMetadataError::Status504 => Some(crate::model::InstanceEndpointError::GatewayTimeout), 
            GetInstanceMetadataError::Status403 { error } => Some(crate::model::InstanceEndpointError::LimitExceeded { error: error.clone() }), 
            GetInstanceMetadataError::Status409 { error } => Some(crate::model::InstanceEndpointError::AlreadyExists { error: error.clone() }), 
            GetInstanceMetadataError::Status400 { errors } => Some(crate::model::InstanceEndpointError::BadRequest { errors: errors.clone() }), 
            _ => None
        }
    }
}

#[async_trait::async_trait]
pub trait Instance {
    async fn get_instance_of_id(&self, worker_id: &str, authorization: &str) -> Result<crate::model::ComponentInstance, GetInstanceOfIdError>;
    async fn launch_new_instance(&self, template_id: &str, worker_name: &str, args: Option<&str>, env: Option<&str>, authorization: &str) -> Result<crate::model::ComponentInstance, LaunchNewInstanceError>;
    async fn delete_instance(&self, template_id: &str, worker_name: &str, authorization: &str) -> Result<(), DeleteInstanceError>;
    async fn get_invocation_key(&self, template_id: &str, worker_name: &str, authorization: &str) -> Result<crate::model::InvocationKey, GetInvocationKeyError>;
    async fn invoke_and_await_function(&self, template_id: &str, worker_name: &str, invocation_key: &str, function: &str, calling_convention: Option<&str>, field0: crate::model::InvokeParameters, authorization: &str) -> Result<crate::model::InvokeResult, InvokeAndAwaitFunctionError>;
    async fn invoke_function(&self, template_id: &str, worker_name: &str, function: &str, field0: crate::model::InvokeParameters, authorization: &str) -> Result<(), InvokeFunctionError>;
    async fn complete_instance_promise(&self, template_id: &str, worker_name: &str, field0: crate::model::CompleteParameters, authorization: &str) -> Result<bool, CompleteInstancePromiseError>;
    async fn interrupt_instance(&self, template_id: &str, worker_name: &str, recover_immediately: Option<bool>, authorization: &str) -> Result<(), InterruptInstanceError>;
    async fn get_instance_metadata(&self, template_id: &str, worker_name: &str, authorization: &str) -> Result<crate::model::InstanceMetadata, GetInstanceMetadataError>;
}

#[derive(Clone, Debug)]
pub struct InstanceLive {
    pub base_url: reqwest::Url,
}

#[async_trait::async_trait]
impl Instance for InstanceLive {
    async fn get_instance_of_id(&self, worker_id: &str, authorization: &str) -> Result<crate::model::ComponentInstance, GetInstanceOfIdError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/workers/{worker_id}"));

        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        let result = reqwest::Client::builder()
            .build()?
            .get(url)
            .headers(headers)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<crate::model::ComponentInstance>().await?;
                Ok(body)
            }
            504 => Err(GetInstanceOfIdError::Status504), 
            404 => {
                let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
                Err(GetInstanceOfIdError::Status404 { error: body.error })
            }
            403 => {
                let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
                Err(GetInstanceOfIdError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
                Err(GetInstanceOfIdError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
                Err(GetInstanceOfIdError::Status500 { golem_error: body.golem_error })
            }
            409 => {
                let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
                Err(GetInstanceOfIdError::Status409 { error: body.error })
            }
            _ => Err(GetInstanceOfIdError::UnexpectedStatus(result.status()))
        }
    }

    async fn launch_new_instance(&self, template_id: &str, worker_name: &str, args: Option<&str>, env: Option<&str>, authorization: &str) -> Result<crate::model::ComponentInstance, LaunchNewInstanceError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/{template_id}/workers"));
        url.query_pairs_mut().append_pair("worker-name", &format!("{worker_name}"));
        if let Some(value) = args {
            url.query_pairs_mut().append_pair("args", &format!("{value}"));
        }
        if let Some(value) = env {
            url.query_pairs_mut().append_pair("env", &format!("{value}"));
        }
        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        let result = reqwest::Client::builder()
            .build()?
            .post(url)
            .headers(headers)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<crate::model::ComponentInstance>().await?;
                Ok(body)
            }
            504 => Err(LaunchNewInstanceError::Status504), 
            404 => {
                let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
                Err(LaunchNewInstanceError::Status404 { error: body.error })
            }
            403 => {
                let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
                Err(LaunchNewInstanceError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
                Err(LaunchNewInstanceError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
                Err(LaunchNewInstanceError::Status500 { golem_error: body.golem_error })
            }
            409 => {
                let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
                Err(LaunchNewInstanceError::Status409 { error: body.error })
            }
            _ => Err(LaunchNewInstanceError::UnexpectedStatus(result.status()))
        }
    }

    async fn delete_instance(&self, template_id: &str, worker_name: &str, authorization: &str) -> Result<(), DeleteInstanceError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/{template_id}/workers/{worker_name}"));

        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        let result = reqwest::Client::builder()
            .build()?
            .delete(url)
            .headers(headers)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<()>().await?;
                Ok(body)
            }
            504 => Err(DeleteInstanceError::Status504), 
            404 => {
                let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
                Err(DeleteInstanceError::Status404 { error: body.error })
            }
            403 => {
                let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
                Err(DeleteInstanceError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
                Err(DeleteInstanceError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
                Err(DeleteInstanceError::Status500 { golem_error: body.golem_error })
            }
            409 => {
                let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
                Err(DeleteInstanceError::Status409 { error: body.error })
            }
            _ => Err(DeleteInstanceError::UnexpectedStatus(result.status()))
        }
    }

    async fn get_invocation_key(&self, template_id: &str, worker_name: &str, authorization: &str) -> Result<crate::model::InvocationKey, GetInvocationKeyError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/{template_id}/workers/{worker_name}/key"));

        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        let result = reqwest::Client::builder()
            .build()?
            .post(url)
            .headers(headers)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<crate::model::InvocationKey>().await?;
                Ok(body)
            }
            504 => Err(GetInvocationKeyError::Status504), 
            404 => {
                let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
                Err(GetInvocationKeyError::Status404 { error: body.error })
            }
            403 => {
                let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
                Err(GetInvocationKeyError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
                Err(GetInvocationKeyError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
                Err(GetInvocationKeyError::Status500 { golem_error: body.golem_error })
            }
            409 => {
                let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
                Err(GetInvocationKeyError::Status409 { error: body.error })
            }
            _ => Err(GetInvocationKeyError::UnexpectedStatus(result.status()))
        }
    }

    async fn invoke_and_await_function(&self, template_id: &str, worker_name: &str, invocation_key: &str, function: &str, calling_convention: Option<&str>, field0: crate::model::InvokeParameters, authorization: &str) -> Result<crate::model::InvokeResult, InvokeAndAwaitFunctionError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/{template_id}/workers/{worker_name}/invoke-and-await"));
        url.query_pairs_mut().append_pair("invocation-key", &format!("{invocation_key}"));
        url.query_pairs_mut().append_pair("function", &format!("{function}"));
        if let Some(value) = calling_convention {
            url.query_pairs_mut().append_pair("calling-convention", &format!("{value}"));
        }
        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        let result = reqwest::Client::builder()
            .build()?
            .post(url)
            .headers(headers)
            .json(&field0)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<crate::model::InvokeResult>().await?;
                Ok(body)
            }
            504 => Err(InvokeAndAwaitFunctionError::Status504), 
            404 => {
                let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
                Err(InvokeAndAwaitFunctionError::Status404 { error: body.error })
            }
            403 => {
                let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
                Err(InvokeAndAwaitFunctionError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
                Err(InvokeAndAwaitFunctionError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
                Err(InvokeAndAwaitFunctionError::Status500 { golem_error: body.golem_error })
            }
            409 => {
                let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
                Err(InvokeAndAwaitFunctionError::Status409 { error: body.error })
            }
            _ => Err(InvokeAndAwaitFunctionError::UnexpectedStatus(result.status()))
        }
    }

    async fn invoke_function(&self, template_id: &str, worker_name: &str, function: &str, field0: crate::model::InvokeParameters, authorization: &str) -> Result<(), InvokeFunctionError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/{template_id}/workers/{worker_name}/invoke"));
        url.query_pairs_mut().append_pair("function", &format!("{function}"));
        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        let result = reqwest::Client::builder()
            .build()?
            .post(url)
            .headers(headers)
            .json(&field0)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<()>().await?;
                Ok(body)
            }
            504 => Err(InvokeFunctionError::Status504), 
            404 => {
                let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
                Err(InvokeFunctionError::Status404 { error: body.error })
            }
            403 => {
                let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
                Err(InvokeFunctionError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
                Err(InvokeFunctionError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
                Err(InvokeFunctionError::Status500 { golem_error: body.golem_error })
            }
            409 => {
                let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
                Err(InvokeFunctionError::Status409 { error: body.error })
            }
            _ => Err(InvokeFunctionError::UnexpectedStatus(result.status()))
        }
    }

    async fn complete_instance_promise(&self, template_id: &str, worker_name: &str, field0: crate::model::CompleteParameters, authorization: &str) -> Result<bool, CompleteInstancePromiseError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/{template_id}/workers/{worker_name}/complete"));

        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        let result = reqwest::Client::builder()
            .build()?
            .post(url)
            .headers(headers)
            .json(&field0)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<bool>().await?;
                Ok(body)
            }
            504 => Err(CompleteInstancePromiseError::Status504), 
            404 => {
                let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
                Err(CompleteInstancePromiseError::Status404 { error: body.error })
            }
            403 => {
                let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
                Err(CompleteInstancePromiseError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
                Err(CompleteInstancePromiseError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
                Err(CompleteInstancePromiseError::Status500 { golem_error: body.golem_error })
            }
            409 => {
                let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
                Err(CompleteInstancePromiseError::Status409 { error: body.error })
            }
            _ => Err(CompleteInstancePromiseError::UnexpectedStatus(result.status()))
        }
    }

    async fn interrupt_instance(&self, template_id: &str, worker_name: &str, recover_immediately: Option<bool>, authorization: &str) -> Result<(), InterruptInstanceError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/{template_id}/workers/{worker_name}/interrupt"));
        if let Some(value) = recover_immediately {
            url.query_pairs_mut().append_pair("recover-immediately", &format!("{value}"));
        }
        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        let result = reqwest::Client::builder()
            .build()?
            .post(url)
            .headers(headers)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<()>().await?;
                Ok(body)
            }
            504 => Err(InterruptInstanceError::Status504), 
            404 => {
                let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
                Err(InterruptInstanceError::Status404 { error: body.error })
            }
            403 => {
                let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
                Err(InterruptInstanceError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
                Err(InterruptInstanceError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
                Err(InterruptInstanceError::Status500 { golem_error: body.golem_error })
            }
            409 => {
                let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
                Err(InterruptInstanceError::Status409 { error: body.error })
            }
            _ => Err(InterruptInstanceError::UnexpectedStatus(result.status()))
        }
    }

    async fn get_instance_metadata(&self, template_id: &str, worker_name: &str, authorization: &str) -> Result<crate::model::InstanceMetadata, GetInstanceMetadataError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/{template_id}/workers/{worker_name}"));

        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        let result = reqwest::Client::builder()
            .build()?
            .get(url)
            .headers(headers)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<crate::model::InstanceMetadata>().await?;
                Ok(body)
            }
            504 => Err(GetInstanceMetadataError::Status504), 
            404 => {
                let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
                Err(GetInstanceMetadataError::Status404 { error: body.error })
            }
            403 => {
                let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
                Err(GetInstanceMetadataError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
                Err(GetInstanceMetadataError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
                Err(GetInstanceMetadataError::Status500 { golem_error: body.golem_error })
            }
            409 => {
                let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
                Err(GetInstanceMetadataError::Status409 { error: body.error })
            }
            _ => Err(GetInstanceMetadataError::UnexpectedStatus(result.status()))
        }
    }
}