reflow_api_services 0.2.0

#![allow(clippy::all, unused_imports, dead_code)]

//! Auto-generated API actors for GitLab
//!
//! Service: GitLab (gitlab)
//! DevOps platform with CI/CD and code hosting
//!
//! Required env var: GITLAB_API_KEY (OAuth2 access token)
//!
//! Generated by api-schema-gen codegen — do not edit manually.

use crate::{Actor, ActorBehavior, Message, Port};
use anyhow::{Error, Result};
use reflow_actor::{message::EncodableValue, ActorContext};
use reflow_actor_macro::actor;
use serde_json::{json, Value};
use std::collections::HashMap;
use std::time::Duration;

const BASE_URL: &str = "https://gitlab.com/api/v4";
const ENV_KEY: &str = "GITLAB_API_KEY";

/// Apply authentication to the request builder.
fn apply_auth(
    config: &reflow_actor::ActorConfig,
    mut builder: reqwest::RequestBuilder,
) -> Result<reqwest::RequestBuilder> {
    let credential = config
        .get_config_or_env(ENV_KEY)
        .ok_or_else(|| anyhow::anyhow!("Missing env var: {}", ENV_KEY))?;
    builder = builder.header("Authorization", format!("Bearer {}", credential));
    Ok(builder)
}

/// list projects via GitLab API
///
/// Method: GET /projects
#[actor(
    GitlabListProjectsActor,
    inports::<100>(owned, membership),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_list_projects(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/projects".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("owned") {
        query_pairs.push(("owned", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("membership") {
        query_pairs.push(("membership", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /projects failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// create issue via GitLab API
///
/// Method: POST /projects/{id}/issues
#[actor(
    GitlabCreateIssueActor,
    inports::<100>(id, title, description),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_create_issue(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/projects/{id}/issues".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("title") {
        body.insert("title".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("description") {
        body.insert("description".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /projects/{{id}}/issues failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// create merge_request via GitLab API
///
/// Method: POST /projects/{id}/merge_requests
#[actor(
    GitlabCreateMergeRequestActor,
    inports::<100>(id, source_branch, target_branch, title),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_create_merge_request(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/projects/{id}/merge_requests".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("source_branch") {
        body.insert("source_branch".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("target_branch") {
        body.insert("target_branch".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("title") {
        body.insert("title".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("POST /projects/{{id}}/merge_requests failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Get the list of batched background migrations
///
/// Method: GET /admin/batched_background_migrations
#[actor(
    GitlabReadApiV4AdminBatchedBackgroundMigrationsActor,
    inports::<100>(database),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_admin_batched_background_migrations(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/admin/batched_background_migrations".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("database") {
        query_pairs.push(("database", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("GET /admin/batched_background_migrations failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Retrieve a batched background migration
///
/// Method: GET /admin/batched_background_migrations/{id}
#[actor(
    GitlabReadApiV4AdminBatchedBackgroundMigrationsIdActor,
    inports::<100>(database, id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_admin_batched_background_migrations_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/admin/batched_background_migrations/{id}".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("database") {
        query_pairs.push(("database", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "GET /admin/batched_background_migrations/{{id}} failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Pause a batched background migration
///
/// Method: PUT /admin/batched_background_migrations/{id}/pause
#[actor(
    GitlabUpdateApiV4AdminBatchedBackgroundMigrationsIdPauseActor,
    inports::<100>(id, database),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_update_api_v4_admin_batched_background_migrations_id_pause(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/admin/batched_background_migrations/{id}/pause".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.put(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("database") {
        body.insert("database".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "PUT /admin/batched_background_migrations/{{id}}/pause failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Resume a batched background migration
///
/// Method: PUT /admin/batched_background_migrations/{id}/resume
#[actor(
    GitlabUpdateApiV4AdminBatchedBackgroundMigrationsIdResumeActor,
    inports::<100>(id, database),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_update_api_v4_admin_batched_background_migrations_id_resume(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/admin/batched_background_migrations/{id}/resume".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.put(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("database") {
        body.insert("database".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "PUT /admin/batched_background_migrations/{{id}}/resume failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Create a new instance-level variable
///
/// Method: POST /admin/ci/variables
#[actor(
    GitlabCreateApiV4AdminCiVariablesActor,
    inports::<100>(raw, value, variable_type, masked, protected, key),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_create_api_v4_admin_ci_variables(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/admin/ci/variables".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("raw") {
        body.insert("raw".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("value") {
        body.insert("value".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("variable_type") {
        body.insert("variable_type".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("masked") {
        body.insert("masked".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("protected") {
        body.insert("protected".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("key") {
        body.insert("key".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /admin/ci/variables failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// List all instance-level variables
///
/// Method: GET /admin/ci/variables
#[actor(
    GitlabReadApiV4AdminCiVariablesActor,
    inports::<100>(page, per_page),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_admin_ci_variables(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/admin/ci/variables".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("page") {
        query_pairs.push(("page", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("per_page") {
        query_pairs.push(("per_page", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /admin/ci/variables failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Delete an existing instance-level variable
///
/// Method: DELETE /admin/ci/variables/{key}
#[actor(
    GitlabDeleteApiV4AdminCiVariablesKeyActor,
    inports::<100>(key),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_delete_api_v4_admin_ci_variables_key(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/admin/ci/variables/{key}".to_string();
    if let Some(val) = inputs.get("key") {
        endpoint = endpoint.replace("{{key}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.delete(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("DELETE /admin/ci/variables/{{key}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get the details of a specific instance-level variable
///
/// Method: GET /admin/ci/variables/{key}
#[actor(
    GitlabReadApiV4AdminCiVariablesKeyActor,
    inports::<100>(key),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_admin_ci_variables_key(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/admin/ci/variables/{key}".to_string();
    if let Some(val) = inputs.get("key") {
        endpoint = endpoint.replace("{{key}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /admin/ci/variables/{{key}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Update an instance-level variable
///
/// Method: PUT /admin/ci/variables/{key}
#[actor(
    GitlabUpdateApiV4AdminCiVariablesKeyActor,
    inports::<100>(key, value, masked, variable_type, protected, raw),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_update_api_v4_admin_ci_variables_key(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/admin/ci/variables/{key}".to_string();
    if let Some(val) = inputs.get("key") {
        endpoint = endpoint.replace("{{key}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.put(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("value") {
        body.insert("value".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("masked") {
        body.insert("masked".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("variable_type") {
        body.insert("variable_type".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("protected") {
        body.insert("protected".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("raw") {
        body.insert("raw".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("PUT /admin/ci/variables/{{key}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// List instance clusters
///
/// Method: GET /admin/clusters
#[actor(
    GitlabReadApiV4AdminClustersActor,
    inports::<100>(trigger),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_admin_clusters(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/admin/clusters".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /admin/clusters failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Add existing instance cluster
///
/// Method: POST /admin/clusters/add
#[actor(
    GitlabCreateApiV4AdminClustersAddActor,
    inports::<100>(platform_kubernetes_attributes_namespace, name, management_project_id, namespace_per_environment, domain, platform_kubernetes_attributes_api_url, environment_scope, managed, enabled, platform_kubernetes_attributes_token, platform_kubernetes_attributes_ca_cert, platform_kubernetes_attributes_authorization_type),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_create_api_v4_admin_clusters_add(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/admin/clusters/add".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("platform_kubernetes_attributes_namespace") {
        body.insert(
            "platform_kubernetes_attributes[namespace]".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("name") {
        body.insert("name".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("management_project_id") {
        body.insert("management_project_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("namespace_per_environment") {
        body.insert("namespace_per_environment".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("domain") {
        body.insert("domain".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("platform_kubernetes_attributes_api_url") {
        body.insert(
            "platform_kubernetes_attributes[api_url]".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("environment_scope") {
        body.insert("environment_scope".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("managed") {
        body.insert("managed".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("enabled") {
        body.insert("enabled".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("platform_kubernetes_attributes_token") {
        body.insert(
            "platform_kubernetes_attributes[token]".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("platform_kubernetes_attributes_ca_cert") {
        body.insert(
            "platform_kubernetes_attributes[ca_cert]".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("platform_kubernetes_attributes_authorization_type") {
        body.insert(
            "platform_kubernetes_attributes[authorization_type]".to_string(),
            val.clone().into(),
        );
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /admin/clusters/add failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Edit instance cluster
///
/// Method: PUT /admin/clusters/{cluster_id}
#[actor(
    GitlabUpdateApiV4AdminClustersClusterIdActor,
    inports::<100>(cluster_id, domain, namespace_per_environment, environment_scope, enabled, management_project_id, platform_kubernetes_attributes_namespace, name, platform_kubernetes_attributes_api_url, platform_kubernetes_attributes_ca_cert, managed, platform_kubernetes_attributes_token),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_update_api_v4_admin_clusters_cluster_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/admin/clusters/{cluster_id}".to_string();
    if let Some(val) = inputs.get("cluster_id") {
        endpoint = endpoint.replace("{{cluster_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.put(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("domain") {
        body.insert("domain".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("namespace_per_environment") {
        body.insert("namespace_per_environment".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("environment_scope") {
        body.insert("environment_scope".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("enabled") {
        body.insert("enabled".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("management_project_id") {
        body.insert("management_project_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("platform_kubernetes_attributes_namespace") {
        body.insert(
            "platform_kubernetes_attributes[namespace]".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("name") {
        body.insert("name".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("platform_kubernetes_attributes_api_url") {
        body.insert(
            "platform_kubernetes_attributes[api_url]".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("platform_kubernetes_attributes_ca_cert") {
        body.insert(
            "platform_kubernetes_attributes[ca_cert]".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("managed") {
        body.insert("managed".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("platform_kubernetes_attributes_token") {
        body.insert(
            "platform_kubernetes_attributes[token]".to_string(),
            val.clone().into(),
        );
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("PUT /admin/clusters/{{cluster_id}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get a single instance cluster
///
/// Method: GET /admin/clusters/{cluster_id}
#[actor(
    GitlabReadApiV4AdminClustersClusterIdActor,
    inports::<100>(cluster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_admin_clusters_cluster_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/admin/clusters/{cluster_id}".to_string();
    if let Some(val) = inputs.get("cluster_id") {
        endpoint = endpoint.replace("{{cluster_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /admin/clusters/{{cluster_id}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Delete instance cluster
///
/// Method: DELETE /admin/clusters/{cluster_id}
#[actor(
    GitlabDeleteApiV4AdminClustersClusterIdActor,
    inports::<100>(cluster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_delete_api_v4_admin_clusters_cluster_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/admin/clusters/{cluster_id}".to_string();
    if let Some(val) = inputs.get("cluster_id") {
        endpoint = endpoint.replace("{{cluster_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.delete(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("DELETE /admin/clusters/{{cluster_id}} failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Retrieve dictionary details
///
/// Method: GET /admin/databases/{database_name}/dictionary/tables/{table_name}
#[actor(
    GitlabReadApiV4AdminDatabasesDatabaseNameDictionaryTablesTableNameActor,
    inports::<100>(database_name, table_name),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_admin_databases_database_name_dictionary_tables_table_name(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint =
        "/admin/databases/{database_name}/dictionary/tables/{table_name}".to_string();
    if let Some(val) = inputs.get("database_name") {
        endpoint = endpoint.replace("{{database_name}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("table_name") {
        endpoint = endpoint.replace("{{table_name}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert("error".to_string(), Message::Error(format!("GET /admin/databases/{{database_name}}/dictionary/tables/{{table_name}} failed: {}", e).into()));
        }
    }

    Ok(output)
}

/// Mark the migration as successfully executed
///
/// Method: POST /admin/migrations/{timestamp}/mark
#[actor(
    GitlabCreateApiV4AdminMigrationsTimestampMarkActor,
    inports::<100>(timestamp, database),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_create_api_v4_admin_migrations_timestamp_mark(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/admin/migrations/{timestamp}/mark".to_string();
    if let Some(val) = inputs.get("timestamp") {
        endpoint = endpoint.replace("{{timestamp}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("database") {
        body.insert("database".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("POST /admin/migrations/{{timestamp}}/mark failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Modify appearance
///
/// Method: PUT /application/appearance
#[actor(
    GitlabUpdateApiV4ApplicationAppearanceActor,
    inports::<100>(favicon, pwa_short_name, header_logo, header_message, pwa_icon, new_project_guidelines, logo, description, email_header_and_footer_enabled, message_background_color, profile_image_guidelines, pwa_description, title, message_font_color, footer_message, pwa_name),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_update_api_v4_application_appearance(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/application/appearance".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.put(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("favicon") {
        body.insert("favicon".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("pwa_short_name") {
        body.insert("pwa_short_name".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("header_logo") {
        body.insert("header_logo".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("header_message") {
        body.insert("header_message".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("pwa_icon") {
        body.insert("pwa_icon".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("new_project_guidelines") {
        body.insert("new_project_guidelines".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("logo") {
        body.insert("logo".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("description") {
        body.insert("description".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("email_header_and_footer_enabled") {
        body.insert(
            "email_header_and_footer_enabled".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("message_background_color") {
        body.insert("message_background_color".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("profile_image_guidelines") {
        body.insert("profile_image_guidelines".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("pwa_description") {
        body.insert("pwa_description".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("title") {
        body.insert("title".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("message_font_color") {
        body.insert("message_font_color".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("footer_message") {
        body.insert("footer_message".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("pwa_name") {
        body.insert("pwa_name".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("PUT /application/appearance failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get the current appearance
///
/// Method: GET /application/appearance
#[actor(
    GitlabReadApiV4ApplicationAppearanceActor,
    inports::<100>(trigger),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_application_appearance(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/application/appearance".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /application/appearance failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get current plan limits
///
/// Method: GET /application/plan_limits
#[actor(
    GitlabReadApiV4ApplicationPlanLimitsActor,
    inports::<100>(plan_name),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_application_plan_limits(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/application/plan_limits".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("plan_name") {
        query_pairs.push(("plan_name", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /application/plan_limits failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Change plan limits
///
/// Method: PUT /application/plan_limits
#[actor(
    GitlabUpdateApiV4ApplicationPlanLimitsActor,
    inports::<100>(ci_registered_project_runners, ci_pipeline_schedules, ci_active_jobs, pypi_max_file_size, pipeline_hierarchy_size, helm_max_file_size, generic_packages_max_file_size, ci_needs_size_limit, plan_name, storage_size_limit, conan_max_file_size, terraform_module_max_file_size, ci_pipeline_size, ci_registered_group_runners, nuget_max_file_size, maven_max_file_size, notification_limit, npm_max_file_size, enforcement_limit, ci_project_subscriptions),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_update_api_v4_application_plan_limits(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/application/plan_limits".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.put(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("ci_registered_project_runners") {
        body.insert(
            "ci_registered_project_runners".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("ci_pipeline_schedules") {
        body.insert("ci_pipeline_schedules".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("ci_active_jobs") {
        body.insert("ci_active_jobs".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("pypi_max_file_size") {
        body.insert("pypi_max_file_size".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("pipeline_hierarchy_size") {
        body.insert("pipeline_hierarchy_size".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("helm_max_file_size") {
        body.insert("helm_max_file_size".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("generic_packages_max_file_size") {
        body.insert(
            "generic_packages_max_file_size".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("ci_needs_size_limit") {
        body.insert("ci_needs_size_limit".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("plan_name") {
        body.insert("plan_name".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("storage_size_limit") {
        body.insert("storage_size_limit".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("conan_max_file_size") {
        body.insert("conan_max_file_size".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("terraform_module_max_file_size") {
        body.insert(
            "terraform_module_max_file_size".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("ci_pipeline_size") {
        body.insert("ci_pipeline_size".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("ci_registered_group_runners") {
        body.insert(
            "ci_registered_group_runners".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("nuget_max_file_size") {
        body.insert("nuget_max_file_size".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("maven_max_file_size") {
        body.insert("maven_max_file_size".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("notification_limit") {
        body.insert("notification_limit".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("npm_max_file_size") {
        body.insert("npm_max_file_size".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("enforcement_limit") {
        body.insert("enforcement_limit".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("ci_project_subscriptions") {
        body.insert("ci_project_subscriptions".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("PUT /application/plan_limits failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Create a new application
///
/// Method: POST /applications
#[actor(
    GitlabCreateApiV4ApplicationsActor,
    inports::<100>(scopes, redirect_uri, confidential, name),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_create_api_v4_applications(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/applications".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("scopes") {
        body.insert("scopes".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("redirect_uri") {
        body.insert("redirect_uri".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("confidential") {
        body.insert("confidential".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("name") {
        body.insert("name".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /applications failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get applications
///
/// Method: GET /applications
#[actor(
    GitlabReadApiV4ApplicationsActor,
    inports::<100>(trigger),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_applications(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/applications".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /applications failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Delete an application
///
/// Method: DELETE /applications/{id}
#[actor(
    GitlabDeleteApiV4ApplicationsIdActor,
    inports::<100>(id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_delete_api_v4_applications_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/applications/{id}".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.delete(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("DELETE /applications/{{id}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Return avatar url for a user
///
/// Method: GET /avatar
#[actor(
    GitlabReadApiV4AvatarActor,
    inports::<100>(email, size),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_avatar(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/avatar".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("email") {
        query_pairs.push(("email", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("size") {
        query_pairs.push(("size", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /avatar failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Create a broadcast message
///
/// Method: POST /broadcast_messages
#[actor(
    GitlabCreateApiV4BroadcastMessagesActor,
    inports::<100>(color, broadcast_type, ends_at, message, starts_at, target_access_levels, dismissable, font, target_path),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_create_api_v4_broadcast_messages(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/broadcast_messages".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("color") {
        body.insert("color".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("broadcast_type") {
        body.insert("broadcast_type".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("ends_at") {
        body.insert("ends_at".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("message") {
        body.insert("message".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("starts_at") {
        body.insert("starts_at".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("target_access_levels") {
        body.insert("target_access_levels".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("dismissable") {
        body.insert("dismissable".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("font") {
        body.insert("font".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("target_path") {
        body.insert("target_path".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /broadcast_messages failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get all broadcast messages
///
/// Method: GET /broadcast_messages
#[actor(
    GitlabReadApiV4BroadcastMessagesActor,
    inports::<100>(page, per_page),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_broadcast_messages(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/broadcast_messages".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("page") {
        query_pairs.push(("page", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("per_page") {
        query_pairs.push(("per_page", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /broadcast_messages failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get a specific broadcast message
///
/// Method: GET /broadcast_messages/{id}
#[actor(
    GitlabReadApiV4BroadcastMessagesIdActor,
    inports::<100>(id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_broadcast_messages_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/broadcast_messages/{id}".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /broadcast_messages/{{id}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Delete a broadcast message
///
/// Method: DELETE /broadcast_messages/{id}
#[actor(
    GitlabDeleteApiV4BroadcastMessagesIdActor,
    inports::<100>(id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_delete_api_v4_broadcast_messages_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/broadcast_messages/{id}".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.delete(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("DELETE /broadcast_messages/{{id}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Update a broadcast message
///
/// Method: PUT /broadcast_messages/{id}
#[actor(
    GitlabUpdateApiV4BroadcastMessagesIdActor,
    inports::<100>(id, font, starts_at, color, target_path, target_access_levels, broadcast_type, ends_at, message, dismissable),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_update_api_v4_broadcast_messages_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/broadcast_messages/{id}".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.put(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("font") {
        body.insert("font".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("starts_at") {
        body.insert("starts_at".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("color") {
        body.insert("color".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("target_path") {
        body.insert("target_path".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("target_access_levels") {
        body.insert("target_access_levels".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("broadcast_type") {
        body.insert("broadcast_type".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("ends_at") {
        body.insert("ends_at".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("message") {
        body.insert("message".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("dismissable") {
        body.insert("dismissable".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("PUT /broadcast_messages/{{id}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// List all GitLab Migrations
///
/// Method: GET /bulk_imports
#[actor(
    GitlabReadApiV4BulkImportsActor,
    inports::<100>(page, per_page, sort, status),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_bulk_imports(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/bulk_imports".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("page") {
        query_pairs.push(("page", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("per_page") {
        query_pairs.push(("per_page", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("sort") {
        query_pairs.push(("sort", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("status") {
        query_pairs.push(("status", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /bulk_imports failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Start a new GitLab Migration
///
/// Method: POST /bulk_imports
#[actor(
    GitlabCreateApiV4BulkImportsActor,
    inports::<100>(configuration_url, entities_source_full_path, configuration_access_token, entities_destination_name, entities_destination_slug, entities_destination_namespace, entities_source_type, entities_migrate_projects),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_create_api_v4_bulk_imports(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/bulk_imports".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("configuration_url") {
        body.insert("configuration[url]".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("entities_source_full_path") {
        body.insert("entities[source_full_path]".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("configuration_access_token") {
        body.insert(
            "configuration[access_token]".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("entities_destination_name") {
        body.insert("entities[destination_name]".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("entities_destination_slug") {
        body.insert("entities[destination_slug]".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("entities_destination_namespace") {
        body.insert(
            "entities[destination_namespace]".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("entities_source_type") {
        body.insert("entities[source_type]".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("entities_migrate_projects") {
        body.insert("entities[migrate_projects]".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /bulk_imports failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// List all GitLab Migrations' entities
///
/// Method: GET /bulk_imports/entities
#[actor(
    GitlabReadApiV4BulkImportsEntitiesActor,
    inports::<100>(page, per_page, sort, status),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_bulk_imports_entities(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/bulk_imports/entities".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("page") {
        query_pairs.push(("page", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("per_page") {
        query_pairs.push(("per_page", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("sort") {
        query_pairs.push(("sort", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("status") {
        query_pairs.push(("status", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /bulk_imports/entities failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get GitLab Migration details
///
/// Method: GET /bulk_imports/{import_id}
#[actor(
    GitlabReadApiV4BulkImportsImportIdActor,
    inports::<100>(import_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_bulk_imports_import_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/bulk_imports/{import_id}".to_string();
    if let Some(val) = inputs.get("import_id") {
        endpoint = endpoint.replace("{{import_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /bulk_imports/{{import_id}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// List GitLab Migration entities
///
/// Method: GET /bulk_imports/{import_id}/entities
#[actor(
    GitlabReadApiV4BulkImportsImportIdEntitiesActor,
    inports::<100>(import_id, status, page, per_page),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_bulk_imports_import_id_entities(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/bulk_imports/{import_id}/entities".to_string();
    if let Some(val) = inputs.get("import_id") {
        endpoint = endpoint.replace("{{import_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("status") {
        query_pairs.push(("status", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("page") {
        query_pairs.push(("page", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("per_page") {
        query_pairs.push(("per_page", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("GET /bulk_imports/{{import_id}}/entities failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Get GitLab Migration entity details
///
/// Method: GET /bulk_imports/{import_id}/entities/{entity_id}
#[actor(
    GitlabReadApiV4BulkImportsImportIdEntitiesEntityIdActor,
    inports::<100>(import_id, entity_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_bulk_imports_import_id_entities_entity_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/bulk_imports/{import_id}/entities/{entity_id}".to_string();
    if let Some(val) = inputs.get("import_id") {
        endpoint = endpoint.replace("{{import_id}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("entity_id") {
        endpoint = endpoint.replace("{{entity_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "GET /bulk_imports/{{import_id}}/entities/{{entity_id}} failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Requests access for the authenticated user to a group.
///
/// Method: POST /groups/{id}/access_requests
#[actor(
    GitlabCreateApiV4GroupsIdAccessRequestsActor,
    inports::<100>(id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_create_api_v4_groups_id_access_requests(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/groups/{id}/access_requests".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /groups/{{id}}/access_requests failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets a list of access requests for a group.
///
/// Method: GET /groups/{id}/access_requests
#[actor(
    GitlabReadApiV4GroupsIdAccessRequestsActor,
    inports::<100>(id, page, per_page),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_groups_id_access_requests(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/groups/{id}/access_requests".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("page") {
        query_pairs.push(("page", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("per_page") {
        query_pairs.push(("per_page", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /groups/{{id}}/access_requests failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Denies an access request for the given user.
///
/// Method: DELETE /groups/{id}/access_requests/{user_id}
#[actor(
    GitlabDeleteApiV4GroupsIdAccessRequestsUserIdActor,
    inports::<100>(id, user_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_delete_api_v4_groups_id_access_requests_user_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/groups/{id}/access_requests/{user_id}".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("user_id") {
        endpoint = endpoint.replace("{{user_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.delete(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "DELETE /groups/{{id}}/access_requests/{{user_id}} failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Approves an access request for the given user.
///
/// Method: PUT /groups/{id}/access_requests/{user_id}/approve
#[actor(
    GitlabUpdateApiV4GroupsIdAccessRequestsUserIdApproveActor,
    inports::<100>(id, user_id, access_level),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_update_api_v4_groups_id_access_requests_user_id_approve(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/groups/{id}/access_requests/{user_id}/approve".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("user_id") {
        endpoint = endpoint.replace("{{user_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.put(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("access_level") {
        body.insert("access_level".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "PUT /groups/{{id}}/access_requests/{{user_id}}/approve failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Gets a list of group badges viewable by the authenticated user.
///
/// Method: GET /groups/{id}/badges
#[actor(
    GitlabReadApiV4GroupsIdBadgesActor,
    inports::<100>(id, page, per_page, name),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_groups_id_badges(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/groups/{id}/badges".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("page") {
        query_pairs.push(("page", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("per_page") {
        query_pairs.push(("per_page", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("name") {
        query_pairs.push(("name", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /groups/{{id}}/badges failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Adds a badge to a group.
///
/// Method: POST /groups/{id}/badges
#[actor(
    GitlabCreateApiV4GroupsIdBadgesActor,
    inports::<100>(id, link_url, name, image_url),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_create_api_v4_groups_id_badges(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/groups/{id}/badges".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("link_url") {
        body.insert("link_url".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("name") {
        body.insert("name".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("image_url") {
        body.insert("image_url".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /groups/{{id}}/badges failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Preview a badge from a group.
///
/// Method: GET /groups/{id}/badges/render
#[actor(
    GitlabReadApiV4GroupsIdBadgesRenderActor,
    inports::<100>(id, link_url, image_url),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_groups_id_badges_render(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/groups/{id}/badges/render".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("link_url") {
        query_pairs.push(("link_url", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("image_url") {
        query_pairs.push(("image_url", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /groups/{{id}}/badges/render failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Removes a badge from the group.
///
/// Method: DELETE /groups/{id}/badges/{badge_id}
#[actor(
    GitlabDeleteApiV4GroupsIdBadgesBadgeIdActor,
    inports::<100>(id, badge_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_delete_api_v4_groups_id_badges_badge_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/groups/{id}/badges/{badge_id}".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("badge_id") {
        endpoint = endpoint.replace("{{badge_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.delete(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("DELETE /groups/{{id}}/badges/{{badge_id}} failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Gets a badge of a group.
///
/// Method: GET /groups/{id}/badges/{badge_id}
#[actor(
    GitlabReadApiV4GroupsIdBadgesBadgeIdActor,
    inports::<100>(id, badge_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_groups_id_badges_badge_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/groups/{id}/badges/{badge_id}".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("badge_id") {
        endpoint = endpoint.replace("{{badge_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("GET /groups/{{id}}/badges/{{badge_id}} failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Updates a badge of a group.
///
/// Method: PUT /groups/{id}/badges/{badge_id}
#[actor(
    GitlabUpdateApiV4GroupsIdBadgesBadgeIdActor,
    inports::<100>(id, badge_id, name, image_url, link_url),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_update_api_v4_groups_id_badges_badge_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/groups/{id}/badges/{badge_id}".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("badge_id") {
        endpoint = endpoint.replace("{{badge_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.put(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("name") {
        body.insert("name".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("image_url") {
        body.insert("image_url".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("link_url") {
        body.insert("link_url".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("PUT /groups/{{id}}/badges/{{badge_id}} failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Retrieve metadata information for this GitLab instance
///
/// Method: GET /metadata
#[actor(
    GitlabReadApiV4MetadataActor,
    inports::<100>(trigger),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_metadata(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/metadata".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /metadata failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets a list of access requests for a project.
///
/// Method: GET /projects/{id}/access_requests
#[actor(
    GitlabReadApiV4ProjectsIdAccessRequestsActor,
    inports::<100>(page, per_page),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_projects_id_access_requests(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/projects/{id}/access_requests".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("page") {
        query_pairs.push(("page", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("per_page") {
        query_pairs.push(("per_page", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("GET /projects/{{id}}/access_requests failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Requests access for the authenticated user to a project.
///
/// Method: POST /projects/{id}/access_requests
#[actor(
    GitlabCreateApiV4ProjectsIdAccessRequestsActor,
    inports::<100>(trigger),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_create_api_v4_projects_id_access_requests(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/projects/{id}/access_requests".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("POST /projects/{{id}}/access_requests failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Denies an access request for the given user.
///
/// Method: DELETE /projects/{id}/access_requests/{user_id}
#[actor(
    GitlabDeleteApiV4ProjectsIdAccessRequestsUserIdActor,
    inports::<100>(user_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_delete_api_v4_projects_id_access_requests_user_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/projects/{id}/access_requests/{user_id}".to_string();
    if let Some(val) = inputs.get("user_id") {
        endpoint = endpoint.replace("{{user_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.delete(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "DELETE /projects/{{id}}/access_requests/{{user_id}} failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Approves an access request for the given user.
///
/// Method: PUT /projects/{id}/access_requests/{user_id}/approve
#[actor(
    GitlabUpdateApiV4ProjectsIdAccessRequestsUserIdApproveActor,
    inports::<100>(user_id, access_level),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_update_api_v4_projects_id_access_requests_user_id_approve(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/projects/{id}/access_requests/{user_id}/approve".to_string();
    if let Some(val) = inputs.get("user_id") {
        endpoint = endpoint.replace("{{user_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.put(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("access_level") {
        body.insert("access_level".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "PUT /projects/{{id}}/access_requests/{{user_id}}/approve failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Metric Images for alert
///
/// Method: GET /projects/{id}/alert_management_alerts/{alert_iid}/metric_images
#[actor(
    GitlabReadApiV4ProjectsIdAlertManagementAlertsAlertIidMetricImagesActor,
    inports::<100>(alert_iid),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_projects_id_alert_management_alerts_alert_iid_metric_images(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint =
        "/projects/{id}/alert_management_alerts/{alert_iid}/metric_images".to_string();
    if let Some(val) = inputs.get("alert_iid") {
        endpoint = endpoint.replace("{{alert_iid}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert("error".to_string(), Message::Error(format!("GET /projects/{{id}}/alert_management_alerts/{{alert_iid}}/metric_images failed: {}", e).into()));
        }
    }

    Ok(output)
}

/// Upload a metric image for an alert
///
/// Method: POST /projects/{id}/alert_management_alerts/{alert_iid}/metric_images
#[actor(
    GitlabCreateApiV4ProjectsIdAlertManagementAlertsAlertIidMetricImagesActor,
    inports::<100>(alert_iid, url, file, url_text),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_create_api_v4_projects_id_alert_management_alerts_alert_iid_metric_images(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint =
        "/projects/{id}/alert_management_alerts/{alert_iid}/metric_images".to_string();
    if let Some(val) = inputs.get("alert_iid") {
        endpoint = endpoint.replace("{{alert_iid}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("url") {
        body.insert("url".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("file") {
        body.insert("file".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("url_text") {
        body.insert("url_text".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert("error".to_string(), Message::Error(format!("POST /projects/{{id}}/alert_management_alerts/{{alert_iid}}/metric_images failed: {}", e).into()));
        }
    }

    Ok(output)
}

/// Workhorse authorize metric image file upload
///
/// Method: POST /projects/{id}/alert_management_alerts/{alert_iid}/metric_images/authorize
#[actor(
    GitlabCreateApiV4ProjectsIdAlertManagementAlertsAlertIidMetricImagesAuthorizeActor,
    inports::<100>(alert_iid),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_create_api_v4_projects_id_alert_management_alerts_alert_iid_metric_images_authorize(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint =
        "/projects/{id}/alert_management_alerts/{alert_iid}/metric_images/authorize".to_string();
    if let Some(val) = inputs.get("alert_iid") {
        endpoint = endpoint.replace("{{alert_iid}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert("error".to_string(), Message::Error(format!("POST /projects/{{id}}/alert_management_alerts/{{alert_iid}}/metric_images/authorize failed: {}", e).into()));
        }
    }

    Ok(output)
}

/// Update a metric image for an alert
///
/// Method: PUT /projects/{id}/alert_management_alerts/{alert_iid}/metric_images/{metric_image_id}
#[actor(
    GitlabUpdateApiV4ProjectsIdAlertManagementAlertsAlertIidMetricImagesMetricImageIdActor,
    inports::<100>(alert_iid, metric_image_id, url_text, url),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_update_api_v4_projects_id_alert_management_alerts_alert_iid_metric_images_metric_image_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint =
        "/projects/{id}/alert_management_alerts/{alert_iid}/metric_images/{metric_image_id}"
            .to_string();
    if let Some(val) = inputs.get("alert_iid") {
        endpoint = endpoint.replace("{{alert_iid}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("metric_image_id") {
        endpoint = endpoint.replace("{{metric_image_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.put(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("url_text") {
        body.insert("url_text".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("url") {
        body.insert("url".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert("error".to_string(), Message::Error(format!("PUT /projects/{{id}}/alert_management_alerts/{{alert_iid}}/metric_images/{{metric_image_id}} failed: {}", e).into()));
        }
    }

    Ok(output)
}

/// Remove a metric image for an alert
///
/// Method: DELETE /projects/{id}/alert_management_alerts/{alert_iid}/metric_images/{metric_image_id}
#[actor(
    GitlabDeleteApiV4ProjectsIdAlertManagementAlertsAlertIidMetricImagesMetricImageIdActor,
    inports::<100>(alert_iid, metric_image_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_delete_api_v4_projects_id_alert_management_alerts_alert_iid_metric_images_metric_image_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint =
        "/projects/{id}/alert_management_alerts/{alert_iid}/metric_images/{metric_image_id}"
            .to_string();
    if let Some(val) = inputs.get("alert_iid") {
        endpoint = endpoint.replace("{{alert_iid}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("metric_image_id") {
        endpoint = endpoint.replace("{{metric_image_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.delete(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert("error".to_string(), Message::Error(format!("DELETE /projects/{{id}}/alert_management_alerts/{{alert_iid}}/metric_images/{{metric_image_id}} failed: {}", e).into()));
        }
    }

    Ok(output)
}

/// Adds a badge to a project.
///
/// Method: POST /projects/{id}/badges
#[actor(
    GitlabCreateApiV4ProjectsIdBadgesActor,
    inports::<100>(link_url, image_url, name),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_create_api_v4_projects_id_badges(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/projects/{id}/badges".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("link_url") {
        body.insert("link_url".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("image_url") {
        body.insert("image_url".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("name") {
        body.insert("name".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /projects/{{id}}/badges failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets a list of project badges viewable by the authenticated user.
///
/// Method: GET /projects/{id}/badges
#[actor(
    GitlabReadApiV4ProjectsIdBadgesActor,
    inports::<100>(page, per_page, name),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_projects_id_badges(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/projects/{id}/badges".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("page") {
        query_pairs.push(("page", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("per_page") {
        query_pairs.push(("per_page", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("name") {
        query_pairs.push(("name", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /projects/{{id}}/badges failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Preview a badge from a project.
///
/// Method: GET /projects/{id}/badges/render
#[actor(
    GitlabReadApiV4ProjectsIdBadgesRenderActor,
    inports::<100>(link_url, image_url),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_projects_id_badges_render(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/projects/{id}/badges/render".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("link_url") {
        query_pairs.push(("link_url", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("image_url") {
        query_pairs.push(("image_url", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /projects/{{id}}/badges/render failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Updates a badge of a project.
///
/// Method: PUT /projects/{id}/badges/{badge_id}
#[actor(
    GitlabUpdateApiV4ProjectsIdBadgesBadgeIdActor,
    inports::<100>(badge_id, image_url, name, link_url),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_update_api_v4_projects_id_badges_badge_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/projects/{id}/badges/{badge_id}".to_string();
    if let Some(val) = inputs.get("badge_id") {
        endpoint = endpoint.replace("{{badge_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.put(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("image_url") {
        body.insert("image_url".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("name") {
        body.insert("name".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("link_url") {
        body.insert("link_url".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("PUT /projects/{{id}}/badges/{{badge_id}} failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Removes a badge from the project.
///
/// Method: DELETE /projects/{id}/badges/{badge_id}
#[actor(
    GitlabDeleteApiV4ProjectsIdBadgesBadgeIdActor,
    inports::<100>(badge_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_delete_api_v4_projects_id_badges_badge_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/projects/{id}/badges/{badge_id}".to_string();
    if let Some(val) = inputs.get("badge_id") {
        endpoint = endpoint.replace("{{badge_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.delete(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("DELETE /projects/{{id}}/badges/{{badge_id}} failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Gets a badge of a project.
///
/// Method: GET /projects/{id}/badges/{badge_id}
#[actor(
    GitlabReadApiV4ProjectsIdBadgesBadgeIdActor,
    inports::<100>(badge_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_projects_id_badges_badge_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/projects/{id}/badges/{badge_id}".to_string();
    if let Some(val) = inputs.get("badge_id") {
        endpoint = endpoint.replace("{{badge_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("GET /projects/{{id}}/badges/{{badge_id}} failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// List jobs for a project
///
/// Method: GET /projects/{id}/jobs
#[actor(
    GitlabListProjectJobsActor,
    inports::<100>(scope),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_list_project_jobs(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/projects/{id}/jobs".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("scope") {
        query_pairs.push(("scope", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /projects/{{id}}/jobs failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get a single job by ID
///
/// Method: GET /projects/{id}/jobs/{job_id}
#[actor(
    GitlabReadSingleJobActor,
    inports::<100>(job_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_single_job(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/projects/{id}/jobs/{job_id}".to_string();
    if let Some(val) = inputs.get("job_id") {
        endpoint = endpoint.replace("{{job_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("GET /projects/{{id}}/jobs/{{job_id}} failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Run a manual job
///
/// Method: POST /projects/{id}/jobs/{job_id}/play
#[actor(
    GitlabCreateJobsActor,
    inports::<100>(job_id, job_variables_attributes),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_create_jobs(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/projects/{id}/jobs/{job_id}/play".to_string();
    if let Some(val) = inputs.get("job_id") {
        endpoint = endpoint.replace("{{job_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("job_variables_attributes") {
        query_pairs.push(("job_variables_attributes", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("POST /projects/{{id}}/jobs/{{job_id}}/play failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Get a project repository branches
///
/// Method: GET /projects/{id}/repository/branches
#[actor(
    GitlabReadApiV4ProjectsIdRepositoryBranchesActor,
    inports::<100>(page, per_page, search, regex, sort, page_token),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_projects_id_repository_branches(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/projects/{id}/repository/branches".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("page") {
        query_pairs.push(("page", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("per_page") {
        query_pairs.push(("per_page", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("search") {
        query_pairs.push(("search", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("regex") {
        query_pairs.push(("regex", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("sort") {
        query_pairs.push(("sort", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("page_token") {
        query_pairs.push(("page_token", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("GET /projects/{{id}}/repository/branches failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Create branch
///
/// Method: POST /projects/{id}/repository/branches
#[actor(
    GitlabCreateApiV4ProjectsIdRepositoryBranchesActor,
    inports::<100>(branch, ref_),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_create_api_v4_projects_id_repository_branches(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/projects/{id}/repository/branches".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("branch") {
        query_pairs.push(("branch", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("ref_") {
        query_pairs.push(("ref", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("POST /projects/{{id}}/repository/branches failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Get a single repository branch
///
/// Method: GET /projects/{id}/repository/branches/{branch}
#[actor(
    GitlabReadApiV4ProjectsIdRepositoryBranchesBranchActor,
    inports::<100>(branch),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_projects_id_repository_branches_branch(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/projects/{id}/repository/branches/{branch}".to_string();
    if let Some(val) = inputs.get("branch") {
        endpoint = endpoint.replace("{{branch}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "GET /projects/{{id}}/repository/branches/{{branch}} failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Delete a branch
///
/// Method: DELETE /projects/{id}/repository/branches/{branch}
#[actor(
    GitlabDeleteApiV4ProjectsIdRepositoryBranchesBranchActor,
    inports::<100>(branch),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_delete_api_v4_projects_id_repository_branches_branch(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/projects/{id}/repository/branches/{branch}".to_string();
    if let Some(val) = inputs.get("branch") {
        endpoint = endpoint.replace("{{branch}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.delete(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "DELETE /projects/{{id}}/repository/branches/{{branch}} failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Check if a branch exists
///
/// Method: HEAD /projects/{id}/repository/branches/{branch}
#[actor(
    GitlabReadBranchesActor,
    inports::<100>(branch),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_branches(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/projects/{id}/repository/branches/{branch}".to_string();
    if let Some(val) = inputs.get("branch") {
        endpoint = endpoint.replace("{{branch}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.head(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "HEAD /projects/{{id}}/repository/branches/{{branch}} failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Protect a single branch
///
/// Method: PUT /projects/{id}/repository/branches/{branch}/protect
#[actor(
    GitlabUpdateApiV4ProjectsIdRepositoryBranchesBranchProtectActor,
    inports::<100>(branch, developers_can_push, developers_can_merge),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_update_api_v4_projects_id_repository_branches_branch_protect(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/projects/{id}/repository/branches/{branch}/protect".to_string();
    if let Some(val) = inputs.get("branch") {
        endpoint = endpoint.replace("{{branch}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.put(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("developers_can_push") {
        body.insert("developers_can_push".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("developers_can_merge") {
        body.insert("developers_can_merge".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "PUT /projects/{{id}}/repository/branches/{{branch}}/protect failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Unprotect a single branch
///
/// Method: PUT /projects/{id}/repository/branches/{branch}/unprotect
#[actor(
    GitlabUpdateApiV4ProjectsIdRepositoryBranchesBranchUnprotectActor,
    inports::<100>(branch),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_update_api_v4_projects_id_repository_branches_branch_unprotect(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/projects/{id}/repository/branches/{branch}/unprotect".to_string();
    if let Some(val) = inputs.get("branch") {
        endpoint = endpoint.replace("{{branch}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.put(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "PUT /projects/{{id}}/repository/branches/{{branch}}/unprotect failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Delete all merged branches
///
/// Method: DELETE /projects/{id}/repository/merged_branches
#[actor(
    GitlabDeleteApiV4ProjectsIdRepositoryMergedBranchesActor,
    inports::<100>(trigger),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_delete_api_v4_projects_id_repository_merged_branches(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/projects/{id}/repository/merged_branches".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.delete(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "DELETE /projects/{{id}}/repository/merged_branches failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Retrieves version information for the GitLab instance
///
/// Method: GET /version
#[actor(
    GitlabReadApiV4VersionActor,
    inports::<100>(trigger),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn gitlab_read_api_v4_version(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/version".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /version failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}