gestalt-sdk 0.0.1-alpha.26

// Code generated by sdkgen. DO NOT EDIT.

//! Generated wire conversions for indexeddb.proto.

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

use crate::generated::v1;

/// Encodes a wire `ColumnDef` as protobuf JSON.
pub(crate) fn encode_wire_column_def_json(value: &v1::ColumnDef) -> 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.r#type != 0 {
        object.insert("type".into(), serde_json::json!(value.r#type));
    }
    if value.primary_key {
        object.insert(
            "primaryKey".into(),
            serde_json::Value::Bool(value.primary_key),
        );
    }
    if value.not_null {
        object.insert("notNull".into(), serde_json::Value::Bool(value.not_null));
    }
    if value.unique {
        object.insert("unique".into(), serde_json::Value::Bool(value.unique));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ColumnDef`.
pub(crate) fn decode_wire_column_def_json(
    value: &serde_json::Value,
) -> Result<v1::ColumnDef, 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::ColumnDef {
        name: match object.get("name") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        r#type: match object.get("type") {
            Some(value) => crate::public::proto_json::decode_i32(value)?,
            None => 0,
        },
        primary_key: match object.get("primaryKey") {
            Some(value) => crate::public::proto_json::decode_bool(value)?,
            None => false,
        },
        not_null: match object.get("notNull") {
            Some(value) => crate::public::proto_json::decode_bool(value)?,
            None => false,
        },
        unique: match object.get("unique") {
            Some(value) => crate::public::proto_json::decode_bool(value)?,
            None => false,
        },
        ..Default::default()
    })
}

/// Encodes a wire `CountResponse` as protobuf JSON.
pub(crate) fn encode_wire_count_response_json(value: &v1::CountResponse) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if value.count != 0 {
        object.insert(
            "count".into(),
            crate::public::proto_json::encode_i64(value.count),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `CountResponse`.
pub(crate) fn decode_wire_count_response_json(
    value: &serde_json::Value,
) -> Result<v1::CountResponse, 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::CountResponse {
        count: match object.get("count") {
            Some(value) => crate::public::proto_json::decode_i64(value)?,
            None => 0,
        },
        ..Default::default()
    })
}

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

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

/// Encodes a wire `IndexSchema` as protobuf JSON.
pub(crate) fn encode_wire_index_schema_json(value: &v1::IndexSchema) -> 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.key_path.is_empty() {
        object.insert(
            "keyPath".into(),
            serde_json::Value::Array(
                value
                    .key_path
                    .iter()
                    .map(|item| serde_json::Value::String(item.to_string()))
                    .collect(),
            ),
        );
    }
    if value.unique {
        object.insert("unique".into(), serde_json::Value::Bool(value.unique));
    }
    serde_json::Value::Object(object)
}

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

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

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

/// Encodes a wire `CreateObjectStoreRequest` as protobuf JSON.
pub(crate) fn encode_wire_create_object_store_request_json(
    value: &v1::CreateObjectStoreRequest,
) -> 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.schema {
        object.insert("schema".into(), encode_wire_object_store_schema_json(inner));
    }
    serde_json::Value::Object(object)
}

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

/// Encodes a wire `DeleteIndexRequest` as protobuf JSON.
pub(crate) fn encode_wire_delete_index_request_json(
    value: &v1::DeleteIndexRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.store.is_empty() {
        object.insert(
            "store".into(),
            serde_json::Value::String(value.store.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 `DeleteIndexRequest`.
pub(crate) fn decode_wire_delete_index_request_json(
    value: &serde_json::Value,
) -> Result<v1::DeleteIndexRequest, 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::DeleteIndexRequest {
        store: match object.get("store") {
            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 `DeleteObjectStoreRequest` as protobuf JSON.
pub(crate) fn encode_wire_delete_object_store_request_json(
    value: &v1::DeleteObjectStoreRequest,
) -> 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()),
        );
    }
    serde_json::Value::Object(object)
}

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

/// Encodes a wire `DeleteResponse` as protobuf JSON.
pub(crate) fn encode_wire_delete_response_json(value: &v1::DeleteResponse) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if value.deleted != 0 {
        object.insert(
            "deleted".into(),
            crate::public::proto_json::encode_i64(value.deleted),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `DeleteResponse`.
pub(crate) fn decode_wire_delete_response_json(
    value: &serde_json::Value,
) -> Result<v1::DeleteResponse, 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::DeleteResponse {
        deleted: match object.get("deleted") {
            Some(value) => crate::public::proto_json::decode_i64(value)?,
            None => 0,
        },
        ..Default::default()
    })
}

/// Encodes a wire `TypedValue` as protobuf JSON.
pub(crate) fn encode_wire_typed_value_json(value: &v1::TypedValue) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(active) = &value.kind {
        match active {
            v1::typed_value::Kind::NullValue(_) => {
                object.insert("nullValue".into(), serde_json::Value::Null);
            }
            v1::typed_value::Kind::StringValue(inner) => {
                object.insert(
                    "stringValue".into(),
                    serde_json::Value::String(inner.to_string()),
                );
            }
            v1::typed_value::Kind::IntValue(inner) => {
                object.insert(
                    "intValue".into(),
                    crate::public::proto_json::encode_i64(*inner),
                );
            }
            v1::typed_value::Kind::FloatValue(inner) => {
                object.insert(
                    "floatValue".into(),
                    crate::public::proto_json::encode_f64(*inner),
                );
            }
            v1::typed_value::Kind::BoolValue(inner) => {
                object.insert("boolValue".into(), serde_json::Value::Bool(*inner));
            }
            v1::typed_value::Kind::TimeValue(inner) => {
                object.insert(
                    "timeValue".into(),
                    crate::public::proto_json::encode_timestamp(inner),
                );
            }
            v1::typed_value::Kind::BytesValue(inner) => {
                object.insert(
                    "bytesValue".into(),
                    crate::public::proto_json::encode_bytes(inner),
                );
            }
            v1::typed_value::Kind::JsonValue(inner) => {
                object.insert(
                    "jsonValue".into(),
                    crate::public::proto_json::encode_value(inner),
                );
            }
        }
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `TypedValue`.
pub(crate) fn decode_wire_typed_value_json(
    value: &serde_json::Value,
) -> Result<v1::TypedValue, 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::TypedValue {
        kind: {
            let mut active = None;
            if let Some(value) = object.get("nullValue") {
                active = Some(v1::typed_value::Kind::NullValue(
                    prost_types::NullValue::NullValue as i32,
                ));
            }
            if let Some(value) = object.get("stringValue") {
                active = Some(v1::typed_value::Kind::StringValue(
                    crate::public::proto_json::decode_string(value)?,
                ));
            }
            if let Some(value) = object.get("intValue") {
                active = Some(v1::typed_value::Kind::IntValue(
                    crate::public::proto_json::decode_i64(value)?,
                ));
            }
            if let Some(value) = object.get("floatValue") {
                active = Some(v1::typed_value::Kind::FloatValue(
                    crate::public::proto_json::decode_f64(value)?,
                ));
            }
            if let Some(value) = object.get("boolValue") {
                active = Some(v1::typed_value::Kind::BoolValue(
                    crate::public::proto_json::decode_bool(value)?,
                ));
            }
            if let Some(value) = object.get("timeValue") {
                active = Some(v1::typed_value::Kind::TimeValue(
                    crate::public::proto_json::decode_timestamp(value)?,
                ));
            }
            if let Some(value) = object.get("bytesValue") {
                active = Some(v1::typed_value::Kind::BytesValue(
                    crate::public::proto_json::decode_bytes(value)?,
                ));
            }
            if let Some(value) = object.get("jsonValue") {
                active = Some(v1::typed_value::Kind::JsonValue(
                    crate::public::proto_json::decode_value(value)?,
                ));
            }
            active
        },
        ..Default::default()
    })
}

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

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

/// Encodes a wire `KeyValue` as protobuf JSON.
pub(crate) fn encode_wire_key_value_json(value: &v1::KeyValue) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(active) = &value.kind {
        match active {
            v1::key_value::Kind::Scalar(inner) => {
                object.insert("scalar".into(), encode_wire_typed_value_json(inner));
            }
            v1::key_value::Kind::Array(inner) => {
                object.insert("array".into(), encode_wire_key_value_array_json(inner));
            }
        }
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `KeyValue`.
pub(crate) fn decode_wire_key_value_json(
    value: &serde_json::Value,
) -> Result<v1::KeyValue, 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::KeyValue {
        kind: {
            let mut active = None;
            if let Some(value) = object.get("scalar") {
                active = Some(v1::key_value::Kind::Scalar(decode_wire_typed_value_json(
                    value,
                )?));
            }
            if let Some(value) = object.get("array") {
                active = Some(v1::key_value::Kind::Array(
                    decode_wire_key_value_array_json(value)?,
                ));
            }
            active
        },
        ..Default::default()
    })
}

/// Encodes a wire `KeyRange` as protobuf JSON.
pub(crate) fn encode_wire_key_range_json(value: &v1::KeyRange) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(inner) = &value.lower {
        object.insert("lower".into(), encode_wire_key_value_json(inner));
    }
    if let Some(inner) = &value.upper {
        object.insert("upper".into(), encode_wire_key_value_json(inner));
    }
    if value.lower_open {
        object.insert(
            "lowerOpen".into(),
            serde_json::Value::Bool(value.lower_open),
        );
    }
    if value.upper_open {
        object.insert(
            "upperOpen".into(),
            serde_json::Value::Bool(value.upper_open),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `KeyRange`.
pub(crate) fn decode_wire_key_range_json(
    value: &serde_json::Value,
) -> Result<v1::KeyRange, 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::KeyRange {
        lower: object
            .get("lower")
            .map(|value| decode_wire_key_value_json(value))
            .transpose()?,
        upper: object
            .get("upper")
            .map(|value| decode_wire_key_value_json(value))
            .transpose()?,
        lower_open: match object.get("lowerOpen") {
            Some(value) => crate::public::proto_json::decode_bool(value)?,
            None => false,
        },
        upper_open: match object.get("upperOpen") {
            Some(value) => crate::public::proto_json::decode_bool(value)?,
            None => false,
        },
        ..Default::default()
    })
}

/// Encodes a wire `IndexedDbQuery` as protobuf JSON.
pub(crate) fn encode_wire_indexed_db_query_json(value: &v1::IndexedDbQuery) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(active) = &value.query {
        match active {
            v1::indexed_db_query::Query::Key(inner) => {
                object.insert("key".into(), encode_wire_key_value_json(inner));
            }
            v1::indexed_db_query::Query::Range(inner) => {
                object.insert("range".into(), encode_wire_key_range_json(inner));
            }
        }
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `IndexedDbQuery`.
pub(crate) fn decode_wire_indexed_db_query_json(
    value: &serde_json::Value,
) -> Result<v1::IndexedDbQuery, 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::IndexedDbQuery {
        query: {
            let mut active = None;
            if let Some(value) = object.get("key") {
                active = Some(v1::indexed_db_query::Query::Key(
                    decode_wire_key_value_json(value)?,
                ));
            }
            if let Some(value) = object.get("range") {
                active = Some(v1::indexed_db_query::Query::Range(
                    decode_wire_key_range_json(value)?,
                ));
            }
            active
        },
        ..Default::default()
    })
}

/// Encodes a wire `IndexQueryRequest` as protobuf JSON.
pub(crate) fn encode_wire_index_query_request_json(
    value: &v1::IndexQueryRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.store.is_empty() {
        object.insert(
            "store".into(),
            serde_json::Value::String(value.store.to_string()),
        );
    }
    if !value.index.is_empty() {
        object.insert(
            "index".into(),
            serde_json::Value::String(value.index.to_string()),
        );
    }
    if let Some(inner) = &value.query {
        object.insert("query".into(), encode_wire_indexed_db_query_json(inner));
    }
    if let Some(inner) = &value.count {
        if *inner != 0 {
            object.insert("count".into(), serde_json::json!(*inner));
        }
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `IndexQueryRequest`.
pub(crate) fn decode_wire_index_query_request_json(
    value: &serde_json::Value,
) -> Result<v1::IndexQueryRequest, 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::IndexQueryRequest {
        store: match object.get("store") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        index: match object.get("index") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        query: object
            .get("query")
            .map(|value| decode_wire_indexed_db_query_json(value))
            .transpose()?,
        count: object
            .get("count")
            .map(|value| crate::public::proto_json::decode_u32(value))
            .transpose()?,
        ..Default::default()
    })
}

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

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

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

/// Decodes protobuf JSON into a wire `KeysResponse`.
pub(crate) fn decode_wire_keys_response_json(
    value: &serde_json::Value,
) -> Result<v1::KeysResponse, 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::KeysResponse {
        keys: match object.get("keys") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for keys")
                })?
                .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 `ObjectStoreNameRequest` as protobuf JSON.
pub(crate) fn encode_wire_object_store_name_request_json(
    value: &v1::ObjectStoreNameRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.store.is_empty() {
        object.insert(
            "store".into(),
            serde_json::Value::String(value.store.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

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

/// Encodes a wire `ObjectStoreRangeRequest` as protobuf JSON.
pub(crate) fn encode_wire_object_store_range_request_json(
    value: &v1::ObjectStoreRangeRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.store.is_empty() {
        object.insert(
            "store".into(),
            serde_json::Value::String(value.store.to_string()),
        );
    }
    if let Some(inner) = &value.query {
        object.insert("query".into(), encode_wire_indexed_db_query_json(inner));
    }
    if let Some(inner) = &value.count {
        if *inner != 0 {
            object.insert("count".into(), serde_json::json!(*inner));
        }
    }
    serde_json::Value::Object(object)
}

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

/// Encodes a wire `ObjectStoreRequest` as protobuf JSON.
pub(crate) fn encode_wire_object_store_request_json(
    value: &v1::ObjectStoreRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.store.is_empty() {
        object.insert(
            "store".into(),
            serde_json::Value::String(value.store.to_string()),
        );
    }
    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 `ObjectStoreRequest`.
pub(crate) fn decode_wire_object_store_request_json(
    value: &serde_json::Value,
) -> Result<v1::ObjectStoreRequest, 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::ObjectStoreRequest {
        store: match object.get("store") {
            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(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `Record` as protobuf JSON.
pub(crate) fn encode_wire_record_json(value: &v1::Record) -> 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(), encode_wire_typed_value_json(value));
        }
        object.insert("fields".into(), serde_json::Value::Object(map));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `Record`.
pub(crate) fn decode_wire_record_json(
    value: &serde_json::Value,
) -> Result<v1::Record, 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::Record {
        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(),
                        )?,
                        decode_wire_typed_value_json(value)?,
                    );
                }
                out
            }
            None => std::collections::BTreeMap::new(),
        },
        ..Default::default()
    })
}

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

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

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

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

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

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