gestalt-sdk 0.0.1-alpha.25

// Code generated by sdkgen. DO NOT EDIT.

//! Generated wire conversions for remote.proto.

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

use crate::generated::v1;

/// Encodes a wire `TunnelEndpoint` as protobuf JSON.
pub(crate) fn encode_wire_tunnel_endpoint_json(value: &v1::TunnelEndpoint) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.host.is_empty() {
        object.insert(
            "host".into(),
            serde_json::Value::String(value.host.to_string()),
        );
    }
    if !value.certificate.is_empty() {
        object.insert(
            "certificate".into(),
            crate::public::proto_json::encode_bytes(&value.certificate),
        );
    }
    if !value.server_spki_sha256.is_empty() {
        object.insert(
            "serverSpkiSha256".into(),
            serde_json::Value::String(value.server_spki_sha256.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `TunnelEndpoint`.
pub(crate) fn decode_wire_tunnel_endpoint_json(
    value: &serde_json::Value,
) -> Result<v1::TunnelEndpoint, 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::TunnelEndpoint {
        host: match object.get("host") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        certificate: match object.get("certificate") {
            Some(value) => crate::public::proto_json::decode_bytes(value)?,
            None => Vec::new(),
        },
        server_spki_sha256: match object.get("serverSpkiSha256") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `RemoteProviderDefinition` as protobuf JSON.
pub(crate) fn encode_wire_remote_provider_definition_json(
    value: &v1::RemoteProviderDefinition,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.kind.is_empty() {
        object.insert(
            "kind".into(),
            serde_json::Value::String(value.kind.to_string()),
        );
    }
    if !value.name.is_empty() {
        object.insert(
            "name".into(),
            serde_json::Value::String(value.name.to_string()),
        );
    }
    if let Some(inner) = &value.definition {
        object.insert(
            "definition".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `RemoteProviderDefinition`.
pub(crate) fn decode_wire_remote_provider_definition_json(
    value: &serde_json::Value,
) -> Result<v1::RemoteProviderDefinition, 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::RemoteProviderDefinition {
        kind: match object.get("kind") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        name: match object.get("name") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        definition: object
            .get("definition")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `CreateRemoteRequest` as protobuf JSON.
pub(crate) fn encode_wire_create_remote_request_json(
    value: &v1::CreateRemoteRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(inner) = &value.tunnel {
        object.insert("tunnel".into(), encode_wire_tunnel_endpoint_json(inner));
    }
    if !value.providers.is_empty() {
        object.insert(
            "providers".into(),
            serde_json::Value::Array(
                value
                    .providers
                    .iter()
                    .map(|item| encode_wire_remote_provider_definition_json(item))
                    .collect(),
            ),
        );
    }
    if value.expected_generation != 0 {
        object.insert(
            "expectedGeneration".into(),
            crate::public::proto_json::encode_u64(value.expected_generation),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `CreateRemoteRequest`.
pub(crate) fn decode_wire_create_remote_request_json(
    value: &serde_json::Value,
) -> Result<v1::CreateRemoteRequest, 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::CreateRemoteRequest {
        tunnel: object
            .get("tunnel")
            .map(|value| decode_wire_tunnel_endpoint_json(value))
            .transpose()?,
        providers: match object.get("providers") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for providers")
                })?
                .iter()
                .map(|item| decode_wire_remote_provider_definition_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        expected_generation: match object.get("expectedGeneration") {
            Some(value) => crate::public::proto_json::decode_u64(value)?,
            None => 0,
        },
        ..Default::default()
    })
}

/// Encodes a wire `DeleteRemoteRequest` as protobuf JSON.
pub(crate) fn encode_wire_delete_remote_request_json(
    value: &v1::DeleteRemoteRequest,
) -> 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.expected_generation != 0 {
        object.insert(
            "expectedGeneration".into(),
            crate::public::proto_json::encode_u64(value.expected_generation),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `DeleteRemoteRequest`.
pub(crate) fn decode_wire_delete_remote_request_json(
    value: &serde_json::Value,
) -> Result<v1::DeleteRemoteRequest, 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::DeleteRemoteRequest {
        id: match object.get("id") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        expected_generation: match object.get("expectedGeneration") {
            Some(value) => crate::public::proto_json::decode_u64(value)?,
            None => 0,
        },
        ..Default::default()
    })
}

/// Encodes a wire `ListRemotesRequest` as protobuf JSON.
pub(crate) fn encode_wire_list_remotes_request_json(
    value: &v1::ListRemotesRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ListRemotesRequest`.
pub(crate) fn decode_wire_list_remotes_request_json(
    value: &serde_json::Value,
) -> Result<v1::ListRemotesRequest, 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::ListRemotesRequest {
        ..Default::default()
    })
}

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

/// Decodes protobuf JSON into a wire `RemoteProviderSummary`.
pub(crate) fn decode_wire_remote_provider_summary_json(
    value: &serde_json::Value,
) -> Result<v1::RemoteProviderSummary, 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::RemoteProviderSummary {
        kind: match object.get("kind") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        name: match object.get("name") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

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

/// Decodes protobuf JSON into a wire `RemoteReachability`.
pub(crate) fn decode_wire_remote_reachability_json(
    value: &serde_json::Value,
) -> Result<v1::RemoteReachability, 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::RemoteReachability {
        reachable: match object.get("reachable") {
            Some(value) => crate::public::proto_json::decode_bool(value)?,
            None => false,
        },
        message: match object.get("message") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `Remote` as protobuf JSON.
pub(crate) fn encode_wire_remote_json(value: &v1::Remote) -> 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.owner_subject_id.is_empty() {
        object.insert(
            "ownerSubjectId".into(),
            serde_json::Value::String(value.owner_subject_id.to_string()),
        );
    }
    if value.generation != 0 {
        object.insert(
            "generation".into(),
            crate::public::proto_json::encode_u64(value.generation),
        );
    }
    if !value.providers.is_empty() {
        object.insert(
            "providers".into(),
            serde_json::Value::Array(
                value
                    .providers
                    .iter()
                    .map(|item| encode_wire_remote_provider_summary_json(item))
                    .collect(),
            ),
        );
    }
    if let Some(inner) = &value.reachability {
        object.insert(
            "reachability".into(),
            encode_wire_remote_reachability_json(inner),
        );
    }
    if !value.server_spki_sha256.is_empty() {
        object.insert(
            "serverSpkiSha256".into(),
            serde_json::Value::String(value.server_spki_sha256.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(inner) = &value.last_checked_at {
        object.insert(
            "lastCheckedAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if let Some(inner) = &value.last_successful_heartbeat_at {
        object.insert(
            "lastSuccessfulHeartbeatAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if !value.last_error.is_empty() {
        object.insert(
            "lastError".into(),
            serde_json::Value::String(value.last_error.to_string()),
        );
    }
    if let Some(inner) = &value.lease_expires_at {
        object.insert(
            "leaseExpiresAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `Remote`.
pub(crate) fn decode_wire_remote_json(
    value: &serde_json::Value,
) -> Result<v1::Remote, 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::Remote {
        id: match object.get("id") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        owner_subject_id: match object.get("ownerSubjectId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        generation: match object.get("generation") {
            Some(value) => crate::public::proto_json::decode_u64(value)?,
            None => 0,
        },
        providers: match object.get("providers") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for providers")
                })?
                .iter()
                .map(|item| decode_wire_remote_provider_summary_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        reachability: object
            .get("reachability")
            .map(|value| decode_wire_remote_reachability_json(value))
            .transpose()?,
        server_spki_sha256: match object.get("serverSpkiSha256") {
            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()?,
        last_checked_at: object
            .get("lastCheckedAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        last_successful_heartbeat_at: object
            .get("lastSuccessfulHeartbeatAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        last_error: match object.get("lastError") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        lease_expires_at: object
            .get("leaseExpiresAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        ..Default::default()
    })
}

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

/// Decodes protobuf JSON into a wire `ServerIdentity`.
pub(crate) fn decode_wire_server_identity_json(
    value: &serde_json::Value,
) -> Result<v1::ServerIdentity, 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::ServerIdentity {
        client_spki_sha256: match object.get("clientSpkiSha256") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `TunnelBootstrap` as protobuf JSON.
pub(crate) fn encode_wire_tunnel_bootstrap_json(value: &v1::TunnelBootstrap) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.frps_address.is_empty() {
        object.insert(
            "frpsAddress".into(),
            serde_json::Value::String(value.frps_address.to_string()),
        );
    }
    if let Some(inner) = &value.lease_duration {
        object.insert(
            "leaseDuration".into(),
            crate::public::proto_json::encode_duration(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `TunnelBootstrap`.
pub(crate) fn decode_wire_tunnel_bootstrap_json(
    value: &serde_json::Value,
) -> Result<v1::TunnelBootstrap, 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::TunnelBootstrap {
        frps_address: match object.get("frpsAddress") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        lease_duration: object
            .get("leaseDuration")
            .map(|value| crate::public::proto_json::decode_duration(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `ListRemotesResponse` as protobuf JSON.
pub(crate) fn encode_wire_list_remotes_response_json(
    value: &v1::ListRemotesResponse,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.remotes.is_empty() {
        object.insert(
            "remotes".into(),
            serde_json::Value::Array(
                value
                    .remotes
                    .iter()
                    .map(|item| encode_wire_remote_json(item))
                    .collect(),
            ),
        );
    }
    if let Some(inner) = &value.server_identity {
        object.insert(
            "serverIdentity".into(),
            encode_wire_server_identity_json(inner),
        );
    }
    if let Some(inner) = &value.tunnel {
        object.insert("tunnel".into(), encode_wire_tunnel_bootstrap_json(inner));
    }
    if let Some(inner) = &value.lease_duration {
        object.insert(
            "leaseDuration".into(),
            crate::public::proto_json::encode_duration(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ListRemotesResponse`.
pub(crate) fn decode_wire_list_remotes_response_json(
    value: &serde_json::Value,
) -> Result<v1::ListRemotesResponse, 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::ListRemotesResponse {
        remotes: match object.get("remotes") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for remotes")
                })?
                .iter()
                .map(|item| decode_wire_remote_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        server_identity: object
            .get("serverIdentity")
            .map(|value| decode_wire_server_identity_json(value))
            .transpose()?,
        tunnel: object
            .get("tunnel")
            .map(|value| decode_wire_tunnel_bootstrap_json(value))
            .transpose()?,
        lease_duration: object
            .get("leaseDuration")
            .map(|value| crate::public::proto_json::decode_duration(value))
            .transpose()?,
        ..Default::default()
    })
}