gestalt-sdk 0.0.1-alpha.25

// Code generated by sdkgen. DO NOT EDIT.

//! Generated wire conversions for authorization.proto.

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

use crate::generated::v1;

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

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

/// Encodes a wire `Subject` as protobuf JSON.
pub(crate) fn encode_wire_subject_json(value: &v1::Subject) -> 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.id.is_empty() {
        object.insert("id".into(), serde_json::Value::String(value.id.to_string()));
    }
    if let Some(inner) = &value.properties {
        object.insert(
            "properties".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    serde_json::Value::Object(object)
}

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

/// Encodes a wire `Resource` as protobuf JSON.
pub(crate) fn encode_wire_resource_json(value: &v1::Resource) -> 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.id.is_empty() {
        object.insert("id".into(), serde_json::Value::String(value.id.to_string()));
    }
    if let Some(inner) = &value.properties {
        object.insert(
            "properties".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    serde_json::Value::Object(object)
}

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

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

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

/// Encodes a wire `RelationshipTarget` as protobuf JSON.
pub(crate) fn encode_wire_relationship_target_json(
    value: &v1::RelationshipTarget,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(active) = &value.kind {
        match active {
            v1::relationship_target::Kind::Subject(inner) => {
                object.insert("subject".into(), encode_wire_subject_json(inner));
            }
            v1::relationship_target::Kind::Resource(inner) => {
                object.insert("resource".into(), encode_wire_resource_json(inner));
            }
            v1::relationship_target::Kind::SubjectSet(inner) => {
                object.insert("subjectSet".into(), encode_wire_subject_set_json(inner));
            }
        }
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `RelationshipTarget`.
pub(crate) fn decode_wire_relationship_target_json(
    value: &serde_json::Value,
) -> Result<v1::RelationshipTarget, 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::RelationshipTarget {
        kind: {
            let mut active = None;
            if let Some(value) = object.get("subject") {
                active = Some(v1::relationship_target::Kind::Subject(
                    decode_wire_subject_json(value)?,
                ));
            }
            if let Some(value) = object.get("resource") {
                active = Some(v1::relationship_target::Kind::Resource(
                    decode_wire_resource_json(value)?,
                ));
            }
            if let Some(value) = object.get("subjectSet") {
                active = Some(v1::relationship_target::Kind::SubjectSet(
                    decode_wire_subject_set_json(value)?,
                ));
            }
            active
        },
        ..Default::default()
    })
}

/// Encodes a wire `RelationshipTuple` as protobuf JSON.
pub(crate) fn encode_wire_relationship_tuple_json(
    value: &v1::RelationshipTuple,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(inner) = &value.target {
        object.insert("target".into(), encode_wire_relationship_target_json(inner));
    }
    if !value.relation.is_empty() {
        object.insert(
            "relation".into(),
            serde_json::Value::String(value.relation.to_string()),
        );
    }
    if let Some(inner) = &value.resource {
        object.insert("resource".into(), encode_wire_resource_json(inner));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `RelationshipTuple`.
pub(crate) fn decode_wire_relationship_tuple_json(
    value: &serde_json::Value,
) -> Result<v1::RelationshipTuple, 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::RelationshipTuple {
        target: object
            .get("target")
            .map(|value| decode_wire_relationship_target_json(value))
            .transpose()?,
        relation: match object.get("relation") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        resource: object
            .get("resource")
            .map(|value| decode_wire_resource_json(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `Relationship` as protobuf JSON.
pub(crate) fn encode_wire_relationship_json(value: &v1::Relationship) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(inner) = &value.tuple {
        object.insert("tuple".into(), encode_wire_relationship_tuple_json(inner));
    }
    if let Some(inner) = &value.properties {
        object.insert(
            "properties".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if value.source_layer != 0 {
        object.insert("sourceLayer".into(), {
            let v = value.source_layer;
            if let Some(name) = match value.source_layer {
                0 => Some("SOURCE_LAYER_UNSPECIFIED"),
                1 => Some("SOURCE_LAYER_STATIC_CONFIG"),
                2 => Some("SOURCE_LAYER_RUNTIME"),
                _ => None,
            } {
                serde_json::Value::String(name.to_string())
            } else {
                serde_json::json!(v)
            }
        });
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `Relationship`.
pub(crate) fn decode_wire_relationship_json(
    value: &serde_json::Value,
) -> Result<v1::Relationship, 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::Relationship {
        tuple: object
            .get("tuple")
            .map(|value| decode_wire_relationship_tuple_json(value))
            .transpose()?,
        properties: object
            .get("properties")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        source_layer: object
            .get("sourceLayer")
            .map(|value| match value {
                serde_json::Value::String(text) => match text.as_str() {
                    "SOURCE_LAYER_UNSPECIFIED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(0)
                    }
                    "SOURCE_LAYER_STATIC_CONFIG" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(1)
                    }
                    "SOURCE_LAYER_RUNTIME" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(2)
                    }
                    _ => Err(crate::public::proto_json::invalid_proto_json(
                        "unknown enum value",
                    )),
                },
                serde_json::Value::Number(number) => number
                    .as_i64()
                    .and_then(|v| i32::try_from(v).ok())
                    .ok_or_else(|| {
                        crate::public::proto_json::invalid_proto_json("enum number out of range")
                    }),
                _ => Err(crate::public::proto_json::invalid_proto_json(
                    "expected enum value",
                )),
            })
            .transpose()?
            .unwrap_or(0),
        ..Default::default()
    })
}

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

/// Decodes protobuf JSON into a wire `AddRelationshipRequest`.
pub(crate) fn decode_wire_add_relationship_request_json(
    value: &serde_json::Value,
) -> Result<v1::AddRelationshipRequest, 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::AddRelationshipRequest {
        relationship: object
            .get("relationship")
            .map(|value| decode_wire_relationship_json(value))
            .transpose()?,
        ..Default::default()
    })
}

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

/// Decodes protobuf JSON into a wire `AddRelationshipResponse`.
pub(crate) fn decode_wire_add_relationship_response_json(
    value: &serde_json::Value,
) -> Result<v1::AddRelationshipResponse, 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::AddRelationshipResponse {
        relationship: object
            .get("relationship")
            .map(|value| decode_wire_relationship_json(value))
            .transpose()?,
        ..Default::default()
    })
}

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

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

/// Encodes a wire `ModelAllowedTarget` as protobuf JSON.
pub(crate) fn encode_wire_model_allowed_target_json(
    value: &v1::ModelAllowedTarget,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(active) = &value.kind {
        match active {
            v1::model_allowed_target::Kind::SubjectType(inner) => {
                object.insert(
                    "subjectType".into(),
                    serde_json::Value::String(inner.to_string()),
                );
            }
            v1::model_allowed_target::Kind::ResourceType(inner) => {
                object.insert(
                    "resourceType".into(),
                    serde_json::Value::String(inner.to_string()),
                );
            }
            v1::model_allowed_target::Kind::SubjectSetType(inner) => {
                object.insert(
                    "subjectSetType".into(),
                    encode_wire_subject_set_type_json(inner),
                );
            }
        }
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ModelAllowedTarget`.
pub(crate) fn decode_wire_model_allowed_target_json(
    value: &serde_json::Value,
) -> Result<v1::ModelAllowedTarget, 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::ModelAllowedTarget {
        kind: {
            let mut active = None;
            if let Some(value) = object.get("subjectType") {
                active = Some(v1::model_allowed_target::Kind::SubjectType(
                    crate::public::proto_json::decode_string(value)?,
                ));
            }
            if let Some(value) = object.get("resourceType") {
                active = Some(v1::model_allowed_target::Kind::ResourceType(
                    crate::public::proto_json::decode_string(value)?,
                ));
            }
            if let Some(value) = object.get("subjectSetType") {
                active = Some(v1::model_allowed_target::Kind::SubjectSetType(
                    decode_wire_subject_set_type_json(value)?,
                ));
            }
            active
        },
        ..Default::default()
    })
}

/// Encodes a wire `ModelRelation` as protobuf JSON.
pub(crate) fn encode_wire_model_relation_json(value: &v1::ModelRelation) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.name.is_empty() {
        object.insert(
            "name".into(),
            serde_json::Value::String(value.name.to_string()),
        );
    }
    if !value.allowed_targets.is_empty() {
        object.insert(
            "allowedTargets".into(),
            serde_json::Value::Array(
                value
                    .allowed_targets
                    .iter()
                    .map(|item| encode_wire_model_allowed_target_json(item))
                    .collect(),
            ),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ModelRelation`.
pub(crate) fn decode_wire_model_relation_json(
    value: &serde_json::Value,
) -> Result<v1::ModelRelation, 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::ModelRelation {
        name: match object.get("name") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        allowed_targets: match object.get("allowedTargets") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json(
                        "expected array for allowedTargets",
                    )
                })?
                .iter()
                .map(|item| decode_wire_model_allowed_target_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        ..Default::default()
    })
}

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

/// Decodes protobuf JSON into a wire `ModelAction`.
pub(crate) fn decode_wire_model_action_json(
    value: &serde_json::Value,
) -> Result<v1::ModelAction, 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::ModelAction {
        name: match object.get("name") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        relations: match object.get("relations") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for relations")
                })?
                .iter()
                .map(|item| {
                    Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                        crate::public::proto_json::decode_string(item)?,
                    )
                })
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `AuthorizationModelResourceType` as protobuf JSON.
pub(crate) fn encode_wire_authorization_model_resource_type_json(
    value: &v1::AuthorizationModelResourceType,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.name.is_empty() {
        object.insert(
            "name".into(),
            serde_json::Value::String(value.name.to_string()),
        );
    }
    if !value.relations.is_empty() {
        object.insert(
            "relations".into(),
            serde_json::Value::Array(
                value
                    .relations
                    .iter()
                    .map(|item| encode_wire_model_relation_json(item))
                    .collect(),
            ),
        );
    }
    if !value.actions.is_empty() {
        object.insert(
            "actions".into(),
            serde_json::Value::Array(
                value
                    .actions
                    .iter()
                    .map(|item| encode_wire_model_action_json(item))
                    .collect(),
            ),
        );
    }
    if value.source_layer != 0 {
        object.insert("sourceLayer".into(), {
            let v = value.source_layer;
            if let Some(name) = match value.source_layer {
                0 => Some("SOURCE_LAYER_UNSPECIFIED"),
                1 => Some("SOURCE_LAYER_STATIC_CONFIG"),
                2 => Some("SOURCE_LAYER_RUNTIME"),
                _ => None,
            } {
                serde_json::Value::String(name.to_string())
            } else {
                serde_json::json!(v)
            }
        });
    }
    if !value.default_role.is_empty() {
        object.insert(
            "defaultRole".into(),
            serde_json::Value::String(value.default_role.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AuthorizationModelResourceType`.
pub(crate) fn decode_wire_authorization_model_resource_type_json(
    value: &serde_json::Value,
) -> Result<v1::AuthorizationModelResourceType, 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::AuthorizationModelResourceType {
        name: match object.get("name") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        relations: match object.get("relations") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for relations")
                })?
                .iter()
                .map(|item| decode_wire_model_relation_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        actions: match object.get("actions") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for actions")
                })?
                .iter()
                .map(|item| decode_wire_model_action_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        source_layer: object
            .get("sourceLayer")
            .map(|value| match value {
                serde_json::Value::String(text) => match text.as_str() {
                    "SOURCE_LAYER_UNSPECIFIED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(0)
                    }
                    "SOURCE_LAYER_STATIC_CONFIG" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(1)
                    }
                    "SOURCE_LAYER_RUNTIME" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(2)
                    }
                    _ => Err(crate::public::proto_json::invalid_proto_json(
                        "unknown enum value",
                    )),
                },
                serde_json::Value::Number(number) => number
                    .as_i64()
                    .and_then(|v| i32::try_from(v).ok())
                    .ok_or_else(|| {
                        crate::public::proto_json::invalid_proto_json("enum number out of range")
                    }),
                _ => Err(crate::public::proto_json::invalid_proto_json(
                    "expected enum value",
                )),
            })
            .transpose()?
            .unwrap_or(0),
        default_role: match object.get("defaultRole") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `AuthorizationModel` as protobuf JSON.
pub(crate) fn encode_wire_authorization_model_json(
    value: &v1::AuthorizationModel,
) -> 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.version.is_empty() {
        object.insert(
            "version".into(),
            serde_json::Value::String(value.version.to_string()),
        );
    }
    if !value.resource_types.is_empty() {
        object.insert(
            "resourceTypes".into(),
            serde_json::Value::Array(
                value
                    .resource_types
                    .iter()
                    .map(|item| encode_wire_authorization_model_resource_type_json(item))
                    .collect(),
            ),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AuthorizationModel`.
pub(crate) fn decode_wire_authorization_model_json(
    value: &serde_json::Value,
) -> Result<v1::AuthorizationModel, 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::AuthorizationModel {
        id: match object.get("id") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        version: match object.get("version") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        resource_types: match object.get("resourceTypes") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json(
                        "expected array for resourceTypes",
                    )
                })?
                .iter()
                .map(|item| decode_wire_authorization_model_resource_type_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `AuthorizationModelRef` as protobuf JSON.
pub(crate) fn encode_wire_authorization_model_ref_json(
    value: &v1::AuthorizationModelRef,
) -> 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.version.is_empty() {
        object.insert(
            "version".into(),
            serde_json::Value::String(value.version.to_string()),
        );
    }
    if let Some(inner) = &value.created_at {
        object.insert(
            "createdAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    serde_json::Value::Object(object)
}

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

/// Encodes a wire `AuthorizationModelResourceTypeFilter` as protobuf JSON.
pub(crate) fn encode_wire_authorization_model_resource_type_filter_json(
    value: &v1::AuthorizationModelResourceTypeFilter,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.name.is_empty() {
        object.insert(
            "name".into(),
            serde_json::Value::String(value.name.to_string()),
        );
    }
    if value.source_layer != 0 {
        object.insert("sourceLayer".into(), {
            let v = value.source_layer;
            if let Some(name) = match value.source_layer {
                0 => Some("SOURCE_LAYER_UNSPECIFIED"),
                1 => Some("SOURCE_LAYER_STATIC_CONFIG"),
                2 => Some("SOURCE_LAYER_RUNTIME"),
                _ => None,
            } {
                serde_json::Value::String(name.to_string())
            } else {
                serde_json::json!(v)
            }
        });
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AuthorizationModelResourceTypeFilter`.
pub(crate) fn decode_wire_authorization_model_resource_type_filter_json(
    value: &serde_json::Value,
) -> Result<
    v1::AuthorizationModelResourceTypeFilter,
    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::AuthorizationModelResourceTypeFilter {
        name: match object.get("name") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        source_layer: object
            .get("sourceLayer")
            .map(|value| match value {
                serde_json::Value::String(text) => match text.as_str() {
                    "SOURCE_LAYER_UNSPECIFIED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(0)
                    }
                    "SOURCE_LAYER_STATIC_CONFIG" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(1)
                    }
                    "SOURCE_LAYER_RUNTIME" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(2)
                    }
                    _ => Err(crate::public::proto_json::invalid_proto_json(
                        "unknown enum value",
                    )),
                },
                serde_json::Value::Number(number) => number
                    .as_i64()
                    .and_then(|v| i32::try_from(v).ok())
                    .ok_or_else(|| {
                        crate::public::proto_json::invalid_proto_json("enum number out of range")
                    }),
                _ => Err(crate::public::proto_json::invalid_proto_json(
                    "expected enum value",
                )),
            })
            .transpose()?
            .unwrap_or(0),
        ..Default::default()
    })
}

/// Encodes a wire `CheckAccessRequest` as protobuf JSON.
pub(crate) fn encode_wire_check_access_request_json(
    value: &v1::CheckAccessRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(inner) = &value.subject {
        object.insert("subject".into(), encode_wire_subject_json(inner));
    }
    if let Some(inner) = &value.action {
        object.insert("action".into(), encode_wire_action_json(inner));
    }
    if let Some(inner) = &value.resource {
        object.insert("resource".into(), encode_wire_resource_json(inner));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `CheckAccessRequest`.
pub(crate) fn decode_wire_check_access_request_json(
    value: &serde_json::Value,
) -> Result<v1::CheckAccessRequest, 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::CheckAccessRequest {
        subject: object
            .get("subject")
            .map(|value| decode_wire_subject_json(value))
            .transpose()?,
        action: object
            .get("action")
            .map(|value| decode_wire_action_json(value))
            .transpose()?,
        resource: object
            .get("resource")
            .map(|value| decode_wire_resource_json(value))
            .transpose()?,
        ..Default::default()
    })
}

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

/// Decodes protobuf JSON into a wire `CheckAccessManyRequest`.
pub(crate) fn decode_wire_check_access_many_request_json(
    value: &serde_json::Value,
) -> Result<v1::CheckAccessManyRequest, 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::CheckAccessManyRequest {
        requests: match object.get("requests") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for requests")
                })?
                .iter()
                .map(|item| decode_wire_check_access_request_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        ..Default::default()
    })
}

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

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

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

/// Decodes protobuf JSON into a wire `CheckAccessManyResponse`.
pub(crate) fn decode_wire_check_access_many_response_json(
    value: &serde_json::Value,
) -> Result<v1::CheckAccessManyResponse, 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::CheckAccessManyResponse {
        decisions: match object.get("decisions") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for decisions")
                })?
                .iter()
                .map(|item| decode_wire_check_access_response_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        ..Default::default()
    })
}

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

/// Decodes protobuf JSON into a wire `DeleteRelationshipRequest`.
pub(crate) fn decode_wire_delete_relationship_request_json(
    value: &serde_json::Value,
) -> Result<v1::DeleteRelationshipRequest, 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::DeleteRelationshipRequest {
        relationship_tuple: object
            .get("relationshipTuple")
            .map(|value| decode_wire_relationship_tuple_json(value))
            .transpose()?,
        ..Default::default()
    })
}

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

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

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

/// Decodes protobuf JSON into a wire `GetActiveModelRefResponse`.
pub(crate) fn decode_wire_get_active_model_ref_response_json(
    value: &serde_json::Value,
) -> Result<v1::GetActiveModelRefResponse, 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::GetActiveModelRefResponse {
        model: object
            .get("model")
            .map(|value| decode_wire_authorization_model_ref_json(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `ListActiveModelResourceTypesRequest` as protobuf JSON.
pub(crate) fn encode_wire_list_active_model_resource_types_request_json(
    value: &v1::ListActiveModelResourceTypesRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(inner) = &value.filter {
        object.insert(
            "filter".into(),
            encode_wire_authorization_model_resource_type_filter_json(inner),
        );
    }
    if value.page_size != 0 {
        object.insert("pageSize".into(), serde_json::json!(value.page_size));
    }
    if !value.page_token.is_empty() {
        object.insert(
            "pageToken".into(),
            serde_json::Value::String(value.page_token.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ListActiveModelResourceTypesRequest`.
pub(crate) fn decode_wire_list_active_model_resource_types_request_json(
    value: &serde_json::Value,
) -> Result<
    v1::ListActiveModelResourceTypesRequest,
    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::ListActiveModelResourceTypesRequest {
        filter: object
            .get("filter")
            .map(|value| decode_wire_authorization_model_resource_type_filter_json(value))
            .transpose()?,
        page_size: match object.get("pageSize") {
            Some(value) => crate::public::proto_json::decode_i32(value)?,
            None => 0,
        },
        page_token: match object.get("pageToken") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `ListActiveModelResourceTypesResponse` as protobuf JSON.
pub(crate) fn encode_wire_list_active_model_resource_types_response_json(
    value: &v1::ListActiveModelResourceTypesResponse,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.resource_types.is_empty() {
        object.insert(
            "resourceTypes".into(),
            serde_json::Value::Array(
                value
                    .resource_types
                    .iter()
                    .map(|item| encode_wire_authorization_model_resource_type_json(item))
                    .collect(),
            ),
        );
    }
    if !value.next_page_token.is_empty() {
        object.insert(
            "nextPageToken".into(),
            serde_json::Value::String(value.next_page_token.to_string()),
        );
    }
    if !value.model_id.is_empty() {
        object.insert(
            "modelId".into(),
            serde_json::Value::String(value.model_id.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ListActiveModelResourceTypesResponse`.
pub(crate) fn decode_wire_list_active_model_resource_types_response_json(
    value: &serde_json::Value,
) -> Result<
    v1::ListActiveModelResourceTypesResponse,
    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::ListActiveModelResourceTypesResponse {
        resource_types: match object.get("resourceTypes") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json(
                        "expected array for resourceTypes",
                    )
                })?
                .iter()
                .map(|item| decode_wire_authorization_model_resource_type_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        next_page_token: match object.get("nextPageToken") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        model_id: match object.get("modelId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `RelationshipFilter` as protobuf JSON.
pub(crate) fn encode_wire_relationship_filter_json(
    value: &v1::RelationshipFilter,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(inner) = &value.target {
        object.insert("target".into(), encode_wire_relationship_target_json(inner));
    }
    if !value.relation.is_empty() {
        object.insert(
            "relation".into(),
            serde_json::Value::String(value.relation.to_string()),
        );
    }
    if let Some(inner) = &value.resource {
        object.insert("resource".into(), encode_wire_resource_json(inner));
    }
    if value.target_type != 0 {
        object.insert("targetType".into(), {
            let v = value.target_type;
            if let Some(name) = match value.target_type {
                0 => Some("RELATIONSHIP_TARGET_TYPE_UNSPECIFIED"),
                1 => Some("RELATIONSHIP_TARGET_TYPE_SUBJECT"),
                2 => Some("RELATIONSHIP_TARGET_TYPE_RESOURCE"),
                3 => Some("RELATIONSHIP_TARGET_TYPE_SUBJECT_SET"),
                _ => None,
            } {
                serde_json::Value::String(name.to_string())
            } else {
                serde_json::json!(v)
            }
        });
    }
    if !value.target_entity_type.is_empty() {
        object.insert(
            "targetEntityType".into(),
            serde_json::Value::String(value.target_entity_type.to_string()),
        );
    }
    if !value.resource_type.is_empty() {
        object.insert(
            "resourceType".into(),
            serde_json::Value::String(value.resource_type.to_string()),
        );
    }
    if value.source_layer != 0 {
        object.insert("sourceLayer".into(), {
            let v = value.source_layer;
            if let Some(name) = match value.source_layer {
                0 => Some("SOURCE_LAYER_UNSPECIFIED"),
                1 => Some("SOURCE_LAYER_STATIC_CONFIG"),
                2 => Some("SOURCE_LAYER_RUNTIME"),
                _ => None,
            } {
                serde_json::Value::String(name.to_string())
            } else {
                serde_json::json!(v)
            }
        });
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `RelationshipFilter`.
pub(crate) fn decode_wire_relationship_filter_json(
    value: &serde_json::Value,
) -> Result<v1::RelationshipFilter, 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::RelationshipFilter {
        target: object
            .get("target")
            .map(|value| decode_wire_relationship_target_json(value))
            .transpose()?,
        relation: match object.get("relation") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        resource: object
            .get("resource")
            .map(|value| decode_wire_resource_json(value))
            .transpose()?,
        target_type: object
            .get("targetType")
            .map(|value| match value {
                serde_json::Value::String(text) => match text.as_str() {
                    "RELATIONSHIP_TARGET_TYPE_UNSPECIFIED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(0)
                    }
                    "RELATIONSHIP_TARGET_TYPE_SUBJECT" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(1)
                    }
                    "RELATIONSHIP_TARGET_TYPE_RESOURCE" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(2)
                    }
                    "RELATIONSHIP_TARGET_TYPE_SUBJECT_SET" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(3)
                    }
                    _ => Err(crate::public::proto_json::invalid_proto_json(
                        "unknown enum value",
                    )),
                },
                serde_json::Value::Number(number) => number
                    .as_i64()
                    .and_then(|v| i32::try_from(v).ok())
                    .ok_or_else(|| {
                        crate::public::proto_json::invalid_proto_json("enum number out of range")
                    }),
                _ => Err(crate::public::proto_json::invalid_proto_json(
                    "expected enum value",
                )),
            })
            .transpose()?
            .unwrap_or(0),
        target_entity_type: match object.get("targetEntityType") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        resource_type: match object.get("resourceType") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        source_layer: object
            .get("sourceLayer")
            .map(|value| match value {
                serde_json::Value::String(text) => match text.as_str() {
                    "SOURCE_LAYER_UNSPECIFIED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(0)
                    }
                    "SOURCE_LAYER_STATIC_CONFIG" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(1)
                    }
                    "SOURCE_LAYER_RUNTIME" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(2)
                    }
                    _ => Err(crate::public::proto_json::invalid_proto_json(
                        "unknown enum value",
                    )),
                },
                serde_json::Value::Number(number) => number
                    .as_i64()
                    .and_then(|v| i32::try_from(v).ok())
                    .ok_or_else(|| {
                        crate::public::proto_json::invalid_proto_json("enum number out of range")
                    }),
                _ => Err(crate::public::proto_json::invalid_proto_json(
                    "expected enum value",
                )),
            })
            .transpose()?
            .unwrap_or(0),
        ..Default::default()
    })
}

/// Encodes a wire `ListRelationshipsRequest` as protobuf JSON.
pub(crate) fn encode_wire_list_relationships_request_json(
    value: &v1::ListRelationshipsRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(inner) = &value.filter {
        object.insert("filter".into(), encode_wire_relationship_filter_json(inner));
    }
    if value.page_size != 0 {
        object.insert("pageSize".into(), serde_json::json!(value.page_size));
    }
    if !value.page_token.is_empty() {
        object.insert(
            "pageToken".into(),
            serde_json::Value::String(value.page_token.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ListRelationshipsRequest`.
pub(crate) fn decode_wire_list_relationships_request_json(
    value: &serde_json::Value,
) -> Result<v1::ListRelationshipsRequest, 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::ListRelationshipsRequest {
        filter: object
            .get("filter")
            .map(|value| decode_wire_relationship_filter_json(value))
            .transpose()?,
        page_size: match object.get("pageSize") {
            Some(value) => crate::public::proto_json::decode_i32(value)?,
            None => 0,
        },
        page_token: match object.get("pageToken") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `ListRelationshipsResponse` as protobuf JSON.
pub(crate) fn encode_wire_list_relationships_response_json(
    value: &v1::ListRelationshipsResponse,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.relationships.is_empty() {
        object.insert(
            "relationships".into(),
            serde_json::Value::Array(
                value
                    .relationships
                    .iter()
                    .map(|item| encode_wire_relationship_json(item))
                    .collect(),
            ),
        );
    }
    if !value.next_page_token.is_empty() {
        object.insert(
            "nextPageToken".into(),
            serde_json::Value::String(value.next_page_token.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ListRelationshipsResponse`.
pub(crate) fn decode_wire_list_relationships_response_json(
    value: &serde_json::Value,
) -> Result<v1::ListRelationshipsResponse, 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::ListRelationshipsResponse {
        relationships: match object.get("relationships") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json(
                        "expected array for relationships",
                    )
                })?
                .iter()
                .map(|item| decode_wire_relationship_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        next_page_token: match object.get("nextPageToken") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

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

/// Decodes protobuf JSON into a wire `SetActiveModelRequest`.
pub(crate) fn decode_wire_set_active_model_request_json(
    value: &serde_json::Value,
) -> Result<v1::SetActiveModelRequest, 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::SetActiveModelRequest {
        model: object
            .get("model")
            .map(|value| decode_wire_authorization_model_json(value))
            .transpose()?,
        ..Default::default()
    })
}

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

/// Decodes protobuf JSON into a wire `SetActiveModelResponse`.
pub(crate) fn decode_wire_set_active_model_response_json(
    value: &serde_json::Value,
) -> Result<v1::SetActiveModelResponse, 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::SetActiveModelResponse {
        model: object
            .get("model")
            .map(|value| decode_wire_authorization_model_ref_json(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `SetAuthorizationStateRequest` as protobuf JSON.
pub(crate) fn encode_wire_set_authorization_state_request_json(
    value: &v1::SetAuthorizationStateRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(inner) = &value.model {
        object.insert("model".into(), encode_wire_authorization_model_json(inner));
    }
    if !value.relationships.is_empty() {
        object.insert(
            "relationships".into(),
            serde_json::Value::Array(
                value
                    .relationships
                    .iter()
                    .map(|item| encode_wire_relationship_json(item))
                    .collect(),
            ),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `SetAuthorizationStateRequest`.
pub(crate) fn decode_wire_set_authorization_state_request_json(
    value: &serde_json::Value,
) -> Result<v1::SetAuthorizationStateRequest, 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::SetAuthorizationStateRequest {
        model: object
            .get("model")
            .map(|value| decode_wire_authorization_model_json(value))
            .transpose()?,
        relationships: match object.get("relationships") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json(
                        "expected array for relationships",
                    )
                })?
                .iter()
                .map(|item| decode_wire_relationship_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        ..Default::default()
    })
}

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

/// Decodes protobuf JSON into a wire `SetAuthorizationStateResponse`.
pub(crate) fn decode_wire_set_authorization_state_response_json(
    value: &serde_json::Value,
) -> Result<v1::SetAuthorizationStateResponse, 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::SetAuthorizationStateResponse {
        active_model: object
            .get("activeModel")
            .map(|value| decode_wire_authorization_model_ref_json(value))
            .transpose()?,
        ..Default::default()
    })
}