nebula-fbthrift-common-v1 0.3.0

// @generated by Thrift for src/interface/common.thrift
// This file is probably not the place you want to edit!

//! Thrift type definitions for `common`.

#![allow(clippy::redundant_closure)]


pub type GraphSpaceID = ::std::primitive::i32;

pub type PartitionID = ::std::primitive::i32;

pub type TagID = ::std::primitive::i32;

pub type EdgeType = ::std::primitive::i32;

pub type EdgeRanking = ::std::primitive::i64;

pub type VertexID = ::std::primitive::i64;

pub type IndexID = ::std::primitive::i32;

pub type IPv4 = ::std::primitive::i32;

pub type Port = ::std::primitive::i32;

pub type SchemaVer = ::std::primitive::i64;

pub type ClusterID = ::std::primitive::i64;

#[derive(Clone, PartialEq)]
pub struct ValueType {
    pub r#type: crate::types::SupportedType,
    pub value_type: ::std::option::Option<Box<crate::types::ValueType>>,
    pub schema: ::std::option::Option<crate::types::Schema>,
    // This field forces `..Default::default()` when instantiating this
    // struct, to make code future-proof against new fields added later to
    // the definition in Thrift. If you don't want this, add the annotation
    // `(rust.exhaustive)` to the Thrift struct to eliminate this field.
    #[doc(hidden)]
    pub _dot_dot_Default_default: self::dot_dot::OtherFields,
}

#[derive(Clone, PartialEq, Debug)]
pub enum Value {
    int_value(::std::primitive::i64),
    bool_value(::std::primitive::bool),
    double_value(::std::primitive::f64),
    string_value(::std::string::String),
    timestamp(::std::primitive::i64),
    UnknownField(::std::primitive::i32),
}

#[derive(Clone, PartialEq)]
pub struct ColumnDef {
    pub name: ::std::string::String,
    pub r#type: crate::types::ValueType,
    pub default_value: ::std::option::Option<crate::types::Value>,
    // This field forces `..Default::default()` when instantiating this
    // struct, to make code future-proof against new fields added later to
    // the definition in Thrift. If you don't want this, add the annotation
    // `(rust.exhaustive)` to the Thrift struct to eliminate this field.
    #[doc(hidden)]
    pub _dot_dot_Default_default: self::dot_dot::OtherFields,
}

#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct SchemaProp {
    pub ttl_duration: ::std::option::Option<::std::primitive::i64>,
    pub ttl_col: ::std::option::Option<::std::string::String>,
    // This field forces `..Default::default()` when instantiating this
    // struct, to make code future-proof against new fields added later to
    // the definition in Thrift. If you don't want this, add the annotation
    // `(rust.exhaustive)` to the Thrift struct to eliminate this field.
    #[doc(hidden)]
    pub _dot_dot_Default_default: self::dot_dot::OtherFields,
}

#[derive(Clone, PartialEq)]
pub struct Schema {
    pub columns: ::std::vec::Vec<crate::types::ColumnDef>,
    pub schema_prop: crate::types::SchemaProp,
    // This field forces `..Default::default()` when instantiating this
    // struct, to make code future-proof against new fields added later to
    // the definition in Thrift. If you don't want this, add the annotation
    // `(rust.exhaustive)` to the Thrift struct to eliminate this field.
    #[doc(hidden)]
    pub _dot_dot_Default_default: self::dot_dot::OtherFields,
}

#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
pub enum SchemaID {
    tag_id(crate::types::TagID),
    edge_type(crate::types::EdgeType),
    UnknownField(::std::primitive::i32),
}

#[derive(Clone, PartialEq)]
pub struct IndexItem {
    pub index_id: crate::types::IndexID,
    pub index_name: ::std::string::String,
    pub schema_id: crate::types::SchemaID,
    pub schema_name: ::std::string::String,
    pub fields: ::std::vec::Vec<crate::types::ColumnDef>,
    // This field forces `..Default::default()` when instantiating this
    // struct, to make code future-proof against new fields added later to
    // the definition in Thrift. If you don't want this, add the annotation
    // `(rust.exhaustive)` to the Thrift struct to eliminate this field.
    #[doc(hidden)]
    pub _dot_dot_Default_default: self::dot_dot::OtherFields,
}

#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct HostAddr {
    pub ip: crate::types::IPv4,
    pub port: crate::types::Port,
    // This field forces `..Default::default()` when instantiating this
    // struct, to make code future-proof against new fields added later to
    // the definition in Thrift. If you don't want this, add the annotation
    // `(rust.exhaustive)` to the Thrift struct to eliminate this field.
    #[doc(hidden)]
    pub _dot_dot_Default_default: self::dot_dot::OtherFields,
}

#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Pair {
    pub key: ::std::string::String,
    pub value: ::std::string::String,
    // This field forces `..Default::default()` when instantiating this
    // struct, to make code future-proof against new fields added later to
    // the definition in Thrift. If you don't want this, add the annotation
    // `(rust.exhaustive)` to the Thrift struct to eliminate this field.
    #[doc(hidden)]
    pub _dot_dot_Default_default: self::dot_dot::OtherFields,
}

#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct RoleItem {
    pub user: ::std::string::String,
    pub space_id: crate::types::GraphSpaceID,
    pub role_type: crate::types::RoleType,
    // This field forces `..Default::default()` when instantiating this
    // struct, to make code future-proof against new fields added later to
    // the definition in Thrift. If you don't want this, add the annotation
    // `(rust.exhaustive)` to the Thrift struct to eliminate this field.
    #[doc(hidden)]
    pub _dot_dot_Default_default: self::dot_dot::OtherFields,
}

#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct SupportedType(pub ::std::primitive::i32);

impl SupportedType {
    pub const UNKNOWN: Self = SupportedType(0i32);
    pub const BOOL: Self = SupportedType(1i32);
    pub const INT: Self = SupportedType(2i32);
    pub const VID: Self = SupportedType(3i32);
    pub const FLOAT: Self = SupportedType(4i32);
    pub const DOUBLE: Self = SupportedType(5i32);
    pub const STRING: Self = SupportedType(6i32);
    pub const TIMESTAMP: Self = SupportedType(21i32);
    pub const YEAR: Self = SupportedType(22i32);
    pub const YEARMONTH: Self = SupportedType(23i32);
    pub const DATE: Self = SupportedType(24i32);
    pub const DATETIME: Self = SupportedType(25i32);
    pub const PATH: Self = SupportedType(41i32);
}

impl ::fbthrift::ThriftEnum for SupportedType {
    fn enumerate() -> &'static [(Self, &'static str)] {
        &[
            (Self::UNKNOWN, "UNKNOWN"),
            (Self::BOOL, "BOOL"),
            (Self::INT, "INT"),
            (Self::VID, "VID"),
            (Self::FLOAT, "FLOAT"),
            (Self::DOUBLE, "DOUBLE"),
            (Self::STRING, "STRING"),
            (Self::TIMESTAMP, "TIMESTAMP"),
            (Self::YEAR, "YEAR"),
            (Self::YEARMONTH, "YEARMONTH"),
            (Self::DATE, "DATE"),
            (Self::DATETIME, "DATETIME"),
            (Self::PATH, "PATH"),
        ]
    }

    fn variants() -> &'static [&'static str] {
        &[
            "UNKNOWN",
            "BOOL",
            "INT",
            "VID",
            "FLOAT",
            "DOUBLE",
            "STRING",
            "TIMESTAMP",
            "YEAR",
            "YEARMONTH",
            "DATE",
            "DATETIME",
            "PATH",
        ]
    }

    fn variant_values() -> &'static [Self] {
        &[
            Self::UNKNOWN,
            Self::BOOL,
            Self::INT,
            Self::VID,
            Self::FLOAT,
            Self::DOUBLE,
            Self::STRING,
            Self::TIMESTAMP,
            Self::YEAR,
            Self::YEARMONTH,
            Self::DATE,
            Self::DATETIME,
            Self::PATH,
        ]
    }
}

impl ::std::default::Default for SupportedType {
    fn default() -> Self {
        Self(::fbthrift::__UNKNOWN_ID)
    }
}

impl<'a> ::std::convert::From<&'a SupportedType> for ::std::primitive::i32 {
    #[inline]
    fn from(x: &'a SupportedType) -> Self {
        x.0
    }
}

impl ::std::convert::From<SupportedType> for ::std::primitive::i32 {
    #[inline]
    fn from(x: SupportedType) -> Self {
        x.0
    }
}

impl ::std::convert::From<::std::primitive::i32> for SupportedType {
    #[inline]
    fn from(x: ::std::primitive::i32) -> Self {
        Self(x)
    }
}

impl ::std::fmt::Display for SupportedType {
    fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        static VARIANTS_BY_NUMBER: &[(&::std::primitive::str, ::std::primitive::i32)] = &[
            ("UNKNOWN", 0),
            ("BOOL", 1),
            ("INT", 2),
            ("VID", 3),
            ("FLOAT", 4),
            ("DOUBLE", 5),
            ("STRING", 6),
            ("TIMESTAMP", 21),
            ("YEAR", 22),
            ("YEARMONTH", 23),
            ("DATE", 24),
            ("DATETIME", 25),
            ("PATH", 41),
        ];
        ::fbthrift::help::enum_display(VARIANTS_BY_NUMBER, fmt, self.0)
    }
}

impl ::std::fmt::Debug for SupportedType {
    fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(fmt, "SupportedType::{}", self)
    }
}

impl ::std::str::FromStr for SupportedType {
    type Err = ::anyhow::Error;

    fn from_str(string: &::std::primitive::str) -> ::std::result::Result<Self, Self::Err> {
        static VARIANTS_BY_NAME: &[(&::std::primitive::str, ::std::primitive::i32)] = &[
            ("BOOL", 1),
            ("DATE", 24),
            ("DATETIME", 25),
            ("DOUBLE", 5),
            ("FLOAT", 4),
            ("INT", 2),
            ("PATH", 41),
            ("STRING", 6),
            ("TIMESTAMP", 21),
            ("UNKNOWN", 0),
            ("VID", 3),
            ("YEAR", 22),
            ("YEARMONTH", 23),
        ];
        ::fbthrift::help::enum_from_str(VARIANTS_BY_NAME, string, "SupportedType").map(Self)
    }
}

impl ::fbthrift::GetTType for SupportedType {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::I32;
}

impl<P> ::fbthrift::Serialize<P> for SupportedType
where
    P: ::fbthrift::ProtocolWriter,
{
    #[inline]
    fn write(&self, p: &mut P) {
        p.write_i32(self.into())
    }
}

impl<P> ::fbthrift::Deserialize<P> for SupportedType
where
    P: ::fbthrift::ProtocolReader,
{
    #[inline]
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        ::std::result::Result::Ok(Self::from(p.read_i32()?))
    }
}

#[doc = "* GOD is A global senior administrator.like root of Linux systems.\n* ADMIN is an administrator for a given Graph Space.\n* DBA is an schema administrator for a given Graph Space.\n* USER is a normal user for a given Graph Space. A User can access (read and write) the data in the Graph Space.\n* GUEST is a read-only role for a given Graph Space. A Guest cannot modify the data in the Graph Space.\n* Refer to header file src/graph/PermissionManager.h for details."]
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct RoleType(pub ::std::primitive::i32);

impl RoleType {
    pub const GOD: Self = RoleType(1i32);
    pub const ADMIN: Self = RoleType(2i32);
    pub const DBA: Self = RoleType(3i32);
    pub const USER: Self = RoleType(4i32);
    pub const GUEST: Self = RoleType(5i32);
}

impl ::fbthrift::ThriftEnum for RoleType {
    fn enumerate() -> &'static [(Self, &'static str)] {
        &[
            (Self::GOD, "GOD"),
            (Self::ADMIN, "ADMIN"),
            (Self::DBA, "DBA"),
            (Self::USER, "USER"),
            (Self::GUEST, "GUEST"),
        ]
    }

    fn variants() -> &'static [&'static str] {
        &[
            "GOD",
            "ADMIN",
            "DBA",
            "USER",
            "GUEST",
        ]
    }

    fn variant_values() -> &'static [Self] {
        &[
            Self::GOD,
            Self::ADMIN,
            Self::DBA,
            Self::USER,
            Self::GUEST,
        ]
    }
}

impl ::std::default::Default for RoleType {
    fn default() -> Self {
        Self(::fbthrift::__UNKNOWN_ID)
    }
}

impl<'a> ::std::convert::From<&'a RoleType> for ::std::primitive::i32 {
    #[inline]
    fn from(x: &'a RoleType) -> Self {
        x.0
    }
}

impl ::std::convert::From<RoleType> for ::std::primitive::i32 {
    #[inline]
    fn from(x: RoleType) -> Self {
        x.0
    }
}

impl ::std::convert::From<::std::primitive::i32> for RoleType {
    #[inline]
    fn from(x: ::std::primitive::i32) -> Self {
        Self(x)
    }
}

impl ::std::fmt::Display for RoleType {
    fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        static VARIANTS_BY_NUMBER: &[(&::std::primitive::str, ::std::primitive::i32)] = &[
            ("GOD", 1),
            ("ADMIN", 2),
            ("DBA", 3),
            ("USER", 4),
            ("GUEST", 5),
        ];
        ::fbthrift::help::enum_display(VARIANTS_BY_NUMBER, fmt, self.0)
    }
}

impl ::std::fmt::Debug for RoleType {
    fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(fmt, "RoleType::{}", self)
    }
}

impl ::std::str::FromStr for RoleType {
    type Err = ::anyhow::Error;

    fn from_str(string: &::std::primitive::str) -> ::std::result::Result<Self, Self::Err> {
        static VARIANTS_BY_NAME: &[(&::std::primitive::str, ::std::primitive::i32)] = &[
            ("ADMIN", 2),
            ("DBA", 3),
            ("GOD", 1),
            ("GUEST", 5),
            ("USER", 4),
        ];
        ::fbthrift::help::enum_from_str(VARIANTS_BY_NAME, string, "RoleType").map(Self)
    }
}

impl ::fbthrift::GetTType for RoleType {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::I32;
}

impl<P> ::fbthrift::Serialize<P> for RoleType
where
    P: ::fbthrift::ProtocolWriter,
{
    #[inline]
    fn write(&self, p: &mut P) {
        p.write_i32(self.into())
    }
}

impl<P> ::fbthrift::Deserialize<P> for RoleType
where
    P: ::fbthrift::ProtocolReader,
{
    #[inline]
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        ::std::result::Result::Ok(Self::from(p.read_i32()?))
    }
}












#[allow(clippy::derivable_impls)]
impl ::std::default::Default for self::ValueType {
    fn default() -> Self {
        Self {
            r#type: ::std::default::Default::default(),
            value_type: ::std::option::Option::None,
            schema: ::std::option::Option::None,
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        }
    }
}

impl ::std::fmt::Debug for self::ValueType {
    fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        formatter
            .debug_struct("ValueType")
            .field("r#type", &self.r#type)
            .field("value_type", &self.value_type)
            .field("schema", &self.schema)
            .finish()
    }
}

unsafe impl ::std::marker::Send for self::ValueType {}
unsafe impl ::std::marker::Sync for self::ValueType {}

impl ::fbthrift::GetTType for self::ValueType {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for self::ValueType
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("ValueType");
        p.write_field_begin("type", ::fbthrift::TType::I32, 1);
        ::fbthrift::Serialize::write(&self.r#type, p);
        p.write_field_end();
        if let ::std::option::Option::Some(some) = &self.value_type {
            p.write_field_begin("value_type", ::fbthrift::TType::Struct, 2);
            ::fbthrift::Serialize::write(some, p);
            p.write_field_end();
        }
        if let ::std::option::Option::Some(some) = &self.schema {
            p.write_field_begin("schema", ::fbthrift::TType::Struct, 3);
            ::fbthrift::Serialize::write(some, p);
            p.write_field_end();
        }
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for self::ValueType
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("schema", ::fbthrift::TType::Struct, 3),
            ::fbthrift::Field::new("type", ::fbthrift::TType::I32, 1),
            ::fbthrift::Field::new("value_type", ::fbthrift::TType::Struct, 2),
        ];
        let mut field_type = ::std::option::Option::None;
        let mut field_value_type = ::std::option::Option::None;
        let mut field_schema = ::std::option::Option::None;
        let _ = p.read_struct_begin(|_| ())?;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32) {
                (::fbthrift::TType::Stop, _) => break,
                (::fbthrift::TType::I32, 1) => field_type = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::Struct, 2) => field_value_type = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::Struct, 3) => field_schema = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (fty, _) => p.skip(fty)?,
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(Self {
            r#type: field_type.unwrap_or_default(),
            value_type: field_value_type,
            schema: field_schema,
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        })
    }
}



impl ::std::default::Default for Value {
    fn default() -> Self {
        Self::UnknownField(-1)
    }
}

impl ::fbthrift::GetTType for Value {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for Value
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("Value");
        match self {
            Self::int_value(inner) => {
                p.write_field_begin("int_value", ::fbthrift::TType::I64, 1);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::bool_value(inner) => {
                p.write_field_begin("bool_value", ::fbthrift::TType::Bool, 2);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::double_value(inner) => {
                p.write_field_begin("double_value", ::fbthrift::TType::Double, 3);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::string_value(inner) => {
                p.write_field_begin("string_value", ::fbthrift::TType::String, 4);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::timestamp(inner) => {
                p.write_field_begin("timestamp", ::fbthrift::TType::I64, 5);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::UnknownField(_) => {}
        }
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for Value
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("bool_value", ::fbthrift::TType::Bool, 2),
            ::fbthrift::Field::new("double_value", ::fbthrift::TType::Double, 3),
            ::fbthrift::Field::new("int_value", ::fbthrift::TType::I64, 1),
            ::fbthrift::Field::new("string_value", ::fbthrift::TType::String, 4),
            ::fbthrift::Field::new("timestamp", ::fbthrift::TType::I64, 5),
        ];
        let _ = p.read_struct_begin(|_| ())?;
        let mut once = false;
        let mut alt = ::std::option::Option::None;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32, once) {
                (::fbthrift::TType::Stop, _, _) => break,
                (::fbthrift::TType::I64, 1, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::int_value(::fbthrift::Deserialize::read(p)?));
                }
                (::fbthrift::TType::Bool, 2, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::bool_value(::fbthrift::Deserialize::read(p)?));
                }
                (::fbthrift::TType::Double, 3, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::double_value(::fbthrift::Deserialize::read(p)?));
                }
                (::fbthrift::TType::String, 4, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::string_value(::fbthrift::Deserialize::read(p)?));
                }
                (::fbthrift::TType::I64, 5, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::timestamp(::fbthrift::Deserialize::read(p)?));
                }
                (fty, _, false) => p.skip(fty)?,
                (badty, badid, true) => return ::std::result::Result::Err(::std::convert::From::from(::fbthrift::ApplicationException::new(
                    ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
                    format!(
                        "unwanted extra union {} field ty {:?} id {}",
                        "Value",
                        badty,
                        badid,
                    ),
                ))),
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(alt.unwrap_or_default())
    }
}

#[allow(clippy::derivable_impls)]
impl ::std::default::Default for self::ColumnDef {
    fn default() -> Self {
        Self {
            name: ::std::default::Default::default(),
            r#type: ::std::default::Default::default(),
            default_value: ::std::option::Option::None,
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        }
    }
}

impl ::std::fmt::Debug for self::ColumnDef {
    fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        formatter
            .debug_struct("ColumnDef")
            .field("name", &self.name)
            .field("r#type", &self.r#type)
            .field("default_value", &self.default_value)
            .finish()
    }
}

unsafe impl ::std::marker::Send for self::ColumnDef {}
unsafe impl ::std::marker::Sync for self::ColumnDef {}

impl ::fbthrift::GetTType for self::ColumnDef {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for self::ColumnDef
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("ColumnDef");
        p.write_field_begin("name", ::fbthrift::TType::String, 1);
        ::fbthrift::Serialize::write(&self.name, p);
        p.write_field_end();
        p.write_field_begin("type", ::fbthrift::TType::Struct, 2);
        ::fbthrift::Serialize::write(&self.r#type, p);
        p.write_field_end();
        if let ::std::option::Option::Some(some) = &self.default_value {
            p.write_field_begin("default_value", ::fbthrift::TType::Struct, 3);
            ::fbthrift::Serialize::write(some, p);
            p.write_field_end();
        }
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for self::ColumnDef
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("default_value", ::fbthrift::TType::Struct, 3),
            ::fbthrift::Field::new("name", ::fbthrift::TType::String, 1),
            ::fbthrift::Field::new("type", ::fbthrift::TType::Struct, 2),
        ];
        let mut field_name = ::std::option::Option::None;
        let mut field_type = ::std::option::Option::None;
        let mut field_default_value = ::std::option::Option::None;
        let _ = p.read_struct_begin(|_| ())?;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32) {
                (::fbthrift::TType::Stop, _) => break,
                (::fbthrift::TType::String, 1) => field_name = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::Struct, 2) => field_type = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::Struct, 3) => field_default_value = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (fty, _) => p.skip(fty)?,
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(Self {
            name: field_name.unwrap_or_default(),
            r#type: field_type.unwrap_or_default(),
            default_value: field_default_value,
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        })
    }
}


#[allow(clippy::derivable_impls)]
impl ::std::default::Default for self::SchemaProp {
    fn default() -> Self {
        Self {
            ttl_duration: ::std::option::Option::None,
            ttl_col: ::std::option::Option::None,
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        }
    }
}

impl ::std::fmt::Debug for self::SchemaProp {
    fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        formatter
            .debug_struct("SchemaProp")
            .field("ttl_duration", &self.ttl_duration)
            .field("ttl_col", &self.ttl_col)
            .finish()
    }
}

unsafe impl ::std::marker::Send for self::SchemaProp {}
unsafe impl ::std::marker::Sync for self::SchemaProp {}

impl ::fbthrift::GetTType for self::SchemaProp {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for self::SchemaProp
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("SchemaProp");
        if let ::std::option::Option::Some(some) = &self.ttl_duration {
            p.write_field_begin("ttl_duration", ::fbthrift::TType::I64, 1);
            ::fbthrift::Serialize::write(some, p);
            p.write_field_end();
        }
        if let ::std::option::Option::Some(some) = &self.ttl_col {
            p.write_field_begin("ttl_col", ::fbthrift::TType::String, 2);
            ::fbthrift::Serialize::write(some, p);
            p.write_field_end();
        }
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for self::SchemaProp
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("ttl_col", ::fbthrift::TType::String, 2),
            ::fbthrift::Field::new("ttl_duration", ::fbthrift::TType::I64, 1),
        ];
        let mut field_ttl_duration = ::std::option::Option::None;
        let mut field_ttl_col = ::std::option::Option::None;
        let _ = p.read_struct_begin(|_| ())?;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32) {
                (::fbthrift::TType::Stop, _) => break,
                (::fbthrift::TType::I64, 1) => field_ttl_duration = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::String, 2) => field_ttl_col = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (fty, _) => p.skip(fty)?,
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(Self {
            ttl_duration: field_ttl_duration,
            ttl_col: field_ttl_col,
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        })
    }
}


#[allow(clippy::derivable_impls)]
impl ::std::default::Default for self::Schema {
    fn default() -> Self {
        Self {
            columns: ::std::default::Default::default(),
            schema_prop: ::std::default::Default::default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        }
    }
}

impl ::std::fmt::Debug for self::Schema {
    fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        formatter
            .debug_struct("Schema")
            .field("columns", &self.columns)
            .field("schema_prop", &self.schema_prop)
            .finish()
    }
}

unsafe impl ::std::marker::Send for self::Schema {}
unsafe impl ::std::marker::Sync for self::Schema {}

impl ::fbthrift::GetTType for self::Schema {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for self::Schema
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("Schema");
        p.write_field_begin("columns", ::fbthrift::TType::List, 1);
        ::fbthrift::Serialize::write(&self.columns, p);
        p.write_field_end();
        p.write_field_begin("schema_prop", ::fbthrift::TType::Struct, 2);
        ::fbthrift::Serialize::write(&self.schema_prop, p);
        p.write_field_end();
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for self::Schema
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("columns", ::fbthrift::TType::List, 1),
            ::fbthrift::Field::new("schema_prop", ::fbthrift::TType::Struct, 2),
        ];
        let mut field_columns = ::std::option::Option::None;
        let mut field_schema_prop = ::std::option::Option::None;
        let _ = p.read_struct_begin(|_| ())?;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32) {
                (::fbthrift::TType::Stop, _) => break,
                (::fbthrift::TType::List, 1) => field_columns = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::Struct, 2) => field_schema_prop = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (fty, _) => p.skip(fty)?,
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(Self {
            columns: field_columns.unwrap_or_default(),
            schema_prop: field_schema_prop.unwrap_or_default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        })
    }
}



impl ::std::default::Default for SchemaID {
    fn default() -> Self {
        Self::UnknownField(-1)
    }
}

impl ::fbthrift::GetTType for SchemaID {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for SchemaID
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("SchemaID");
        match self {
            Self::tag_id(inner) => {
                p.write_field_begin("tag_id", ::fbthrift::TType::I32, 1);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::edge_type(inner) => {
                p.write_field_begin("edge_type", ::fbthrift::TType::I32, 2);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::UnknownField(_) => {}
        }
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for SchemaID
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("edge_type", ::fbthrift::TType::I32, 2),
            ::fbthrift::Field::new("tag_id", ::fbthrift::TType::I32, 1),
        ];
        let _ = p.read_struct_begin(|_| ())?;
        let mut once = false;
        let mut alt = ::std::option::Option::None;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32, once) {
                (::fbthrift::TType::Stop, _, _) => break,
                (::fbthrift::TType::I32, 1, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::tag_id(::fbthrift::Deserialize::read(p)?));
                }
                (::fbthrift::TType::I32, 2, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::edge_type(::fbthrift::Deserialize::read(p)?));
                }
                (fty, _, false) => p.skip(fty)?,
                (badty, badid, true) => return ::std::result::Result::Err(::std::convert::From::from(::fbthrift::ApplicationException::new(
                    ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
                    format!(
                        "unwanted extra union {} field ty {:?} id {}",
                        "SchemaID",
                        badty,
                        badid,
                    ),
                ))),
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(alt.unwrap_or_default())
    }
}

#[allow(clippy::derivable_impls)]
impl ::std::default::Default for self::IndexItem {
    fn default() -> Self {
        Self {
            index_id: ::std::default::Default::default(),
            index_name: ::std::default::Default::default(),
            schema_id: ::std::default::Default::default(),
            schema_name: ::std::default::Default::default(),
            fields: ::std::default::Default::default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        }
    }
}

impl ::std::fmt::Debug for self::IndexItem {
    fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        formatter
            .debug_struct("IndexItem")
            .field("index_id", &self.index_id)
            .field("index_name", &self.index_name)
            .field("schema_id", &self.schema_id)
            .field("schema_name", &self.schema_name)
            .field("fields", &self.fields)
            .finish()
    }
}

unsafe impl ::std::marker::Send for self::IndexItem {}
unsafe impl ::std::marker::Sync for self::IndexItem {}

impl ::fbthrift::GetTType for self::IndexItem {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for self::IndexItem
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("IndexItem");
        p.write_field_begin("index_id", ::fbthrift::TType::I32, 1);
        ::fbthrift::Serialize::write(&self.index_id, p);
        p.write_field_end();
        p.write_field_begin("index_name", ::fbthrift::TType::String, 2);
        ::fbthrift::Serialize::write(&self.index_name, p);
        p.write_field_end();
        p.write_field_begin("schema_id", ::fbthrift::TType::Struct, 3);
        ::fbthrift::Serialize::write(&self.schema_id, p);
        p.write_field_end();
        p.write_field_begin("schema_name", ::fbthrift::TType::String, 4);
        ::fbthrift::Serialize::write(&self.schema_name, p);
        p.write_field_end();
        p.write_field_begin("fields", ::fbthrift::TType::List, 5);
        ::fbthrift::Serialize::write(&self.fields, p);
        p.write_field_end();
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for self::IndexItem
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("fields", ::fbthrift::TType::List, 5),
            ::fbthrift::Field::new("index_id", ::fbthrift::TType::I32, 1),
            ::fbthrift::Field::new("index_name", ::fbthrift::TType::String, 2),
            ::fbthrift::Field::new("schema_id", ::fbthrift::TType::Struct, 3),
            ::fbthrift::Field::new("schema_name", ::fbthrift::TType::String, 4),
        ];
        let mut field_index_id = ::std::option::Option::None;
        let mut field_index_name = ::std::option::Option::None;
        let mut field_schema_id = ::std::option::Option::None;
        let mut field_schema_name = ::std::option::Option::None;
        let mut field_fields = ::std::option::Option::None;
        let _ = p.read_struct_begin(|_| ())?;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32) {
                (::fbthrift::TType::Stop, _) => break,
                (::fbthrift::TType::I32, 1) => field_index_id = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::String, 2) => field_index_name = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::Struct, 3) => field_schema_id = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::String, 4) => field_schema_name = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::List, 5) => field_fields = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (fty, _) => p.skip(fty)?,
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(Self {
            index_id: field_index_id.unwrap_or_default(),
            index_name: field_index_name.unwrap_or_default(),
            schema_id: field_schema_id.unwrap_or_default(),
            schema_name: field_schema_name.unwrap_or_default(),
            fields: field_fields.unwrap_or_default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        })
    }
}


#[allow(clippy::derivable_impls)]
impl ::std::default::Default for self::HostAddr {
    fn default() -> Self {
        Self {
            ip: ::std::default::Default::default(),
            port: ::std::default::Default::default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        }
    }
}

impl ::std::fmt::Debug for self::HostAddr {
    fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        formatter
            .debug_struct("HostAddr")
            .field("ip", &self.ip)
            .field("port", &self.port)
            .finish()
    }
}

unsafe impl ::std::marker::Send for self::HostAddr {}
unsafe impl ::std::marker::Sync for self::HostAddr {}

impl ::fbthrift::GetTType for self::HostAddr {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for self::HostAddr
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("HostAddr");
        p.write_field_begin("ip", ::fbthrift::TType::I32, 1);
        ::fbthrift::Serialize::write(&self.ip, p);
        p.write_field_end();
        p.write_field_begin("port", ::fbthrift::TType::I32, 2);
        ::fbthrift::Serialize::write(&self.port, p);
        p.write_field_end();
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for self::HostAddr
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("ip", ::fbthrift::TType::I32, 1),
            ::fbthrift::Field::new("port", ::fbthrift::TType::I32, 2),
        ];
        let mut field_ip = ::std::option::Option::None;
        let mut field_port = ::std::option::Option::None;
        let _ = p.read_struct_begin(|_| ())?;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32) {
                (::fbthrift::TType::Stop, _) => break,
                (::fbthrift::TType::I32, 1) => field_ip = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::I32, 2) => field_port = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (fty, _) => p.skip(fty)?,
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(Self {
            ip: field_ip.unwrap_or_default(),
            port: field_port.unwrap_or_default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        })
    }
}


#[allow(clippy::derivable_impls)]
impl ::std::default::Default for self::Pair {
    fn default() -> Self {
        Self {
            key: ::std::default::Default::default(),
            value: ::std::default::Default::default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        }
    }
}

impl ::std::fmt::Debug for self::Pair {
    fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        formatter
            .debug_struct("Pair")
            .field("key", &self.key)
            .field("value", &self.value)
            .finish()
    }
}

unsafe impl ::std::marker::Send for self::Pair {}
unsafe impl ::std::marker::Sync for self::Pair {}

impl ::fbthrift::GetTType for self::Pair {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for self::Pair
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("Pair");
        p.write_field_begin("key", ::fbthrift::TType::String, 1);
        ::fbthrift::Serialize::write(&self.key, p);
        p.write_field_end();
        p.write_field_begin("value", ::fbthrift::TType::String, 2);
        ::fbthrift::Serialize::write(&self.value, p);
        p.write_field_end();
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for self::Pair
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("key", ::fbthrift::TType::String, 1),
            ::fbthrift::Field::new("value", ::fbthrift::TType::String, 2),
        ];
        let mut field_key = ::std::option::Option::None;
        let mut field_value = ::std::option::Option::None;
        let _ = p.read_struct_begin(|_| ())?;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32) {
                (::fbthrift::TType::Stop, _) => break,
                (::fbthrift::TType::String, 1) => field_key = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::String, 2) => field_value = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (fty, _) => p.skip(fty)?,
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(Self {
            key: field_key.unwrap_or_default(),
            value: field_value.unwrap_or_default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        })
    }
}


#[allow(clippy::derivable_impls)]
impl ::std::default::Default for self::RoleItem {
    fn default() -> Self {
        Self {
            user: ::std::default::Default::default(),
            space_id: ::std::default::Default::default(),
            role_type: ::std::default::Default::default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        }
    }
}

impl ::std::fmt::Debug for self::RoleItem {
    fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        formatter
            .debug_struct("RoleItem")
            .field("user", &self.user)
            .field("space_id", &self.space_id)
            .field("role_type", &self.role_type)
            .finish()
    }
}

unsafe impl ::std::marker::Send for self::RoleItem {}
unsafe impl ::std::marker::Sync for self::RoleItem {}

impl ::fbthrift::GetTType for self::RoleItem {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for self::RoleItem
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("RoleItem");
        p.write_field_begin("user", ::fbthrift::TType::String, 1);
        ::fbthrift::Serialize::write(&self.user, p);
        p.write_field_end();
        p.write_field_begin("space_id", ::fbthrift::TType::I32, 2);
        ::fbthrift::Serialize::write(&self.space_id, p);
        p.write_field_end();
        p.write_field_begin("role_type", ::fbthrift::TType::I32, 3);
        ::fbthrift::Serialize::write(&self.role_type, p);
        p.write_field_end();
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for self::RoleItem
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("role_type", ::fbthrift::TType::I32, 3),
            ::fbthrift::Field::new("space_id", ::fbthrift::TType::I32, 2),
            ::fbthrift::Field::new("user", ::fbthrift::TType::String, 1),
        ];
        let mut field_user = ::std::option::Option::None;
        let mut field_space_id = ::std::option::Option::None;
        let mut field_role_type = ::std::option::Option::None;
        let _ = p.read_struct_begin(|_| ())?;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32) {
                (::fbthrift::TType::Stop, _) => break,
                (::fbthrift::TType::String, 1) => field_user = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::I32, 2) => field_space_id = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::I32, 3) => field_role_type = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (fty, _) => p.skip(fty)?,
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(Self {
            user: field_user.unwrap_or_default(),
            space_id: field_space_id.unwrap_or_default(),
            role_type: field_role_type.unwrap_or_default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        })
    }
}


mod dot_dot {
    #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct OtherFields(pub(crate) ());

    #[allow(dead_code)] // if serde isn't being used
    pub(super) fn default_for_serde_deserialize() -> OtherFields {
        OtherFields(())
    }
}