reflow_api_services 0.2.1

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

//! Auto-generated API actors for Twitch
//!
//! Service: Twitch (twitch)
//! Live streaming platform API
//!
//! Required env var: TWITCH_API_KEY (OAuth2 access token)
//!
//! Generated by api-schema-gen codegen — do not edit manually.

use crate::{Actor, ActorBehavior, ClientBuilderExt, 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://api.twitch.tv/helix";
const ENV_KEY: &str = "TWITCH_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)
}

/// Gets information about one or more users.
///
/// Method: GET /users
#[actor(
    TwitchReadUsersActor,
    inports::<100>(id, login),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_users(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("id") {
        query_pairs.push(("id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("login") {
        query_pairs.push(("login", 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 /users failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets a list of all streams.
///
/// Method: GET /streams
#[actor(
    TwitchListStreamsActor,
    inports::<100>(game_id, language, first, user_id, user_login, type_, before, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_list_streams(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("game_id") {
        query_pairs.push(("game_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("language") {
        query_pairs.push(("language", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("user_id") {
        query_pairs.push(("user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("user_login") {
        query_pairs.push(("user_login", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("type_") {
        query_pairs.push(("type", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("before") {
        query_pairs.push(("before", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /streams failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets an analytics report for one or more extensions.
///
/// Method: GET /analytics/extensions
#[actor(
    TwitchReadExtensionAnalyticsActor,
    inports::<100>(extension_id, type_, started_at, ended_at, first, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_extension_analytics(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/analytics/extensions".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("extension_id") {
        query_pairs.push(("extension_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("type_") {
        query_pairs.push(("type", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("started_at") {
        query_pairs.push(("started_at", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("ended_at") {
        query_pairs.push(("ended_at", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /analytics/extensions failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets an analytics report for one or more games.
///
/// Method: GET /analytics/games
#[actor(
    TwitchReadGameAnalyticsActor,
    inports::<100>(game_id, type_, started_at, ended_at, first, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_game_analytics(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/analytics/games".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("game_id") {
        query_pairs.push(("game_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("type_") {
        query_pairs.push(("type", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("started_at") {
        query_pairs.push(("started_at", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("ended_at") {
        query_pairs.push(("ended_at", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /analytics/games failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// NEW Gets the authorization scopes that the specified user has granted the application.
///
/// Method: GET /authorization/users
#[actor(
    TwitchReadAuthorizationByUserActor,
    inports::<100>(user_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_authorization_by_user(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/authorization/users".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("user_id") {
        query_pairs.push(("user_id", 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 /authorization/users failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets a list of Cheermotes that users can use to cheer Bits.
///
/// Method: GET /bits/cheermotes
#[actor(
    TwitchReadCheermotesActor,
    inports::<100>(broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_cheermotes(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/bits/cheermotes".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", 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 /bits/cheermotes failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Adds or updates a Bits product that the extension created.
///
/// Method: PUT /bits/extensions
#[actor(
    TwitchUpdateExtensionBitsProductActor,
    inports::<100>(cost, expiration, is_broadcast, display_name, sku, in_development),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_extension_bits_product(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/bits/extensions".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("cost") {
        body.insert("cost".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("expiration") {
        body.insert("expiration".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("is_broadcast") {
        body.insert("is_broadcast".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("display_name") {
        body.insert("display_name".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("sku") {
        body.insert("sku".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("in_development") {
        body.insert("in_development".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 /bits/extensions failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the list of Bits products that belongs to the extension.
///
/// Method: GET /bits/extensions
#[actor(
    TwitchReadExtensionBitsProductsActor,
    inports::<100>(should_include_all),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_extension_bits_products(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/bits/extensions".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("should_include_all") {
        query_pairs.push(("should_include_all", 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 /bits/extensions failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the Bits leaderboard for the authenticated broadcaster.
///
/// Method: GET /bits/leaderboard
#[actor(
    TwitchReadBitsLeaderboardActor,
    inports::<100>(count, period, started_at, user_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_bits_leaderboard(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/bits/leaderboard".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("count") {
        query_pairs.push(("count", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("period") {
        query_pairs.push(("period", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("started_at") {
        query_pairs.push(("started_at", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("user_id") {
        query_pairs.push(("user_id", 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 /bits/leaderboard failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets a list of custom rewards that the specified broadcaster created.
///
/// Method: GET /channel_points/custom_rewards
#[actor(
    TwitchReadCustomRewardActor,
    inports::<100>(broadcaster_id, id, only_manageable_rewards),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_custom_reward(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/channel_points/custom_rewards".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("id") {
        query_pairs.push(("id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("only_manageable_rewards") {
        query_pairs.push(("only_manageable_rewards", 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 /channel_points/custom_rewards failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Creates a Custom Reward in the broadcaster’s channel.
///
/// Method: POST /channel_points/custom_rewards
#[actor(
    TwitchCreateCustomRewardsActor,
    inports::<100>(broadcaster_id, max_per_user_per_stream, prompt, should_redemptions_skip_request_queue, title, is_max_per_stream_enabled, cost, global_cooldown_seconds, is_enabled, is_max_per_user_per_stream_enabled, is_user_input_required, background_color, max_per_stream, is_global_cooldown_enabled),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_create_custom_rewards(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/channel_points/custom_rewards".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("max_per_user_per_stream") {
        body.insert("max_per_user_per_stream".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("prompt") {
        body.insert("prompt".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("should_redemptions_skip_request_queue") {
        body.insert(
            "should_redemptions_skip_request_queue".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("is_max_per_stream_enabled") {
        body.insert("is_max_per_stream_enabled".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("cost") {
        body.insert("cost".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("global_cooldown_seconds") {
        body.insert("global_cooldown_seconds".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("is_enabled") {
        body.insert("is_enabled".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("is_max_per_user_per_stream_enabled") {
        body.insert(
            "is_max_per_user_per_stream_enabled".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("is_user_input_required") {
        body.insert("is_user_input_required".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("background_color") {
        body.insert("background_color".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("max_per_stream") {
        body.insert("max_per_stream".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("is_global_cooldown_enabled") {
        body.insert("is_global_cooldown_enabled".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 /channel_points/custom_rewards failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Deletes a custom reward that the broadcaster created.
///
/// Method: DELETE /channel_points/custom_rewards
#[actor(
    TwitchDeleteCustomRewardActor,
    inports::<100>(broadcaster_id, id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_delete_custom_reward(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/channel_points/custom_rewards".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("id") {
        query_pairs.push(("id", 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!("DELETE /channel_points/custom_rewards failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Updates a custom reward.
///
/// Method: PATCH /channel_points/custom_rewards
#[actor(
    TwitchUpdateCustomRewardActor,
    inports::<100>(broadcaster_id, id, is_max_per_stream_enabled, global_cooldown_seconds, cost, background_color, is_max_per_user_per_stream_enabled, is_enabled, is_global_cooldown_enabled, is_paused, max_per_stream, prompt, should_redemptions_skip_request_queue, title, is_user_input_required, max_per_user_per_stream),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_custom_reward(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/channel_points/custom_rewards".to_string();

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

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

    let mut builder = client.patch(&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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("id") {
        query_pairs.push(("id", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("is_max_per_stream_enabled") {
        body.insert("is_max_per_stream_enabled".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("global_cooldown_seconds") {
        body.insert("global_cooldown_seconds".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("cost") {
        body.insert("cost".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("background_color") {
        body.insert("background_color".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("is_max_per_user_per_stream_enabled") {
        body.insert(
            "is_max_per_user_per_stream_enabled".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("is_enabled") {
        body.insert("is_enabled".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("is_global_cooldown_enabled") {
        body.insert("is_global_cooldown_enabled".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("is_paused") {
        body.insert("is_paused".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("max_per_stream") {
        body.insert("max_per_stream".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("prompt") {
        body.insert("prompt".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("should_redemptions_skip_request_queue") {
        body.insert(
            "should_redemptions_skip_request_queue".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("is_user_input_required") {
        body.insert("is_user_input_required".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("max_per_user_per_stream") {
        body.insert("max_per_user_per_stream".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!("PATCH /channel_points/custom_rewards failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Gets a list of redemptions for a custom reward.
///
/// Method: GET /channel_points/custom_rewards/redemptions
#[actor(
    TwitchReadCustomRewardRedemptionActor,
    inports::<100>(broadcaster_id, reward_id, status, id, sort, after, first),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_custom_reward_redemption(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/channel_points/custom_rewards/redemptions".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("reward_id") {
        query_pairs.push(("reward_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("status") {
        query_pairs.push(("status", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("id") {
        query_pairs.push(("id", 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("after") {
        query_pairs.push(("after", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", 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 /channel_points/custom_rewards/redemptions failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Updates a redemption’s status.
///
/// Method: PATCH /channel_points/custom_rewards/redemptions
#[actor(
    TwitchUpdateRedemptionStatusActor,
    inports::<100>(id, broadcaster_id, reward_id, status),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_redemption_status(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/channel_points/custom_rewards/redemptions".to_string();

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

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

    let mut builder = client.patch(&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("id") {
        query_pairs.push(("id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("reward_id") {
        query_pairs.push(("reward_id", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("status") {
        body.insert("status".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!(
                        "PATCH /channel_points/custom_rewards/redemptions failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Gets information about one or more channels.
///
/// Method: GET /channels
#[actor(
    TwitchReadChannelInformationActor,
    inports::<100>(broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_channel_information(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", 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 /channels failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Updates a channel’s properties.
///
/// Method: PATCH /channels
#[actor(
    TwitchUpdateChannelsActor,
    inports::<100>(broadcaster_id, game_id, delay, broadcaster_language, tags, content_classification_labels, is_branded_content, title),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_channels(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

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

    let mut builder = client.patch(&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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("game_id") {
        body.insert("game_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("delay") {
        body.insert("delay".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("broadcaster_language") {
        body.insert("broadcaster_language".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("tags") {
        body.insert("tags".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("content_classification_labels") {
        body.insert(
            "content_classification_labels".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("is_branded_content") {
        body.insert("is_branded_content".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!("PATCH /channels failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Returns ad schedule related information.
///
/// Method: GET /channels/ads
#[actor(
    TwitchReadAdScheduleActor,
    inports::<100>(broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_ad_schedule(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/channels/ads".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", 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 /channels/ads failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Pushes back the timestamp of the upcoming automatic mid-roll ad by 5 minutes.
///
/// Method: POST /channels/ads/schedule/snooze
#[actor(
    TwitchCreateAdsActor,
    inports::<100>(broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_create_ads(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/channels/ads/schedule/snooze".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", 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 /channels/ads/schedule/snooze failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Starts a commercial on the specified channel.
///
/// Method: POST /channels/commercial
#[actor(
    TwitchStartCommercialActor,
    inports::<100>(length, broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_start_commercial(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/channels/commercial".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("length") {
        body.insert("length".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("broadcaster_id") {
        body.insert("broadcaster_id".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 /channels/commercial failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the broadcaster’s list editors.
///
/// Method: GET /channels/editors
#[actor(
    TwitchReadChannelEditorsActor,
    inports::<100>(broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_channel_editors(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/channels/editors".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", 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 /channels/editors failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets a list of broadcasters that the specified user follows. You can also use this endpoint to see whether a user follows a specific broadcaster.
///
/// Method: GET /channels/followed
#[actor(
    TwitchReadFollowedChannelsActor,
    inports::<100>(user_id, broadcaster_id, first, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_followed_channels(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/channels/followed".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("user_id") {
        query_pairs.push(("user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /channels/followed failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets a list of users that follow the specified broadcaster. You can also use this endpoint to see whether a specific user follows the broadcaster.
///
/// Method: GET /channels/followers
#[actor(
    TwitchReadChannelFollowersActor,
    inports::<100>(user_id, broadcaster_id, first, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_channel_followers(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/channels/followers".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("user_id") {
        query_pairs.push(("user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /channels/followers failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Adds the specified user as a VIP in the broadcaster’s channel.
///
/// Method: POST /channels/vips
#[actor(
    TwitchCreateModerationActor,
    inports::<100>(user_id, broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_create_moderation(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/channels/vips".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("user_id") {
        query_pairs.push(("user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", 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 /channels/vips failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets a list of the broadcaster’s VIPs.
///
/// Method: GET /channels/vips
#[actor(
    TwitchReadVipsActor,
    inports::<100>(user_id, broadcaster_id, first, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_vips(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/channels/vips".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("user_id") {
        query_pairs.push(("user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /channels/vips failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Removes the specified user as a VIP in the broadcaster’s channel.
///
/// Method: DELETE /channels/vips
#[actor(
    TwitchDeleteChannelVipActor,
    inports::<100>(user_id, broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_delete_channel_vip(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/channels/vips".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("user_id") {
        query_pairs.push(("user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", 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!("DELETE /channels/vips failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets information about the broadcaster’s active charity campaign.
///
/// Method: GET /charity/campaigns
#[actor(
    TwitchReadCharityCampaignActor,
    inports::<100>(broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_charity_campaign(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/charity/campaigns".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", 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 /charity/campaigns failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the list of donations that users have made to the broadcaster’s active charity campaign.
///
/// Method: GET /charity/donations
#[actor(
    TwitchReadCharityCampaignDonationsActor,
    inports::<100>(broadcaster_id, first, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_charity_campaign_donations(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/charity/donations".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /charity/donations failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Sends an announcement to the broadcaster’s chat room.
///
/// Method: POST /chat/announcements
#[actor(
    TwitchSendChatAnnouncementActor,
    inports::<100>(broadcaster_id, moderator_id, color, message),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_send_chat_announcement(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/chat/announcements".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    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("message") {
        body.insert("message".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 /chat/announcements failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the broadcaster’s list of custom chat badges.
///
/// Method: GET /chat/badges
#[actor(
    TwitchReadChannelChatBadgesActor,
    inports::<100>(broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_channel_chat_badges(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/chat/badges".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", 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 /chat/badges failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets Twitch’s list of chat badges.
///
/// Method: GET /chat/badges/global
#[actor(
    TwitchReadGlobalChatBadgesActor,
    inports::<100>(trigger),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_global_chat_badges(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/chat/badges/global".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 /chat/badges/global failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the list of users that are connected to the broadcaster’s chat session.
///
/// Method: GET /chat/chatters
#[actor(
    TwitchReadChattersActor,
    inports::<100>(broadcaster_id, moderator_id, first, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_chatters(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/chat/chatters".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /chat/chatters failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the color used for the user’s name in chat.
///
/// Method: GET /chat/color
#[actor(
    TwitchReadUserChatColorActor,
    inports::<100>(user_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_user_chat_color(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/chat/color".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("user_id") {
        query_pairs.push(("user_id", 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 /chat/color failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Updates the color used for the user’s name in chat.
///
/// Method: PUT /chat/color
#[actor(
    TwitchUpdateUserChatColorActor,
    inports::<100>(user_id, color),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_user_chat_color(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/chat/color".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("user_id") {
        query_pairs.push(("user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("color") {
        query_pairs.push(("color", 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!("PUT /chat/color failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the broadcaster’s list of custom emotes.
///
/// Method: GET /chat/emotes
#[actor(
    TwitchReadChannelEmotesActor,
    inports::<100>(broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_channel_emotes(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/chat/emotes".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", 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 /chat/emotes failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets all global emotes.
///
/// Method: GET /chat/emotes/global
#[actor(
    TwitchReadGlobalEmotesActor,
    inports::<100>(trigger),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_global_emotes(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/chat/emotes/global".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 /chat/emotes/global failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets emotes for one or more specified emote sets.
///
/// Method: GET /chat/emotes/set
#[actor(
    TwitchReadEmoteSetsActor,
    inports::<100>(emote_set_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_emote_sets(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/chat/emotes/set".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("emote_set_id") {
        query_pairs.push(("emote_set_id", 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 /chat/emotes/set failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Retrieves emotes available to the user across all channels.
///
/// Method: GET /chat/emotes/user
#[actor(
    TwitchReadUserEmotesActor,
    inports::<100>(user_id, after, broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_user_emotes(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/chat/emotes/user".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("user_id") {
        query_pairs.push(("user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", 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 /chat/emotes/user failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Sends a message to the broadcaster’s chat room.
///
/// Method: POST /chat/messages
#[actor(
    TwitchSendChatMessageActor,
    inports::<100>(sender_id, reply_parent_message_id, for_source_only, broadcaster_id, message),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_send_chat_message(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/chat/messages".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("sender_id") {
        body.insert("sender_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("reply_parent_message_id") {
        body.insert("reply_parent_message_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("for_source_only") {
        body.insert("for_source_only".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("broadcaster_id") {
        body.insert("broadcaster_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("message") {
        body.insert("message".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 /chat/messages failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the broadcaster’s chat settings.
///
/// Method: GET /chat/settings
#[actor(
    TwitchReadChatSettingsActor,
    inports::<100>(broadcaster_id, moderator_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_chat_settings(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/chat/settings".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", 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 /chat/settings failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Updates the broadcaster’s chat settings.
///
/// Method: PATCH /chat/settings
#[actor(
    TwitchUpdateChatSettingsActor,
    inports::<100>(broadcaster_id, moderator_id, slow_mode_wait_time, emote_mode, non_moderator_chat_delay_duration, subscriber_mode, follower_mode, unique_chat_mode, non_moderator_chat_delay, slow_mode, follower_mode_duration),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_chat_settings(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/chat/settings".to_string();

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

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

    let mut builder = client.patch(&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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("slow_mode_wait_time") {
        body.insert("slow_mode_wait_time".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("emote_mode") {
        body.insert("emote_mode".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("non_moderator_chat_delay_duration") {
        body.insert(
            "non_moderator_chat_delay_duration".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("subscriber_mode") {
        body.insert("subscriber_mode".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("follower_mode") {
        body.insert("follower_mode".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("unique_chat_mode") {
        body.insert("unique_chat_mode".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("non_moderator_chat_delay") {
        body.insert("non_moderator_chat_delay".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("slow_mode") {
        body.insert("slow_mode".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("follower_mode_duration") {
        body.insert("follower_mode_duration".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!("PATCH /chat/settings failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Sends a Shoutout to the specified broadcaster.
///
/// Method: POST /chat/shoutouts
#[actor(
    TwitchSendAShoutoutActor,
    inports::<100>(from_broadcaster_id, to_broadcaster_id, moderator_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_send_a_shoutout(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/chat/shoutouts".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("from_broadcaster_id") {
        query_pairs.push(("from_broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("to_broadcaster_id") {
        query_pairs.push(("to_broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", 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 /chat/shoutouts failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Creates a clip from the broadcaster’s stream.
///
/// Method: POST /clips
#[actor(
    TwitchCreateClipActor,
    inports::<100>(broadcaster_id, title, duration),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_create_clip(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("title") {
        query_pairs.push(("title", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("duration") {
        query_pairs.push(("duration", 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 /clips failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets one or more video clips.
///
/// Method: GET /clips
#[actor(
    TwitchReadClipsActor,
    inports::<100>(broadcaster_id, game_id, id, started_at, ended_at, first, before, after, is_featured),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_clips(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("game_id") {
        query_pairs.push(("game_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("id") {
        query_pairs.push(("id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("started_at") {
        query_pairs.push(("started_at", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("ended_at") {
        query_pairs.push(("ended_at", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("before") {
        query_pairs.push(("before", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("is_featured") {
        query_pairs.push(("is_featured", 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 /clips failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// NEW Provides URLs to download the video file(s) for the specified clips.
///
/// Method: GET /clips/downloads
#[actor(
    TwitchReadClipsDownloadActor,
    inports::<100>(editor_id, broadcaster_id, clip_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_clips_download(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/clips/downloads".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("editor_id") {
        query_pairs.push(("editor_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("clip_id") {
        query_pairs.push(("clip_id", 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 /clips/downloads failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets information about Twitch content classification labels.
///
/// Method: GET /content_classification_labels
#[actor(
    TwitchReadContentClassificationLabelsActor,
    inports::<100>(locale),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_content_classification_labels(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("locale") {
        query_pairs.push(("locale", 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 /content_classification_labels failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets an organization’s list of entitlements that have been granted to a game, a user, or both.
///
/// Method: GET /entitlements/drops
#[actor(
    TwitchReadDropsEntitlementsActor,
    inports::<100>(id, user_id, game_id, fulfillment_status, after, first),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_drops_entitlements(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/entitlements/drops".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("id") {
        query_pairs.push(("id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("user_id") {
        query_pairs.push(("user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("game_id") {
        query_pairs.push(("game_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("fulfillment_status") {
        query_pairs.push(("fulfillment_status", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", 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 /entitlements/drops failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Updates the Drop entitlement’s fulfillment status.
///
/// Method: PATCH /entitlements/drops
#[actor(
    TwitchUpdateDropsEntitlementsActor,
    inports::<100>(entitlement_ids, fulfillment_status),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_drops_entitlements(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/entitlements/drops".to_string();

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

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

    let mut builder = client.patch(&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("entitlement_ids") {
        body.insert("entitlement_ids".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("fulfillment_status") {
        body.insert("fulfillment_status".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!("PATCH /entitlements/drops failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the conduits for a client ID.
///
/// Method: GET /eventsub/conduits
#[actor(
    TwitchReadConduitsActor,
    inports::<100>(trigger),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_conduits(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/eventsub/conduits".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 /eventsub/conduits failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Deletes a specified conduit.
///
/// Method: DELETE /eventsub/conduits
#[actor(
    TwitchDeleteConduitActor,
    inports::<100>(id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_delete_conduit(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/eventsub/conduits".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("id") {
        query_pairs.push(("id", 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!("DELETE /eventsub/conduits failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Creates a new conduit.
///
/// Method: POST /eventsub/conduits
#[actor(
    TwitchCreateConduitsActor,
    inports::<100>(shard_count),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_create_conduits(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/eventsub/conduits".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("shard_count") {
        body.insert("shard_count".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 /eventsub/conduits failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Updates a conduit’s shard count.
///
/// Method: PATCH /eventsub/conduits
#[actor(
    TwitchUpdateConduitsActor,
    inports::<100>(id, shard_count),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_conduits(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/eventsub/conduits".to_string();

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

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

    let mut builder = client.patch(&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("id") {
        body.insert("id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("shard_count") {
        body.insert("shard_count".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!("PATCH /eventsub/conduits failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Updates shard(s) for a conduit.
///
/// Method: PATCH /eventsub/conduits/shards
#[actor(
    TwitchUpdateConduitShardsActor,
    inports::<100>(conduit_id, shards),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_conduit_shards(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/eventsub/conduits/shards".to_string();

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

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

    let mut builder = client.patch(&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("conduit_id") {
        body.insert("conduit_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("shards") {
        body.insert("shards".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!("PATCH /eventsub/conduits/shards failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets a lists of all shards for a conduit.
///
/// Method: GET /eventsub/conduits/shards
#[actor(
    TwitchReadConduitShardsActor,
    inports::<100>(conduit_id, status, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_conduit_shards(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/eventsub/conduits/shards".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("conduit_id") {
        query_pairs.push(("conduit_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("status") {
        query_pairs.push(("status", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /eventsub/conduits/shards failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets a list of EventSub subscriptions that the client in the access token created.
///
/// Method: GET /eventsub/subscriptions
#[actor(
    TwitchReadEventsubSubscriptionsActor,
    inports::<100>(status, type_, user_id, subscription_id, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_eventsub_subscriptions(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/eventsub/subscriptions".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("type_") {
        query_pairs.push(("type", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("user_id") {
        query_pairs.push(("user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("subscription_id") {
        query_pairs.push(("subscription_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /eventsub/subscriptions failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Creates an EventSub subscription.
///
/// Method: POST /eventsub/subscriptions
#[actor(
    TwitchCreateEventsubSubscriptionActor,
    inports::<100>(transport, condition, type_, version),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_create_eventsub_subscription(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/eventsub/subscriptions".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("transport") {
        body.insert("transport".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("condition") {
        body.insert("condition".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("type_") {
        body.insert("type".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("version") {
        body.insert("version".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 /eventsub/subscriptions failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Deletes an EventSub subscription.
///
/// Method: DELETE /eventsub/subscriptions
#[actor(
    TwitchDeleteEventsubSubscriptionActor,
    inports::<100>(id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_delete_eventsub_subscription(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/eventsub/subscriptions".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("id") {
        query_pairs.push(("id", 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!("DELETE /eventsub/subscriptions failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets information about an extension.
///
/// Method: GET /extensions
#[actor(
    TwitchReadExtensionsActor,
    inports::<100>(extension_id, extension_version),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_extensions(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("extension_id") {
        query_pairs.push(("extension_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("extension_version") {
        query_pairs.push(("extension_version", 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 /extensions failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Sends a message to the specified broadcaster’s chat room.
///
/// Method: POST /extensions/chat
#[actor(
    TwitchSendExtensionChatMessageActor,
    inports::<100>(broadcaster_id, extension_id, extension_version, text),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_send_extension_chat_message(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/extensions/chat".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("extension_id") {
        body.insert("extension_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("extension_version") {
        body.insert("extension_version".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("text") {
        body.insert("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 /extensions/chat failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the specified configuration segment from the specified extension.
///
/// Method: GET /extensions/configurations
#[actor(
    TwitchReadExtensionConfigurationSegmentActor,
    inports::<100>(broadcaster_id, extension_id, segment),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_extension_configuration_segment(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/extensions/configurations".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("extension_id") {
        query_pairs.push(("extension_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("segment") {
        query_pairs.push(("segment", 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 /extensions/configurations failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Updates a configuration segment.
///
/// Method: PUT /extensions/configurations
#[actor(
    TwitchUpdateExtensionsActor,
    inports::<100>(content, segment, broadcaster_id, extension_id, version),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_extensions(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/extensions/configurations".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("content") {
        body.insert("content".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("segment") {
        body.insert("segment".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("broadcaster_id") {
        body.insert("broadcaster_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("extension_id") {
        body.insert("extension_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("version") {
        body.insert("version".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 /extensions/configurations failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Creates a shared secret used to sign and verify JWT tokens.
///
/// Method: POST /extensions/jwt/secrets
#[actor(
    TwitchCreateExtensionSecretActor,
    inports::<100>(extension_id, delay),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_create_extension_secret(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/extensions/jwt/secrets".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("extension_id") {
        query_pairs.push(("extension_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("delay") {
        query_pairs.push(("delay", 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 /extensions/jwt/secrets failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets an extension’s list of shared secrets.
///
/// Method: GET /extensions/jwt/secrets
#[actor(
    TwitchReadExtensionSecretsActor,
    inports::<100>(trigger),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_extension_secrets(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/extensions/jwt/secrets".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 /extensions/jwt/secrets failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets a list of broadcasters that are streaming live and have installed or activated the extension.
///
/// Method: GET /extensions/live
#[actor(
    TwitchReadExtensionLiveChannelsActor,
    inports::<100>(extension_id, first, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_extension_live_channels(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/extensions/live".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("extension_id") {
        query_pairs.push(("extension_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /extensions/live failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Sends a message to one or more viewers.
///
/// Method: POST /extensions/pubsub
#[actor(
    TwitchSendExtensionPubsubMessageActor,
    inports::<100>(target, message, broadcaster_id, is_global_broadcast),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_send_extension_pubsub_message(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/extensions/pubsub".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("target") {
        body.insert("target".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("broadcaster_id") {
        body.insert("broadcaster_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("is_global_broadcast") {
        body.insert("is_global_broadcast".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 /extensions/pubsub failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets information about a released extension.
///
/// Method: GET /extensions/released
#[actor(
    TwitchReadReleasedExtensionsActor,
    inports::<100>(extension_id, extension_version),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_released_extensions(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/extensions/released".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("extension_id") {
        query_pairs.push(("extension_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("extension_version") {
        query_pairs.push(("extension_version", 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 /extensions/released failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets an extension’s list of transactions.
///
/// Method: GET /extensions/transactions
#[actor(
    TwitchReadExtensionTransactionsActor,
    inports::<100>(extension_id, id, first, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_extension_transactions(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/extensions/transactions".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("extension_id") {
        query_pairs.push(("extension_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("id") {
        query_pairs.push(("id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /extensions/transactions failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets information about specified games.
///
/// Method: GET /games
#[actor(
    TwitchReadGamesActor,
    inports::<100>(id, name, igdb_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_games(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("id") {
        query_pairs.push(("id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("name") {
        query_pairs.push(("name", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("igdb_id") {
        query_pairs.push(("igdb_id", 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 /games failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets information about all broadcasts on Twitch.
///
/// Method: GET /games/top
#[actor(
    TwitchReadTopGamesActor,
    inports::<100>(first, after, before),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_top_games(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/games/top".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("before") {
        query_pairs.push(("before", 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 /games/top failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the broadcaster’s list of active goals.
///
/// Method: GET /goals
#[actor(
    TwitchReadCreatorGoalsActor,
    inports::<100>(broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_creator_goals(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", 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 /goals failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// BETA Gets the channel settings for configuration of the Guest Star feature for a particular host.
///
/// Method: GET /guest_star/channel_settings
#[actor(
    TwitchReadChannelGuestStarSettingsActor,
    inports::<100>(broadcaster_id, moderator_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_channel_guest_star_settings(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/guest_star/channel_settings".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", 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 /guest_star/channel_settings failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// BETA Mutates the channel settings for configuration of the Guest Star feature for a particular host.
///
/// Method: PUT /guest_star/channel_settings
#[actor(
    TwitchUpdateChannelGuestStarSettingsActor,
    inports::<100>(broadcaster_id, group_layout, is_browser_source_audio_enabled, regenerate_browser_sources, is_moderator_send_live_enabled, slot_count),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_channel_guest_star_settings(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/guest_star/channel_settings".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("group_layout") {
        body.insert("group_layout".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("is_browser_source_audio_enabled") {
        body.insert(
            "is_browser_source_audio_enabled".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("regenerate_browser_sources") {
        body.insert("regenerate_browser_sources".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("is_moderator_send_live_enabled") {
        body.insert(
            "is_moderator_send_live_enabled".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("slot_count") {
        body.insert("slot_count".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 /guest_star/channel_settings failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// BETA Sends an invite to a specified guest on behalf of the broadcaster for a Guest Star session in progress.
///
/// Method: POST /guest_star/invites
#[actor(
    TwitchSendGuestStarInviteActor,
    inports::<100>(broadcaster_id, moderator_id, session_id, guest_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_send_guest_star_invite(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/guest_star/invites".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("session_id") {
        query_pairs.push(("session_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("guest_id") {
        query_pairs.push(("guest_id", 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 /guest_star/invites failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// BETA Provides the caller with a list of pending invites to a Guest Star session.
///
/// Method: GET /guest_star/invites
#[actor(
    TwitchReadGuestStarInvitesActor,
    inports::<100>(broadcaster_id, moderator_id, session_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_guest_star_invites(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/guest_star/invites".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("session_id") {
        query_pairs.push(("session_id", 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 /guest_star/invites failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// BETA Revokes a previously sent invite for a Guest Star session.
///
/// Method: DELETE /guest_star/invites
#[actor(
    TwitchDeleteGuestStarInviteActor,
    inports::<100>(broadcaster_id, moderator_id, session_id, guest_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_delete_guest_star_invite(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/guest_star/invites".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("session_id") {
        query_pairs.push(("session_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("guest_id") {
        query_pairs.push(("guest_id", 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!("DELETE /guest_star/invites failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// BETA Programmatically ends a Guest Star session on behalf of the broadcaster.
///
/// Method: DELETE /guest_star/session
#[actor(
    TwitchDeleteGuestStarActor,
    inports::<100>(broadcaster_id, session_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_delete_guest_star(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/guest_star/session".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("session_id") {
        query_pairs.push(("session_id", 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!("DELETE /guest_star/session failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// BETA Gets information about an ongoing Guest Star session for a particular channel.
///
/// Method: GET /guest_star/session
#[actor(
    TwitchReadGuestStarSessionActor,
    inports::<100>(broadcaster_id, moderator_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_guest_star_session(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/guest_star/session".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", 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 /guest_star/session failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// BETA Programmatically creates a Guest Star session on behalf of the broadcaster.
///
/// Method: POST /guest_star/session
#[actor(
    TwitchCreateGuestStarSessionActor,
    inports::<100>(broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_create_guest_star_session(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/guest_star/session".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", 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 /guest_star/session failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// BETA Allows a caller to remove a slot assignment from a user participating in an active Guest Star session.
///
/// Method: DELETE /guest_star/slot
#[actor(
    TwitchDeleteGuestStarSlotActor,
    inports::<100>(broadcaster_id, moderator_id, session_id, guest_id, slot_id, should_reinvite_guest),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_delete_guest_star_slot(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/guest_star/slot".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("session_id") {
        query_pairs.push(("session_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("guest_id") {
        query_pairs.push(("guest_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("slot_id") {
        query_pairs.push(("slot_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("should_reinvite_guest") {
        query_pairs.push(("should_reinvite_guest", 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!("DELETE /guest_star/slot failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// BETA Allows a user to update the assigned slot for a particular user within the active Guest Star session.
///
/// Method: PATCH /guest_star/slot
#[actor(
    TwitchUpdateGuestStarSlotActor,
    inports::<100>(broadcaster_id, moderator_id, session_id, source_slot_id, destination_slot_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_guest_star_slot(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/guest_star/slot".to_string();

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

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

    let mut builder = client.patch(&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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("session_id") {
        query_pairs.push(("session_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("source_slot_id") {
        query_pairs.push(("source_slot_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("destination_slot_id") {
        query_pairs.push(("destination_slot_id", 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!("PATCH /guest_star/slot failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// BETA Allows a previously invited user to be assigned a slot within the active Guest Star session.
///
/// Method: POST /guest_star/slot
#[actor(
    TwitchCreateGuestStarActor,
    inports::<100>(broadcaster_id, moderator_id, session_id, guest_id, slot_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_create_guest_star(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/guest_star/slot".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("session_id") {
        query_pairs.push(("session_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("guest_id") {
        query_pairs.push(("guest_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("slot_id") {
        query_pairs.push(("slot_id", 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 /guest_star/slot failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// BETA Allows a user to update slot settings for a particular guest within a Guest Star session.
///
/// Method: PATCH /guest_star/slot_settings
#[actor(
    TwitchUpdateGuestStarSlotSettingsActor,
    inports::<100>(broadcaster_id, moderator_id, session_id, slot_id, is_audio_enabled, is_video_enabled, is_live, volume),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_guest_star_slot_settings(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/guest_star/slot_settings".to_string();

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

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

    let mut builder = client.patch(&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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("session_id") {
        query_pairs.push(("session_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("slot_id") {
        query_pairs.push(("slot_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("is_audio_enabled") {
        query_pairs.push(("is_audio_enabled", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("is_video_enabled") {
        query_pairs.push(("is_video_enabled", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("is_live") {
        query_pairs.push(("is_live", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("volume") {
        query_pairs.push(("volume", 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!("PATCH /guest_star/slot_settings failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// NEW Gets the status of a Hype Train for the specified broadcaster.
///
/// Method: GET /hypetrain/status
#[actor(
    TwitchReadHypeTrainStatusActor,
    inports::<100>(broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_hype_train_status(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/hypetrain/status".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", 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 /hypetrain/status failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Updates the broadcaster’s AutoMod settings.
///
/// Method: PUT /moderation/automod/settings
#[actor(
    TwitchUpdateAutomodSettingsActor,
    inports::<100>(broadcaster_id, moderator_id, sex_based_terms, sexuality_sex_or_gender, bullying, aggression, disability, race_ethnicity_or_religion, misogyny, overall_level, swearing),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_automod_settings(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/moderation/automod/settings".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("sex_based_terms") {
        body.insert("sex_based_terms".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("sexuality_sex_or_gender") {
        body.insert("sexuality_sex_or_gender".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("bullying") {
        body.insert("bullying".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("aggression") {
        body.insert("aggression".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("disability") {
        body.insert("disability".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("race_ethnicity_or_religion") {
        body.insert("race_ethnicity_or_religion".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("misogyny") {
        body.insert("misogyny".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("overall_level") {
        body.insert("overall_level".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("swearing") {
        body.insert("swearing".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 /moderation/automod/settings failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the broadcaster’s AutoMod settings.
///
/// Method: GET /moderation/automod/settings
#[actor(
    TwitchReadAutomodSettingsActor,
    inports::<100>(broadcaster_id, moderator_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_automod_settings(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/moderation/automod/settings".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", 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 /moderation/automod/settings failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets all users that the broadcaster banned or put in a timeout.
///
/// Method: GET /moderation/banned
#[actor(
    TwitchReadBannedUsersActor,
    inports::<100>(broadcaster_id, user_id, first, after, before),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_banned_users(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/moderation/banned".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("user_id") {
        query_pairs.push(("user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("before") {
        query_pairs.push(("before", 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 /moderation/banned failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Removes the ban or timeout that was placed on the specified user.
///
/// Method: DELETE /moderation/bans
#[actor(
    TwitchDeleteModerationActor,
    inports::<100>(broadcaster_id, moderator_id, user_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_delete_moderation(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/moderation/bans".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("user_id") {
        query_pairs.push(("user_id", 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!("DELETE /moderation/bans failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Removes the word or phrase from the broadcaster’s list of blocked terms.
///
/// Method: DELETE /moderation/blocked_terms
#[actor(
    TwitchDeleteBlockedTermActor,
    inports::<100>(broadcaster_id, moderator_id, id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_delete_blocked_term(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/moderation/blocked_terms".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("id") {
        query_pairs.push(("id", 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!("DELETE /moderation/blocked_terms failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the broadcaster’s list of non-private, blocked words or phrases.
///
/// Method: GET /moderation/blocked_terms
#[actor(
    TwitchReadBlockedTermsActor,
    inports::<100>(broadcaster_id, moderator_id, first, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_blocked_terms(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/moderation/blocked_terms".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /moderation/blocked_terms failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets a list of channels that the specified user has moderator privileges in.
///
/// Method: GET /moderation/channels
#[actor(
    TwitchReadModeratedChannelsActor,
    inports::<100>(user_id, after, first),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_moderated_channels(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/moderation/channels".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("user_id") {
        query_pairs.push(("user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", 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 /moderation/channels failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Removes a single chat message or all chat messages from the broadcaster’s chat room.
///
/// Method: DELETE /moderation/chat
#[actor(
    TwitchDeleteChatMessagesActor,
    inports::<100>(broadcaster_id, moderator_id, message_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_delete_chat_messages(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/moderation/chat".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("message_id") {
        query_pairs.push(("message_id", 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!("DELETE /moderation/chat failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets all users allowed to moderate the broadcaster’s chat room.
///
/// Method: GET /moderation/moderators
#[actor(
    TwitchReadModeratorsActor,
    inports::<100>(broadcaster_id, user_id, first, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_moderators(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/moderation/moderators".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("user_id") {
        query_pairs.push(("user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /moderation/moderators failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Removes a moderator from the broadcaster’s chat room.
///
/// Method: DELETE /moderation/moderators
#[actor(
    TwitchDeleteChannelModeratorActor,
    inports::<100>(broadcaster_id, user_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_delete_channel_moderator(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/moderation/moderators".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("user_id") {
        query_pairs.push(("user_id", 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!("DELETE /moderation/moderators failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the broadcaster’s Shield Mode activation status.
///
/// Method: GET /moderation/shield_mode
#[actor(
    TwitchReadShieldModeStatusActor,
    inports::<100>(broadcaster_id, moderator_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_shield_mode_status(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/moderation/shield_mode".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", 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 /moderation/shield_mode failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Activates or deactivates the broadcaster’s Shield Mode.
///
/// Method: PUT /moderation/shield_mode
#[actor(
    TwitchUpdateShieldModeStatusActor,
    inports::<100>(broadcaster_id, moderator_id, is_active),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_shield_mode_status(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/moderation/shield_mode".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("is_active") {
        body.insert("is_active".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 /moderation/shield_mode failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// NEW Remove a suspicious user status from a chatter on broadcaster’s channel.
///
/// Method: DELETE /moderation/suspicious_users
#[actor(
    TwitchDeleteSuspiciousStatusFromChatUserActor,
    inports::<100>(broadcaster_id, moderator_id, user_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_delete_suspicious_status_from_chat_user(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/moderation/suspicious_users".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("user_id") {
        query_pairs.push(("user_id", 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!("DELETE /moderation/suspicious_users failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Resolves an unban request by approving or denying it.
///
/// Method: PATCH /moderation/unban_requests
#[actor(
    TwitchUpdateModerationActor,
    inports::<100>(broadcaster_id, moderator_id, unban_request_id, status, resolution_text),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_moderation(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/moderation/unban_requests".to_string();

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

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

    let mut builder = client.patch(&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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("unban_request_id") {
        query_pairs.push(("unban_request_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("status") {
        query_pairs.push(("status", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("resolution_text") {
        query_pairs.push(("resolution_text", 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!("PATCH /moderation/unban_requests failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets a list of unban requests for a broadcaster’s channel.
///
/// Method: GET /moderation/unban_requests
#[actor(
    TwitchReadUnbanRequestsActor,
    inports::<100>(broadcaster_id, moderator_id, status, user_id, after, first),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_unban_requests(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/moderation/unban_requests".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("moderator_id") {
        query_pairs.push(("moderator_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("status") {
        query_pairs.push(("status", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("user_id") {
        query_pairs.push(("user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", 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 /moderation/unban_requests failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Creates a poll that viewers in the broadcaster’s channel can vote on.
///
/// Method: POST /polls
#[actor(
    TwitchCreatePollActor,
    inports::<100>(title, duration, broadcaster_id, channel_points_voting_enabled, choices, channel_points_per_vote),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_create_poll(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("duration") {
        body.insert("duration".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("broadcaster_id") {
        body.insert("broadcaster_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("channel_points_voting_enabled") {
        body.insert(
            "channel_points_voting_enabled".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("choices") {
        body.insert("choices".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("channel_points_per_vote") {
        body.insert("channel_points_per_vote".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 /polls failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets a list of polls that the broadcaster created.
///
/// Method: GET /polls
#[actor(
    TwitchReadPollsActor,
    inports::<100>(broadcaster_id, id, first, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_polls(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("id") {
        query_pairs.push(("id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /polls failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// End an active poll.
///
/// Method: PATCH /polls
#[actor(
    TwitchUpdatePollsActor,
    inports::<100>(id, status, broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_polls(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

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

    let mut builder = client.patch(&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("id") {
        body.insert("id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("status") {
        body.insert("status".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("broadcaster_id") {
        body.insert("broadcaster_id".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!("PATCH /polls failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Locks, resolves, or cancels a Channel Points Prediction.
///
/// Method: PATCH /predictions
#[actor(
    TwitchUpdatePredictionsActor,
    inports::<100>(winning_outcome_id, broadcaster_id, id, status),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_predictions(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

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

    let mut builder = client.patch(&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("winning_outcome_id") {
        body.insert("winning_outcome_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("broadcaster_id") {
        body.insert("broadcaster_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("id") {
        body.insert("id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("status") {
        body.insert("status".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!("PATCH /predictions failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets a list of Channel Points Predictions that the broadcaster created.
///
/// Method: GET /predictions
#[actor(
    TwitchReadPredictionsActor,
    inports::<100>(broadcaster_id, id, first, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_predictions(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("id") {
        query_pairs.push(("id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /predictions failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Create a Channel Points Prediction.
///
/// Method: POST /predictions
#[actor(
    TwitchCreatePredictionActor,
    inports::<100>(broadcaster_id, outcomes, prediction_window, title),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_create_prediction(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        body.insert("broadcaster_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("outcomes") {
        body.insert("outcomes".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("prediction_window") {
        body.insert("prediction_window".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 /predictions failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Cancel a pending raid.
///
/// Method: DELETE /raids
#[actor(
    TwitchCancelARaidActor,
    inports::<100>(broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_cancel_a_raid(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", 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!("DELETE /raids failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Raid another channel by sending the broadcaster’s viewers to the targeted channel.
///
/// Method: POST /raids
#[actor(
    TwitchStartARaidActor,
    inports::<100>(from_broadcaster_id, to_broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_start_a_raid(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("from_broadcaster_id") {
        query_pairs.push(("from_broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("to_broadcaster_id") {
        query_pairs.push(("to_broadcaster_id", 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 /raids failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the broadcaster’s streaming schedule.
///
/// Method: GET /schedule
#[actor(
    TwitchReadChannelStreamScheduleActor,
    inports::<100>(broadcaster_id, id, start_time, utc_offset, first, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_channel_stream_schedule(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("id") {
        query_pairs.push(("id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("start_time") {
        query_pairs.push(("start_time", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("utc_offset") {
        query_pairs.push(("utc_offset", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /schedule failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the broadcaster’s streaming schedule as an iCalendar.
///
/// Method: GET /schedule/icalendar
#[actor(
    TwitchReadChannelIcalendarActor,
    inports::<100>(broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_channel_icalendar(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/schedule/icalendar".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", 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 /schedule/icalendar failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Updates a scheduled broadcast segment.
///
/// Method: PATCH /schedule/segment
#[actor(
    TwitchUpdateChannelStreamScheduleSegmentActor,
    inports::<100>(broadcaster_id, id, start_time, category_id, is_canceled, duration, timezone, title),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_channel_stream_schedule_segment(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/schedule/segment".to_string();

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

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

    let mut builder = client.patch(&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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("id") {
        query_pairs.push(("id", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("start_time") {
        body.insert("start_time".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("category_id") {
        body.insert("category_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("is_canceled") {
        body.insert("is_canceled".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("duration") {
        body.insert("duration".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("timezone") {
        body.insert("timezone".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!("PATCH /schedule/segment failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Deletes a broadcast from the broadcaster’s streaming schedule.
///
/// Method: DELETE /schedule/segment
#[actor(
    TwitchDeleteChannelStreamScheduleSegmentActor,
    inports::<100>(broadcaster_id, id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_delete_channel_stream_schedule_segment(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/schedule/segment".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("id") {
        query_pairs.push(("id", 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!("DELETE /schedule/segment failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Adds a single or recurring broadcast to the broadcaster’s streaming schedule.
///
/// Method: POST /schedule/segment
#[actor(
    TwitchCreateChannelStreamScheduleSegmentActor,
    inports::<100>(broadcaster_id, is_recurring, timezone, title, category_id, start_time, duration),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_create_channel_stream_schedule_segment(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/schedule/segment".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("is_recurring") {
        body.insert("is_recurring".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("timezone") {
        body.insert("timezone".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("category_id") {
        body.insert("category_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("start_time") {
        body.insert("start_time".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("duration") {
        body.insert("duration".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 /schedule/segment failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Updates the broadcaster’s schedule settings, such as scheduling a vacation.
///
/// Method: PATCH /schedule/settings
#[actor(
    TwitchUpdateChannelStreamScheduleActor,
    inports::<100>(broadcaster_id, is_vacation_enabled, vacation_start_time, vacation_end_time, timezone),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_channel_stream_schedule(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/schedule/settings".to_string();

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

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

    let mut builder = client.patch(&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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("is_vacation_enabled") {
        query_pairs.push(("is_vacation_enabled", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("vacation_start_time") {
        query_pairs.push(("vacation_start_time", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("vacation_end_time") {
        query_pairs.push(("vacation_end_time", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("timezone") {
        query_pairs.push(("timezone", 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!("PATCH /schedule/settings failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the games or categories that match the specified query.
///
/// Method: GET /search/categories
#[actor(
    TwitchSearchCategoriesActor,
    inports::<100>(query, first, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_search_categories(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/search/categories".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("query") {
        query_pairs.push(("query", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /search/categories failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the channels that match the specified query and have streamed content within the past 6 months.
///
/// Method: GET /search/channels
#[actor(
    TwitchSearchChannelsActor,
    inports::<100>(query, live_only, first, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_search_channels(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/search/channels".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("query") {
        query_pairs.push(("query", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("live_only") {
        query_pairs.push(("live_only", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /search/channels failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// NEW Retrieves the active shared chat session for a channel.
///
/// Method: GET /shared_chat/session
#[actor(
    TwitchReadSharedChatSessionActor,
    inports::<100>(broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_shared_chat_session(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/shared_chat/session".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", 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 /shared_chat/session failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets a list of all streams.
///
/// Method: GET /streams
#[actor(
    TwitchReadStreamsActor,
    inports::<100>(user_id, user_login, game_id, type_, language, first, before, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_streams(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("user_id") {
        query_pairs.push(("user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("user_login") {
        query_pairs.push(("user_login", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("game_id") {
        query_pairs.push(("game_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("type_") {
        query_pairs.push(("type", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("language") {
        query_pairs.push(("language", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("before") {
        query_pairs.push(("before", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /streams failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the list of broadcasters that the user follows and that are streaming live.
///
/// Method: GET /streams/followed
#[actor(
    TwitchReadFollowedStreamsActor,
    inports::<100>(user_id, first, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_followed_streams(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/streams/followed".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("user_id") {
        query_pairs.push(("user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /streams/followed failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the channel’s stream key.
///
/// Method: GET /streams/key
#[actor(
    TwitchReadStreamKeyActor,
    inports::<100>(broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_stream_key(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/streams/key".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", 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 /streams/key failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Adds a marker to a live stream.
///
/// Method: POST /streams/markers
#[actor(
    TwitchCreateStreamMarkerActor,
    inports::<100>(description, user_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_create_stream_marker(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/streams/markers".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("description") {
        body.insert("description".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("user_id") {
        body.insert("user_id".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 /streams/markers failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets a list of markers from the user’s most recent stream or from the specified VOD/video.
///
/// Method: GET /streams/markers
#[actor(
    TwitchReadStreamMarkersActor,
    inports::<100>(user_id, video_id, first, before, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_stream_markers(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/streams/markers".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("user_id") {
        query_pairs.push(("user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("video_id") {
        query_pairs.push(("video_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("before") {
        query_pairs.push(("before", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /streams/markers failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets a list of users that subscribe to the specified broadcaster.
///
/// Method: GET /subscriptions
#[actor(
    TwitchReadBroadcasterSubscriptionsActor,
    inports::<100>(broadcaster_id, user_id, first, after, before),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_broadcaster_subscriptions(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("user_id") {
        query_pairs.push(("user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("before") {
        query_pairs.push(("before", 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 /subscriptions failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Checks whether the user subscribes to the broadcaster’s channel.
///
/// Method: GET /subscriptions/user
#[actor(
    TwitchListSubscriptionsActor,
    inports::<100>(broadcaster_id, user_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_list_subscriptions(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/subscriptions/user".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("user_id") {
        query_pairs.push(("user_id", 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 /subscriptions/user failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets information about the specified Twitch team.
///
/// Method: GET /teams
#[actor(
    TwitchReadTeamsActor,
    inports::<100>(name, id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_teams(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("name") {
        query_pairs.push(("name", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("id") {
        query_pairs.push(("id", 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 /teams failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the list of Twitch teams that the broadcaster is a member of.
///
/// Method: GET /teams/channel
#[actor(
    TwitchReadChannelTeamsActor,
    inports::<100>(broadcaster_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_channel_teams(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/teams/channel".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", 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 /teams/channel failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Updates the user’s information.
///
/// Method: PUT /users
#[actor(
    TwitchUpdateUserActor,
    inports::<100>(description),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_user(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("description") {
        query_pairs.push(("description", 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!("PUT /users failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Removes the user from the broadcaster’s list of blocked users.
///
/// Method: DELETE /users/blocks
#[actor(
    TwitchDeleteUsersActor,
    inports::<100>(target_user_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_delete_users(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/users/blocks".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("target_user_id") {
        query_pairs.push(("target_user_id", 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!("DELETE /users/blocks failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the list of users that the broadcaster has blocked.
///
/// Method: GET /users/blocks
#[actor(
    TwitchReadUserBlockListActor,
    inports::<100>(broadcaster_id, first, after),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_user_block_list(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/users/blocks".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", 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 /users/blocks failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Blocks the specified user from interacting with or having contact with the broadcaster.
///
/// Method: PUT /users/blocks
#[actor(
    TwitchUpdateUsersActor,
    inports::<100>(target_user_id, source_context, reason),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_users(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/users/blocks".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("target_user_id") {
        query_pairs.push(("target_user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("source_context") {
        query_pairs.push(("source_context", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("reason") {
        query_pairs.push(("reason", 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!("PUT /users/blocks failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets the active extensions that the broadcaster has installed for each configuration.
///
/// Method: GET /users/extensions
#[actor(
    TwitchReadUserActiveExtensionsActor,
    inports::<100>(user_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_user_active_extensions(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/users/extensions".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("user_id") {
        query_pairs.push(("user_id", 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 /users/extensions failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Updates an installed extension’s information.
///
/// Method: PUT /users/extensions
#[actor(
    TwitchUpdateUserExtensionsActor,
    inports::<100>(data),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_update_user_extensions(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/users/extensions".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("data") {
        body.insert("data".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 /users/extensions failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets a list of all extensions (both active and inactive) that the broadcaster has installed.
///
/// Method: GET /users/extensions/list
#[actor(
    TwitchReadUserExtensionsActor,
    inports::<100>(trigger),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_user_extensions(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/users/extensions/list".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 /users/extensions/list failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Deletes one or more videos.
///
/// Method: DELETE /videos
#[actor(
    TwitchDeleteVideosActor,
    inports::<100>(id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_delete_videos(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("id") {
        query_pairs.push(("id", 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!("DELETE /videos failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Gets information about one or more published videos.
///
/// Method: GET /videos
#[actor(
    TwitchReadVideosActor,
    inports::<100>(id, user_id, game_id, language, period, sort, type_, first, after, before),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_read_videos(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("id") {
        query_pairs.push(("id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("user_id") {
        query_pairs.push(("user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("game_id") {
        query_pairs.push(("game_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("language") {
        query_pairs.push(("language", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("period") {
        query_pairs.push(("period", 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("type_") {
        query_pairs.push(("type", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("first") {
        query_pairs.push(("first", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("after") {
        query_pairs.push(("after", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("before") {
        query_pairs.push(("before", 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 /videos failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// NEW  Creates a clip from the broadcaster’s VOD.
///
/// Method: POST /videos/clips
#[actor(
    TwitchCreateClipFromVodActor,
    inports::<100>(editor_id, broadcaster_id, vod_id, vod_offset, duration, title),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_create_clip_from_vod(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/videos/clips".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("editor_id") {
        query_pairs.push(("editor_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("broadcaster_id") {
        query_pairs.push(("broadcaster_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("vod_id") {
        query_pairs.push(("vod_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("vod_offset") {
        query_pairs.push(("vod_offset", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("duration") {
        query_pairs.push(("duration", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("title") {
        query_pairs.push(("title", 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 /videos/clips failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Sends a whisper message to the specified user.
///
/// Method: POST /whispers
#[actor(
    TwitchSendWhisperActor,
    inports::<100>(from_user_id, to_user_id, message),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn twitch_send_whisper(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("from_user_id") {
        query_pairs.push(("from_user_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("to_user_id") {
        query_pairs.push(("to_user_id", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("message") {
        body.insert("message".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 /whispers failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}