gestalt-sdk 0.0.1-alpha.25

// Code generated by sdkgen. DO NOT EDIT.

//! Generated wire conversions for external_credential.proto.

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

use crate::generated::v1;

/// Encodes a wire `ExternalCredentialGrant` as protobuf JSON.
pub(crate) fn encode_wire_external_credential_grant_json(
    value: &v1::ExternalCredentialGrant,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.access_token.is_empty() {
        object.insert(
            "accessToken".into(),
            serde_json::Value::String(value.access_token.to_string()),
        );
    }
    if !value.refresh_token.is_empty() {
        object.insert(
            "refreshToken".into(),
            serde_json::Value::String(value.refresh_token.to_string()),
        );
    }
    if !value.scope.is_empty() {
        object.insert(
            "scope".into(),
            serde_json::Value::String(value.scope.to_string()),
        );
    }
    if let Some(inner) = &value.expires_at {
        object.insert(
            "expiresAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if let Some(inner) = &value.last_refreshed_at {
        object.insert(
            "lastRefreshedAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if value.refresh_error_count != 0 {
        object.insert(
            "refreshErrorCount".into(),
            serde_json::json!(value.refresh_error_count),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ExternalCredentialGrant`.
pub(crate) fn decode_wire_external_credential_grant_json(
    value: &serde_json::Value,
) -> Result<v1::ExternalCredentialGrant, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::ExternalCredentialGrant {
        access_token: match object.get("accessToken") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        refresh_token: match object.get("refreshToken") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        scope: match object.get("scope") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        expires_at: object
            .get("expiresAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        last_refreshed_at: object
            .get("lastRefreshedAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        refresh_error_count: match object.get("refreshErrorCount") {
            Some(value) => crate::public::proto_json::decode_i32(value)?,
            None => 0,
        },
        ..Default::default()
    })
}

/// Encodes a wire `ExternalCredentialClientInfo` as protobuf JSON.
pub(crate) fn encode_wire_external_credential_client_info_json(
    value: &v1::ExternalCredentialClientInfo,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.client_id.is_empty() {
        object.insert(
            "clientId".into(),
            serde_json::Value::String(value.client_id.to_string()),
        );
    }
    if !value.client_secret.is_empty() {
        object.insert(
            "clientSecret".into(),
            serde_json::Value::String(value.client_secret.to_string()),
        );
    }
    if let Some(inner) = &value.client_secret_expires_at {
        object.insert(
            "clientSecretExpiresAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ExternalCredentialClientInfo`.
pub(crate) fn decode_wire_external_credential_client_info_json(
    value: &serde_json::Value,
) -> Result<v1::ExternalCredentialClientInfo, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::ExternalCredentialClientInfo {
        client_id: match object.get("clientId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        client_secret: match object.get("clientSecret") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        client_secret_expires_at: object
            .get("clientSecretExpiresAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `ExternalCredentialOpaque` as protobuf JSON.
pub(crate) fn encode_wire_external_credential_opaque_json(
    value: &v1::ExternalCredentialOpaque,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.fields.is_empty() {
        let mut map = serde_json::Map::new();
        for (key, value) in &value.fields {
            map.insert(key.clone(), serde_json::Value::String(value.to_string()));
        }
        object.insert("fields".into(), serde_json::Value::Object(map));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ExternalCredentialOpaque`.
pub(crate) fn decode_wire_external_credential_opaque_json(
    value: &serde_json::Value,
) -> Result<v1::ExternalCredentialOpaque, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::ExternalCredentialOpaque {
        fields: match object.get("fields") {
            Some(value) => {
                let mut out = std::collections::BTreeMap::new();
                let Some(entries) = value.as_object() else {
                    return Err(crate::public::proto_json::invalid_proto_json(
                        "expected object for map",
                    ));
                };
                for (key, value) in entries {
                    out.insert(
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            key.to_string(),
                        )?,
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            crate::public::proto_json::decode_string(value)?,
                        )?,
                    );
                }
                out
            }
            None => std::collections::BTreeMap::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `ExternalCredential` as protobuf JSON.
pub(crate) fn encode_wire_external_credential_json(
    value: &v1::ExternalCredential,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.id.is_empty() {
        object.insert("id".into(), serde_json::Value::String(value.id.to_string()));
    }
    if !value.subject.is_empty() {
        object.insert(
            "subject".into(),
            serde_json::Value::String(value.subject.to_string()),
        );
    }
    if !value.audience.is_empty() {
        object.insert(
            "audience".into(),
            serde_json::Value::String(value.audience.to_string()),
        );
    }
    if !value.qualifier.is_empty() {
        object.insert(
            "qualifier".into(),
            serde_json::Value::String(value.qualifier.to_string()),
        );
    }
    if !value.metadata_json.is_empty() {
        object.insert(
            "metadataJson".into(),
            serde_json::Value::String(value.metadata_json.to_string()),
        );
    }
    if let Some(inner) = &value.created_at {
        object.insert(
            "createdAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if let Some(inner) = &value.updated_at {
        object.insert(
            "updatedAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if let Some(active) = &value.credential {
        match active {
            v1::external_credential::Credential::Grant(inner) => {
                object.insert(
                    "grant".into(),
                    encode_wire_external_credential_grant_json(inner),
                );
            }
            v1::external_credential::Credential::Client(inner) => {
                object.insert(
                    "client".into(),
                    encode_wire_external_credential_client_info_json(inner),
                );
            }
            v1::external_credential::Credential::Opaque(inner) => {
                object.insert(
                    "opaque".into(),
                    encode_wire_external_credential_opaque_json(inner),
                );
            }
        }
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ExternalCredential`.
pub(crate) fn decode_wire_external_credential_json(
    value: &serde_json::Value,
) -> Result<v1::ExternalCredential, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::ExternalCredential {
        id: match object.get("id") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        subject: match object.get("subject") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        audience: match object.get("audience") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        qualifier: match object.get("qualifier") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        metadata_json: match object.get("metadataJson") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        created_at: object
            .get("createdAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        updated_at: object
            .get("updatedAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        credential: {
            let mut active = None;
            if let Some(value) = object.get("grant") {
                active = Some(v1::external_credential::Credential::Grant(
                    decode_wire_external_credential_grant_json(value)?,
                ));
            }
            if let Some(value) = object.get("client") {
                active = Some(v1::external_credential::Credential::Client(
                    decode_wire_external_credential_client_info_json(value)?,
                ));
            }
            if let Some(value) = object.get("opaque") {
                active = Some(v1::external_credential::Credential::Opaque(
                    decode_wire_external_credential_opaque_json(value)?,
                ));
            }
            active
        },
        ..Default::default()
    })
}

/// Encodes a wire `CreateExternalCredentialRequest` as protobuf JSON.
pub(crate) fn encode_wire_create_external_credential_request_json(
    value: &v1::CreateExternalCredentialRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(inner) = &value.credential {
        object.insert(
            "credential".into(),
            encode_wire_external_credential_json(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `CreateExternalCredentialRequest`.
pub(crate) fn decode_wire_create_external_credential_request_json(
    value: &serde_json::Value,
) -> Result<v1::CreateExternalCredentialRequest, crate::public::generated::rpc_support::GestaltError>
{
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::CreateExternalCredentialRequest {
        credential: object
            .get("credential")
            .map(|value| decode_wire_external_credential_json(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `DeleteExternalCredentialRequest` as protobuf JSON.
pub(crate) fn encode_wire_delete_external_credential_request_json(
    value: &v1::DeleteExternalCredentialRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.id.is_empty() {
        object.insert("id".into(), serde_json::Value::String(value.id.to_string()));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `DeleteExternalCredentialRequest`.
pub(crate) fn decode_wire_delete_external_credential_request_json(
    value: &serde_json::Value,
) -> Result<v1::DeleteExternalCredentialRequest, crate::public::generated::rpc_support::GestaltError>
{
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::DeleteExternalCredentialRequest {
        id: match object.get("id") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `ExternalCredentialTokenExchangeDriver` as protobuf JSON.
pub(crate) fn encode_wire_external_credential_token_exchange_driver_json(
    value: &v1::ExternalCredentialTokenExchangeDriver,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.r#type.is_empty() {
        object.insert(
            "type".into(),
            serde_json::Value::String(value.r#type.to_string()),
        );
    }
    if !value.target_principal.is_empty() {
        object.insert(
            "targetPrincipal".into(),
            serde_json::Value::String(value.target_principal.to_string()),
        );
    }
    if !value.scopes.is_empty() {
        object.insert(
            "scopes".into(),
            serde_json::Value::Array(
                value
                    .scopes
                    .iter()
                    .map(|item| serde_json::Value::String(item.to_string()))
                    .collect(),
            ),
        );
    }
    if value.lifetime_seconds != 0 {
        object.insert(
            "lifetimeSeconds".into(),
            serde_json::json!(value.lifetime_seconds),
        );
    }
    if !value.endpoint.is_empty() {
        object.insert(
            "endpoint".into(),
            serde_json::Value::String(value.endpoint.to_string()),
        );
    }
    if !value.params.is_empty() {
        let mut map = serde_json::Map::new();
        for (key, value) in &value.params {
            map.insert(key.clone(), serde_json::Value::String(value.to_string()));
        }
        object.insert("params".into(), serde_json::Value::Object(map));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ExternalCredentialTokenExchangeDriver`.
pub(crate) fn decode_wire_external_credential_token_exchange_driver_json(
    value: &serde_json::Value,
) -> Result<
    v1::ExternalCredentialTokenExchangeDriver,
    crate::public::generated::rpc_support::GestaltError,
> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::ExternalCredentialTokenExchangeDriver {
        r#type: match object.get("type") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        target_principal: match object.get("targetPrincipal") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        scopes: match object.get("scopes") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for scopes")
                })?
                .iter()
                .map(|item| {
                    Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                        crate::public::proto_json::decode_string(item)?,
                    )
                })
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        lifetime_seconds: match object.get("lifetimeSeconds") {
            Some(value) => crate::public::proto_json::decode_i32(value)?,
            None => 0,
        },
        endpoint: match object.get("endpoint") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        params: match object.get("params") {
            Some(value) => {
                let mut out = std::collections::BTreeMap::new();
                let Some(entries) = value.as_object() else {
                    return Err(crate::public::proto_json::invalid_proto_json(
                        "expected object for map",
                    ));
                };
                for (key, value) in entries {
                    out.insert(
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            key.to_string(),
                        )?,
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            crate::public::proto_json::decode_string(value)?,
                        )?,
                    );
                }
                out
            }
            None => std::collections::BTreeMap::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `ExternalCredentialAuthConfig` as protobuf JSON.
pub(crate) fn encode_wire_external_credential_auth_config_json(
    value: &v1::ExternalCredentialAuthConfig,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.r#type.is_empty() {
        object.insert(
            "type".into(),
            serde_json::Value::String(value.r#type.to_string()),
        );
    }
    if !value.token.is_empty() {
        object.insert(
            "token".into(),
            serde_json::Value::String(value.token.to_string()),
        );
    }
    if !value.token_prefix.is_empty() {
        object.insert(
            "tokenPrefix".into(),
            serde_json::Value::String(value.token_prefix.to_string()),
        );
    }
    if !value.grant_type.is_empty() {
        object.insert(
            "grantType".into(),
            serde_json::Value::String(value.grant_type.to_string()),
        );
    }
    if !value.token_url.is_empty() {
        object.insert(
            "tokenUrl".into(),
            serde_json::Value::String(value.token_url.to_string()),
        );
    }
    if !value.client_id.is_empty() {
        object.insert(
            "clientId".into(),
            serde_json::Value::String(value.client_id.to_string()),
        );
    }
    if !value.client_secret.is_empty() {
        object.insert(
            "clientSecret".into(),
            serde_json::Value::String(value.client_secret.to_string()),
        );
    }
    if !value.client_auth.is_empty() {
        object.insert(
            "clientAuth".into(),
            serde_json::Value::String(value.client_auth.to_string()),
        );
    }
    if !value.token_exchange.is_empty() {
        object.insert(
            "tokenExchange".into(),
            serde_json::Value::String(value.token_exchange.to_string()),
        );
    }
    if !value.scopes.is_empty() {
        object.insert(
            "scopes".into(),
            serde_json::Value::Array(
                value
                    .scopes
                    .iter()
                    .map(|item| serde_json::Value::String(item.to_string()))
                    .collect(),
            ),
        );
    }
    if !value.scope_param.is_empty() {
        object.insert(
            "scopeParam".into(),
            serde_json::Value::String(value.scope_param.to_string()),
        );
    }
    if !value.scope_separator.is_empty() {
        object.insert(
            "scopeSeparator".into(),
            serde_json::Value::String(value.scope_separator.to_string()),
        );
    }
    if !value.token_params.is_empty() {
        let mut map = serde_json::Map::new();
        for (key, value) in &value.token_params {
            map.insert(key.clone(), serde_json::Value::String(value.to_string()));
        }
        object.insert("tokenParams".into(), serde_json::Value::Object(map));
    }
    if !value.refresh_params.is_empty() {
        let mut map = serde_json::Map::new();
        for (key, value) in &value.refresh_params {
            map.insert(key.clone(), serde_json::Value::String(value.to_string()));
        }
        object.insert("refreshParams".into(), serde_json::Value::Object(map));
    }
    if !value.accept_header.is_empty() {
        object.insert(
            "acceptHeader".into(),
            serde_json::Value::String(value.accept_header.to_string()),
        );
    }
    if !value.access_token_path.is_empty() {
        object.insert(
            "accessTokenPath".into(),
            serde_json::Value::String(value.access_token_path.to_string()),
        );
    }
    if !value.token_exchange_drivers.is_empty() {
        object.insert(
            "tokenExchangeDrivers".into(),
            serde_json::Value::Array(
                value
                    .token_exchange_drivers
                    .iter()
                    .map(|item| encode_wire_external_credential_token_exchange_driver_json(item))
                    .collect(),
            ),
        );
    }
    if !value.refresh_token.is_empty() {
        object.insert(
            "refreshToken".into(),
            serde_json::Value::String(value.refresh_token.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ExternalCredentialAuthConfig`.
pub(crate) fn decode_wire_external_credential_auth_config_json(
    value: &serde_json::Value,
) -> Result<v1::ExternalCredentialAuthConfig, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::ExternalCredentialAuthConfig {
        r#type: match object.get("type") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        token: match object.get("token") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        token_prefix: match object.get("tokenPrefix") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        grant_type: match object.get("grantType") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        token_url: match object.get("tokenUrl") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        client_id: match object.get("clientId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        client_secret: match object.get("clientSecret") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        client_auth: match object.get("clientAuth") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        token_exchange: match object.get("tokenExchange") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        scopes: match object.get("scopes") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for scopes")
                })?
                .iter()
                .map(|item| {
                    Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                        crate::public::proto_json::decode_string(item)?,
                    )
                })
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        scope_param: match object.get("scopeParam") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        scope_separator: match object.get("scopeSeparator") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        token_params: match object.get("tokenParams") {
            Some(value) => {
                let mut out = std::collections::BTreeMap::new();
                let Some(entries) = value.as_object() else {
                    return Err(crate::public::proto_json::invalid_proto_json(
                        "expected object for map",
                    ));
                };
                for (key, value) in entries {
                    out.insert(
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            key.to_string(),
                        )?,
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            crate::public::proto_json::decode_string(value)?,
                        )?,
                    );
                }
                out
            }
            None => std::collections::BTreeMap::new(),
        },
        refresh_params: match object.get("refreshParams") {
            Some(value) => {
                let mut out = std::collections::BTreeMap::new();
                let Some(entries) = value.as_object() else {
                    return Err(crate::public::proto_json::invalid_proto_json(
                        "expected object for map",
                    ));
                };
                for (key, value) in entries {
                    out.insert(
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            key.to_string(),
                        )?,
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            crate::public::proto_json::decode_string(value)?,
                        )?,
                    );
                }
                out
            }
            None => std::collections::BTreeMap::new(),
        },
        accept_header: match object.get("acceptHeader") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        access_token_path: match object.get("accessTokenPath") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        token_exchange_drivers: match object.get("tokenExchangeDrivers") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json(
                        "expected array for tokenExchangeDrivers",
                    )
                })?
                .iter()
                .map(|item| decode_wire_external_credential_token_exchange_driver_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        refresh_token: match object.get("refreshToken") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `ExchangeExternalCredentialRequest` as protobuf JSON.
pub(crate) fn encode_wire_exchange_external_credential_request_json(
    value: &v1::ExchangeExternalCredentialRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.provider.is_empty() {
        object.insert(
            "provider".into(),
            serde_json::Value::String(value.provider.to_string()),
        );
    }
    if !value.connection.is_empty() {
        object.insert(
            "connection".into(),
            serde_json::Value::String(value.connection.to_string()),
        );
    }
    if !value.connection_id.is_empty() {
        object.insert(
            "connectionId".into(),
            serde_json::Value::String(value.connection_id.to_string()),
        );
    }
    if !value.credential_subject_id.is_empty() {
        object.insert(
            "credentialSubjectId".into(),
            serde_json::Value::String(value.credential_subject_id.to_string()),
        );
    }
    if !value.actor_subject_id.is_empty() {
        object.insert(
            "actorSubjectId".into(),
            serde_json::Value::String(value.actor_subject_id.to_string()),
        );
    }
    if !value.instance.is_empty() {
        object.insert(
            "instance".into(),
            serde_json::Value::String(value.instance.to_string()),
        );
    }
    if let Some(inner) = &value.auth {
        object.insert(
            "auth".into(),
            encode_wire_external_credential_auth_config_json(inner),
        );
    }
    if !value.credential_json.is_empty() {
        object.insert(
            "credentialJson".into(),
            serde_json::Value::String(value.credential_json.to_string()),
        );
    }
    if !value.connection_params.is_empty() {
        let mut map = serde_json::Map::new();
        for (key, value) in &value.connection_params {
            map.insert(key.clone(), serde_json::Value::String(value.to_string()));
        }
        object.insert("connectionParams".into(), serde_json::Value::Object(map));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ExchangeExternalCredentialRequest`.
pub(crate) fn decode_wire_exchange_external_credential_request_json(
    value: &serde_json::Value,
) -> Result<
    v1::ExchangeExternalCredentialRequest,
    crate::public::generated::rpc_support::GestaltError,
> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::ExchangeExternalCredentialRequest {
        provider: match object.get("provider") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        connection: match object.get("connection") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        connection_id: match object.get("connectionId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        credential_subject_id: match object.get("credentialSubjectId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        actor_subject_id: match object.get("actorSubjectId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        instance: match object.get("instance") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        auth: object
            .get("auth")
            .map(|value| decode_wire_external_credential_auth_config_json(value))
            .transpose()?,
        credential_json: match object.get("credentialJson") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        connection_params: match object.get("connectionParams") {
            Some(value) => {
                let mut out = std::collections::BTreeMap::new();
                let Some(entries) = value.as_object() else {
                    return Err(crate::public::proto_json::invalid_proto_json(
                        "expected object for map",
                    ));
                };
                for (key, value) in entries {
                    out.insert(
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            key.to_string(),
                        )?,
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            crate::public::proto_json::decode_string(value)?,
                        )?,
                    );
                }
                out
            }
            None => std::collections::BTreeMap::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `ExternalCredentialTokenResponse` as protobuf JSON.
pub(crate) fn encode_wire_external_credential_token_response_json(
    value: &v1::ExternalCredentialTokenResponse,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.access_token.is_empty() {
        object.insert(
            "accessToken".into(),
            serde_json::Value::String(value.access_token.to_string()),
        );
    }
    if !value.refresh_token.is_empty() {
        object.insert(
            "refreshToken".into(),
            serde_json::Value::String(value.refresh_token.to_string()),
        );
    }
    if value.expires_in != 0 {
        object.insert("expiresIn".into(), serde_json::json!(value.expires_in));
    }
    if !value.token_type.is_empty() {
        object.insert(
            "tokenType".into(),
            serde_json::Value::String(value.token_type.to_string()),
        );
    }
    if !value.extra_json.is_empty() {
        object.insert(
            "extraJson".into(),
            serde_json::Value::String(value.extra_json.to_string()),
        );
    }
    if !value.refresh_source.is_empty() {
        object.insert(
            "refreshSource".into(),
            serde_json::Value::String(value.refresh_source.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ExternalCredentialTokenResponse`.
pub(crate) fn decode_wire_external_credential_token_response_json(
    value: &serde_json::Value,
) -> Result<v1::ExternalCredentialTokenResponse, crate::public::generated::rpc_support::GestaltError>
{
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::ExternalCredentialTokenResponse {
        access_token: match object.get("accessToken") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        refresh_token: match object.get("refreshToken") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        expires_in: match object.get("expiresIn") {
            Some(value) => crate::public::proto_json::decode_i32(value)?,
            None => 0,
        },
        token_type: match object.get("tokenType") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        extra_json: match object.get("extraJson") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        refresh_source: match object.get("refreshSource") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `ExchangeExternalCredentialResponse` as protobuf JSON.
pub(crate) fn encode_wire_exchange_external_credential_response_json(
    value: &v1::ExchangeExternalCredentialResponse,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(inner) = &value.token_response {
        object.insert(
            "tokenResponse".into(),
            encode_wire_external_credential_token_response_json(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ExchangeExternalCredentialResponse`.
pub(crate) fn decode_wire_exchange_external_credential_response_json(
    value: &serde_json::Value,
) -> Result<
    v1::ExchangeExternalCredentialResponse,
    crate::public::generated::rpc_support::GestaltError,
> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::ExchangeExternalCredentialResponse {
        token_response: object
            .get("tokenResponse")
            .map(|value| decode_wire_external_credential_token_response_json(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `GetExternalCredentialRequest` as protobuf JSON.
pub(crate) fn encode_wire_get_external_credential_request_json(
    value: &v1::GetExternalCredentialRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.subject.is_empty() {
        object.insert(
            "subject".into(),
            serde_json::Value::String(value.subject.to_string()),
        );
    }
    if !value.audience.is_empty() {
        object.insert(
            "audience".into(),
            serde_json::Value::String(value.audience.to_string()),
        );
    }
    if !value.qualifier.is_empty() {
        object.insert(
            "qualifier".into(),
            serde_json::Value::String(value.qualifier.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `GetExternalCredentialRequest`.
pub(crate) fn decode_wire_get_external_credential_request_json(
    value: &serde_json::Value,
) -> Result<v1::GetExternalCredentialRequest, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::GetExternalCredentialRequest {
        subject: match object.get("subject") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        audience: match object.get("audience") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        qualifier: match object.get("qualifier") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `ListExternalCredentialsRequest` as protobuf JSON.
pub(crate) fn encode_wire_list_external_credentials_request_json(
    value: &v1::ListExternalCredentialsRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.subject.is_empty() {
        object.insert(
            "subject".into(),
            serde_json::Value::String(value.subject.to_string()),
        );
    }
    if !value.audience.is_empty() {
        object.insert(
            "audience".into(),
            serde_json::Value::String(value.audience.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ListExternalCredentialsRequest`.
pub(crate) fn decode_wire_list_external_credentials_request_json(
    value: &serde_json::Value,
) -> Result<v1::ListExternalCredentialsRequest, crate::public::generated::rpc_support::GestaltError>
{
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::ListExternalCredentialsRequest {
        subject: match object.get("subject") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        audience: match object.get("audience") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `ListExternalCredentialsResponse` as protobuf JSON.
pub(crate) fn encode_wire_list_external_credentials_response_json(
    value: &v1::ListExternalCredentialsResponse,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.credentials.is_empty() {
        object.insert(
            "credentials".into(),
            serde_json::Value::Array(
                value
                    .credentials
                    .iter()
                    .map(|item| encode_wire_external_credential_json(item))
                    .collect(),
            ),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ListExternalCredentialsResponse`.
pub(crate) fn decode_wire_list_external_credentials_response_json(
    value: &serde_json::Value,
) -> Result<v1::ListExternalCredentialsResponse, crate::public::generated::rpc_support::GestaltError>
{
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::ListExternalCredentialsResponse {
        credentials: match object.get("credentials") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for credentials")
                })?
                .iter()
                .map(|item| decode_wire_external_credential_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `ResolveExternalCredentialRequest` as protobuf JSON.
pub(crate) fn encode_wire_resolve_external_credential_request_json(
    value: &v1::ResolveExternalCredentialRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.provider.is_empty() {
        object.insert(
            "provider".into(),
            serde_json::Value::String(value.provider.to_string()),
        );
    }
    if !value.connection.is_empty() {
        object.insert(
            "connection".into(),
            serde_json::Value::String(value.connection.to_string()),
        );
    }
    if !value.connection_id.is_empty() {
        object.insert(
            "connectionId".into(),
            serde_json::Value::String(value.connection_id.to_string()),
        );
    }
    if !value.mode.is_empty() {
        object.insert(
            "mode".into(),
            serde_json::Value::String(value.mode.to_string()),
        );
    }
    if !value.credential_subject_id.is_empty() {
        object.insert(
            "credentialSubjectId".into(),
            serde_json::Value::String(value.credential_subject_id.to_string()),
        );
    }
    if !value.actor_subject_id.is_empty() {
        object.insert(
            "actorSubjectId".into(),
            serde_json::Value::String(value.actor_subject_id.to_string()),
        );
    }
    if !value.instance.is_empty() {
        object.insert(
            "instance".into(),
            serde_json::Value::String(value.instance.to_string()),
        );
    }
    if let Some(inner) = &value.auth {
        object.insert(
            "auth".into(),
            encode_wire_external_credential_auth_config_json(inner),
        );
    }
    if !value.connection_params.is_empty() {
        let mut map = serde_json::Map::new();
        for (key, value) in &value.connection_params {
            map.insert(key.clone(), serde_json::Value::String(value.to_string()));
        }
        object.insert("connectionParams".into(), serde_json::Value::Object(map));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ResolveExternalCredentialRequest`.
pub(crate) fn decode_wire_resolve_external_credential_request_json(
    value: &serde_json::Value,
) -> Result<v1::ResolveExternalCredentialRequest, crate::public::generated::rpc_support::GestaltError>
{
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::ResolveExternalCredentialRequest {
        provider: match object.get("provider") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        connection: match object.get("connection") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        connection_id: match object.get("connectionId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        mode: match object.get("mode") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        credential_subject_id: match object.get("credentialSubjectId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        actor_subject_id: match object.get("actorSubjectId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        instance: match object.get("instance") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        auth: object
            .get("auth")
            .map(|value| decode_wire_external_credential_auth_config_json(value))
            .transpose()?,
        connection_params: match object.get("connectionParams") {
            Some(value) => {
                let mut out = std::collections::BTreeMap::new();
                let Some(entries) = value.as_object() else {
                    return Err(crate::public::proto_json::invalid_proto_json(
                        "expected object for map",
                    ));
                };
                for (key, value) in entries {
                    out.insert(
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            key.to_string(),
                        )?,
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            crate::public::proto_json::decode_string(value)?,
                        )?,
                    );
                }
                out
            }
            None => std::collections::BTreeMap::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `ResolveExternalCredentialResponse` as protobuf JSON.
pub(crate) fn encode_wire_resolve_external_credential_response_json(
    value: &v1::ResolveExternalCredentialResponse,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.token.is_empty() {
        object.insert(
            "token".into(),
            serde_json::Value::String(value.token.to_string()),
        );
    }
    if let Some(inner) = &value.expires_at {
        object.insert(
            "expiresAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if !value.metadata_json.is_empty() {
        object.insert(
            "metadataJson".into(),
            serde_json::Value::String(value.metadata_json.to_string()),
        );
    }
    if !value.params.is_empty() {
        let mut map = serde_json::Map::new();
        for (key, value) in &value.params {
            map.insert(key.clone(), serde_json::Value::String(value.to_string()));
        }
        object.insert("params".into(), serde_json::Value::Object(map));
    }
    if let Some(inner) = &value.credential {
        object.insert(
            "credential".into(),
            encode_wire_external_credential_json(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ResolveExternalCredentialResponse`.
pub(crate) fn decode_wire_resolve_external_credential_response_json(
    value: &serde_json::Value,
) -> Result<
    v1::ResolveExternalCredentialResponse,
    crate::public::generated::rpc_support::GestaltError,
> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::ResolveExternalCredentialResponse {
        token: match object.get("token") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        expires_at: object
            .get("expiresAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        metadata_json: match object.get("metadataJson") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        params: match object.get("params") {
            Some(value) => {
                let mut out = std::collections::BTreeMap::new();
                let Some(entries) = value.as_object() else {
                    return Err(crate::public::proto_json::invalid_proto_json(
                        "expected object for map",
                    ));
                };
                for (key, value) in entries {
                    out.insert(
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            key.to_string(),
                        )?,
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            crate::public::proto_json::decode_string(value)?,
                        )?,
                    );
                }
                out
            }
            None => std::collections::BTreeMap::new(),
        },
        credential: object
            .get("credential")
            .map(|value| decode_wire_external_credential_json(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `UpsertExternalCredentialRequest` as protobuf JSON.
pub(crate) fn encode_wire_upsert_external_credential_request_json(
    value: &v1::UpsertExternalCredentialRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(inner) = &value.credential {
        object.insert(
            "credential".into(),
            encode_wire_external_credential_json(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `UpsertExternalCredentialRequest`.
pub(crate) fn decode_wire_upsert_external_credential_request_json(
    value: &serde_json::Value,
) -> Result<v1::UpsertExternalCredentialRequest, crate::public::generated::rpc_support::GestaltError>
{
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::UpsertExternalCredentialRequest {
        credential: object
            .get("credential")
            .map(|value| decode_wire_external_credential_json(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `ValidateExternalCredentialConfigRequest` as protobuf JSON.
pub(crate) fn encode_wire_validate_external_credential_config_request_json(
    value: &v1::ValidateExternalCredentialConfigRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.provider.is_empty() {
        object.insert(
            "provider".into(),
            serde_json::Value::String(value.provider.to_string()),
        );
    }
    if !value.connection.is_empty() {
        object.insert(
            "connection".into(),
            serde_json::Value::String(value.connection.to_string()),
        );
    }
    if !value.connection_id.is_empty() {
        object.insert(
            "connectionId".into(),
            serde_json::Value::String(value.connection_id.to_string()),
        );
    }
    if !value.mode.is_empty() {
        object.insert(
            "mode".into(),
            serde_json::Value::String(value.mode.to_string()),
        );
    }
    if let Some(inner) = &value.auth {
        object.insert(
            "auth".into(),
            encode_wire_external_credential_auth_config_json(inner),
        );
    }
    if !value.connection_params.is_empty() {
        let mut map = serde_json::Map::new();
        for (key, value) in &value.connection_params {
            map.insert(key.clone(), serde_json::Value::String(value.to_string()));
        }
        object.insert("connectionParams".into(), serde_json::Value::Object(map));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ValidateExternalCredentialConfigRequest`.
pub(crate) fn decode_wire_validate_external_credential_config_request_json(
    value: &serde_json::Value,
) -> Result<
    v1::ValidateExternalCredentialConfigRequest,
    crate::public::generated::rpc_support::GestaltError,
> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::ValidateExternalCredentialConfigRequest {
        provider: match object.get("provider") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        connection: match object.get("connection") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        connection_id: match object.get("connectionId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        mode: match object.get("mode") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        auth: object
            .get("auth")
            .map(|value| decode_wire_external_credential_auth_config_json(value))
            .transpose()?,
        connection_params: match object.get("connectionParams") {
            Some(value) => {
                let mut out = std::collections::BTreeMap::new();
                let Some(entries) = value.as_object() else {
                    return Err(crate::public::proto_json::invalid_proto_json(
                        "expected object for map",
                    ));
                };
                for (key, value) in entries {
                    out.insert(
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            key.to_string(),
                        )?,
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            crate::public::proto_json::decode_string(value)?,
                        )?,
                    );
                }
                out
            }
            None => std::collections::BTreeMap::new(),
        },
        ..Default::default()
    })
}