From 36cee44ca209b801e9da2bcfab4cbdf1cf7bb9f9 Mon Sep 17 00:00:00 2001 From: yito88 Date: Thu, 21 Dec 2023 23:12:49 +0100 Subject: [PATCH 01/10] add nft-transfer --- scripts/sync-protobuf.sh | 29 + src/NFT_TRANSFER_COMMIT | 1 + src/lib.rs | 8 + src/prost/ibc.applications.nft_transfer.v1.rs | 1406 +++++++++++++++++ src/prost/proto_descriptor.bin | Bin 702918 -> 715363 bytes tools/proto-compiler/src/cmd/clone.rs | 47 + tools/proto-compiler/src/cmd/compile.rs | 8 + 7 files changed, 1499 insertions(+) create mode 100644 src/NFT_TRANSFER_COMMIT create mode 100644 src/prost/ibc.applications.nft_transfer.v1.rs diff --git a/scripts/sync-protobuf.sh b/scripts/sync-protobuf.sh index a7fe7268..94ba2a03 100755 --- a/scripts/sync-protobuf.sh +++ b/scripts/sync-protobuf.sh @@ -26,14 +26,17 @@ CACHE_PATH="${XDG_CACHE_HOME:-$HOME/.cache}" COSMOS_SDK_GIT="${COSMOS_SDK_GIT:-$CACHE_PATH/cosmos/cosmos-sdk.git}" IBC_GO_GIT="${IBC_GO_GIT:-$CACHE_PATH/ibc-go.git}" COSMOS_ICS_GIT="${COSMOS_ICS_GIT:-$CACHE_PATH/cosmos/interchain-security.git}" +NFT_TRANSFER_GIT="${NFT_TRANSFER_GIT:-$CACHE_PATH/bianjieai/nft-transfer.git}" COSMOS_SDK_COMMIT="$(cat src/COSMOS_SDK_COMMIT)" IBC_GO_COMMIT="$(cat src/IBC_GO_COMMIT)" INTERCHAIN_SECURITY_COMMIT="$(cat src/INTERCHAIN_SECURITY_COMMIT)" +NFT_TRANSFER_COMMIT="$(cat src/NFT_TRANSFER_COMMIT)" echo "COSMOS_SDK_COMMIT: $COSMOS_SDK_COMMIT" echo "IBC_GO_COMMIT: $IBC_GO_COMMIT" echo "INTERCHAIN_SECURITY_COMMIT: $INTERCHAIN_SECURITY_COMMIT" +echo "NFT_TRANSFER_COMMIT: $NFT_TRANSFER_COMMIT" # Use either --ics-commit flag for commit ID, # or --ics-tag for git tag. Because we can't modify @@ -89,6 +92,15 @@ else echo "Using existing ibc-go bare git repository at $IBC_GO_GIT" fi +if [[ ! -e "$NFT_TRANSFER_GIT" ]] +then + echo "Cloning nft-transfer source code to as bare git repository to $NFT_TRANSFER_GIT" + git clone --mirror https://github.com/bianjieai/nft-transfer.git "$NFT_TRANSFER_GIT" +else + echo "Using existing nft-transfer bare git repository at $NFT_TRANSFER_GIT" +fi + + # Update the repositories using git fetch. This is so that # we keep local copies of the repositories up to sync first. pushd "$COSMOS_ICS_GIT" @@ -103,6 +115,10 @@ pushd "$IBC_GO_GIT" git fetch popd +pushd "$NFT_TRANSFER_GIT" +git fetch +popd + # Create a new temporary directory to check out the # actual source files from the bare git repositories. # This is so that we do not accidentally use an unclean @@ -154,6 +170,17 @@ cd proto buf export -v -o ../proto-include popd +NFT_TRANSFER_DIR=$(mktemp -d /tmp/nft-transfer-XXXXXXXX) + +pushd "$NFT_TRANSFER_DIR" +git clone "$NFT_TRANSFER_GIT" . +git checkout -b "$NFT_TRANSFER_COMMIT" "$NFT_TRANSFER_COMMIT" + +cd proto +buf export -v -o ../proto-include +rm ../proto-include/ibc/core/client/v1/client.proto +popd + # Remove the existing generated protobuf files # so that the newly generated code does not # contain removed files. @@ -173,6 +200,7 @@ cargo run -- compile \ --ics "$COSMOS_ICS_DIR/proto-include" \ --sdk "$COSMOS_SDK_DIR/proto-include" \ --ibc "$IBC_GO_DIR/proto-include" \ + --nft "$NFT_TRANSFER_DIR/proto-include" \ --out ../../src/prost cd ../.. @@ -192,3 +220,4 @@ rm -f src/prost/tendermint.abci.rs rm -rf "$COSMOS_ICS_DIR" rm -rf "$COSMOS_SDK_DIR" rm -rf "$IBC_GO_DIR" +rm -rf "$NFT_TRANSFER_DIR" diff --git a/src/NFT_TRANSFER_COMMIT b/src/NFT_TRANSFER_COMMIT new file mode 100644 index 00000000..9a642085 --- /dev/null +++ b/src/NFT_TRANSFER_COMMIT @@ -0,0 +1 @@ +986de3bb91434c9efc49a82544e3ba0b208e19a7 diff --git a/src/lib.rs b/src/lib.rs index 3a821998..cfd42ea5 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -37,6 +37,9 @@ pub const IBC_GO_COMMIT: &str = include_str!("IBC_GO_COMMIT"); /// The version (commit hash) of Interchain Security used when generating this library. pub const INTERCHAIN_SECURITY_COMMIT: &str = include_str!("INTERCHAIN_SECURITY_COMMIT"); +/// The version (commit hash) of nft-transfer used when generating this library. +pub const NFT_TRANSFER_COMMIT: &str = include_str!("NFT_TRANSFER_COMMIT"); + /// File descriptor set of compiled proto. #[cfg(feature = "proto-descriptor")] pub const FILE_DESCRIPTOR_SET: &[u8] = include_bytes!("prost/proto_descriptor.bin"); @@ -299,6 +302,11 @@ pub mod ibc { } } } + pub mod nft_transfer { + pub mod v1 { + include_proto!("ibc.applications.nft_transfer.v1.rs"); + } + } } pub mod core { pub mod channel { diff --git a/src/prost/ibc.applications.nft_transfer.v1.rs b/src/prost/ibc.applications.nft_transfer.v1.rs new file mode 100644 index 00000000..fe683b62 --- /dev/null +++ b/src/prost/ibc.applications.nft_transfer.v1.rs @@ -0,0 +1,1406 @@ +/// ClassTrace contains the base classID for ICS721 non-fungible tokens and the +/// source tracing information path. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ClassTrace { + /// path defines the chain of port/channel identifiers used for tracing the + /// source of the non-fungible token. + #[prost(string, tag = "1")] + pub path: ::prost::alloc::string::String, + /// base classID of the relayed non-fungible token. + #[prost(string, tag = "2")] + pub base_class_id: ::prost::alloc::string::String, +} +impl ::prost::Name for ClassTrace { + const NAME: &'static str = "ClassTrace"; + const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + } +} +/// Params defines the set of IBC nft-transfer parameters. +/// NOTE: To prevent a nft from being transferred, set the +/// TransfersEnabled parameter to false. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Params { + /// send_enabled enables or disables all cross-chain nft transfers from this + /// chain. + #[prost(bool, tag = "1")] + pub send_enabled: bool, + /// receive_enabled enables or disables all cross-chain nft transfers to this + /// chain. + #[prost(bool, tag = "2")] + pub receive_enabled: bool, +} +impl ::prost::Name for Params { + const NAME: &'static str = "Params"; + const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + } +} +/// MsgTransfer defines a msg to transfer non fungible tokens between +/// ICS721 enabled chains. See ICS Spec here: +/// +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgTransfer { + /// the port on which the packet will be sent + #[prost(string, tag = "1")] + pub source_port: ::prost::alloc::string::String, + /// the channel by which the packet will be sent + #[prost(string, tag = "2")] + pub source_channel: ::prost::alloc::string::String, + /// the class_id of tokens to be transferred + #[prost(string, tag = "3")] + pub class_id: ::prost::alloc::string::String, + /// the non fungible tokens to be transferred + #[prost(string, repeated, tag = "4")] + pub token_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// the sender address + #[prost(string, tag = "5")] + pub sender: ::prost::alloc::string::String, + /// the recipient address on the destination chain + #[prost(string, tag = "6")] + pub receiver: ::prost::alloc::string::String, + /// Timeout height relative to the current block height. + /// The timeout is disabled when set to 0. + #[prost(message, optional, tag = "7")] + pub timeout_height: ::core::option::Option< + super::super::super::core::client::v1::Height, + >, + /// Timeout timestamp in absolute nanoseconds since unix epoch. + /// The timeout is disabled when set to 0. + #[prost(uint64, tag = "8")] + pub timeout_timestamp: u64, + /// optional memo + #[prost(string, tag = "9")] + #[cfg_attr(feature = "serde", serde(default))] + pub memo: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgTransfer { + const NAME: &'static str = "MsgTransfer"; + const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + } +} +/// MsgTransferResponse defines the Msg/Transfer response type. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgTransferResponse { + /// sequence number of the transfer packet sent + #[prost(uint64, tag = "1")] + pub sequence: u64, +} +impl ::prost::Name for MsgTransferResponse { + const NAME: &'static str = "MsgTransferResponse"; + const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + } +} +/// MsgUpdateParams is the Msg/UpdateParams request type. +/// +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgUpdateParams { + /// authority is the address that controls the module (defaults to x/gov unless overwritten). + #[prost(string, tag = "1")] + pub authority: ::prost::alloc::string::String, + /// params defines the nft-transfer parameters to update. + /// + /// NOTE: All parameters must be supplied. + #[prost(message, optional, tag = "2")] + pub params: ::core::option::Option, +} +impl ::prost::Name for MsgUpdateParams { + const NAME: &'static str = "MsgUpdateParams"; + const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + } +} +/// MsgUpdateParamsResponse defines the response structure for executing a +/// MsgUpdateParams message. +/// +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgUpdateParamsResponse {} +impl ::prost::Name for MsgUpdateParamsResponse { + const NAME: &'static str = "MsgUpdateParamsResponse"; + const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + } +} +/// Generated client implementations. +#[cfg(feature = "client")] +pub mod msg_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + /// Msg defines the ibc/nft-transfer Msg service. + #[derive(Debug, Clone)] + pub struct MsgClient { + inner: tonic::client::Grpc, + } + impl MsgClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl MsgClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> MsgClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + MsgClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + /// Transfer defines a rpc handler method for MsgTransfer. + pub async fn transfer( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.applications.nft_transfer.v1.Msg/Transfer", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("ibc.applications.nft_transfer.v1.Msg", "Transfer"), + ); + self.inner.unary(req, path, codec).await + } + /// UpdateParams defines a governance operation for updating the nft-transfer module parameters. + /// The authority is defined in the keeper. + /// + pub async fn update_params( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.applications.nft_transfer.v1.Msg/UpdateParams", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "ibc.applications.nft_transfer.v1.Msg", + "UpdateParams", + ), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +#[cfg(feature = "server")] +pub mod msg_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with MsgServer. + #[async_trait] + pub trait Msg: Send + Sync + 'static { + /// Transfer defines a rpc handler method for MsgTransfer. + async fn transfer( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// UpdateParams defines a governance operation for updating the nft-transfer module parameters. + /// The authority is defined in the keeper. + /// + async fn update_params( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + /// Msg defines the ibc/nft-transfer Msg service. + #[derive(Debug)] + pub struct MsgServer { + inner: _Inner, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + struct _Inner(Arc); + impl MsgServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + let inner = _Inner(inner); + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for MsgServer + where + T: Msg, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + let inner = self.inner.clone(); + match req.uri().path() { + "/ibc.applications.nft_transfer.v1.Msg/Transfer" => { + #[allow(non_camel_case_types)] + struct TransferSvc(pub Arc); + impl tonic::server::UnaryService + for TransferSvc { + type Response = super::MsgTransferResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::transfer(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = TransferSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/ibc.applications.nft_transfer.v1.Msg/UpdateParams" => { + #[allow(non_camel_case_types)] + struct UpdateParamsSvc(pub Arc); + impl tonic::server::UnaryService + for UpdateParamsSvc { + type Response = super::MsgUpdateParamsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::update_params(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = UpdateParamsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", "12") + .header("content-type", "application/grpc") + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for MsgServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl Clone for _Inner { + fn clone(&self) -> Self { + Self(Arc::clone(&self.0)) + } + } + impl std::fmt::Debug for _Inner { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", self.0) + } + } + impl tonic::server::NamedService for MsgServer { + const NAME: &'static str = "ibc.applications.nft_transfer.v1.Msg"; + } +} +/// NonFungibleTokenPacketData defines a struct for the packet payload +/// See NonFungibleTokenPacketData spec: +/// +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct NonFungibleTokenPacketData { + /// the class_id of class to be transferred + #[prost(string, tag = "1")] + pub class_id: ::prost::alloc::string::String, + /// the class_uri of class to be transferred + #[prost(string, tag = "2")] + pub class_uri: ::prost::alloc::string::String, + /// the class_data of class to be transferred + #[prost(string, tag = "3")] + pub class_data: ::prost::alloc::string::String, + /// the non fungible tokens to be transferred + #[prost(string, repeated, tag = "4")] + pub token_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// the non fungible tokens's uri to be transferred + #[prost(string, repeated, tag = "5")] + pub token_uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// the non fungible tokens's data to be transferred + #[prost(string, repeated, tag = "6")] + pub token_data: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// the sender address + #[prost(string, tag = "7")] + pub sender: ::prost::alloc::string::String, + /// the recipient address on the destination chain + #[prost(string, tag = "8")] + pub receiver: ::prost::alloc::string::String, + /// optional memo + #[prost(string, tag = "9")] + pub memo: ::prost::alloc::string::String, +} +impl ::prost::Name for NonFungibleTokenPacketData { + const NAME: &'static str = "NonFungibleTokenPacketData"; + const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + } +} +/// QueryClassTraceRequest is the request type for the Query/ClassDenom RPC +/// method +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryClassTraceRequest { + /// hash (in hex format) or classID (full classID with ibc prefix) of the + /// denomination trace information. + #[prost(string, tag = "1")] + pub hash: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryClassTraceRequest { + const NAME: &'static str = "QueryClassTraceRequest"; + const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + } +} +/// QueryClassTraceResponse is the response type for the Query/ClassDenom RPC +/// method. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryClassTraceResponse { + /// class_trace returns the requested class trace information. + #[prost(message, optional, tag = "1")] + pub class_trace: ::core::option::Option, +} +impl ::prost::Name for QueryClassTraceResponse { + const NAME: &'static str = "QueryClassTraceResponse"; + const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + } +} +/// QueryConnectionsRequest is the request type for the Query/ClassTraces RPC +/// method +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryClassTracesRequest { + /// pagination defines an optional pagination for the request. + #[prost(message, optional, tag = "1")] + pub pagination: ::core::option::Option< + super::super::super::super::cosmos::base::query::v1beta1::PageRequest, + >, +} +impl ::prost::Name for QueryClassTracesRequest { + const NAME: &'static str = "QueryClassTracesRequest"; + const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + } +} +/// QueryClassTracesResponse is the response type for the Query/ClassTraces RPC +/// method. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryClassTracesResponse { + /// class_traces returns all class trace information. + #[prost(message, repeated, tag = "1")] + pub class_traces: ::prost::alloc::vec::Vec, + /// pagination defines the pagination in the response. + #[prost(message, optional, tag = "2")] + pub pagination: ::core::option::Option< + super::super::super::super::cosmos::base::query::v1beta1::PageResponse, + >, +} +impl ::prost::Name for QueryClassTracesResponse { + const NAME: &'static str = "QueryClassTracesResponse"; + const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + } +} +/// QueryClassHashRequest is the request type for the Query/ClassHash RPC +/// method +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryClassHashRequest { + /// The class trace (\[port_id\]/[channel_id])+/\[denom\] + #[prost(string, tag = "1")] + pub trace: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryClassHashRequest { + const NAME: &'static str = "QueryClassHashRequest"; + const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + } +} +/// QueryClassHashResponse is the response type for the Query/ClassHash RPC +/// method. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryClassHashResponse { + /// hash (in hex format) of the denomination trace information. + #[prost(string, tag = "1")] + pub hash: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryClassHashResponse { + const NAME: &'static str = "QueryClassHashResponse"; + const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + } +} +/// QueryEscrowAddressRequest is the request type for the EscrowAddress RPC +/// method. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryEscrowAddressRequest { + /// unique port identifier + #[prost(string, tag = "1")] + pub port_id: ::prost::alloc::string::String, + /// unique channel identifier + #[prost(string, tag = "2")] + pub channel_id: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryEscrowAddressRequest { + const NAME: &'static str = "QueryEscrowAddressRequest"; + const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + } +} +/// QueryEscrowAddressResponse is the response type of the EscrowAddress RPC +/// method. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryEscrowAddressResponse { + /// the escrow account address + #[prost(string, tag = "1")] + pub escrow_address: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryEscrowAddressResponse { + const NAME: &'static str = "QueryEscrowAddressResponse"; + const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + } +} +/// QueryParamsRequest is request type for the Query/Params RPC method. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryParamsRequest {} +impl ::prost::Name for QueryParamsRequest { + const NAME: &'static str = "QueryParamsRequest"; + const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + } +} +/// QueryParamsResponse is response type for the Query/Params RPC method. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryParamsResponse { + /// params holds all the parameters of this module. + #[prost(message, optional, tag = "1")] + pub params: ::core::option::Option, +} +impl ::prost::Name for QueryParamsResponse { + const NAME: &'static str = "QueryParamsResponse"; + const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + } +} +/// Generated client implementations. +#[cfg(feature = "client")] +pub mod query_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + /// Query provides defines the gRPC querier service. + #[derive(Debug, Clone)] + pub struct QueryClient { + inner: tonic::client::Grpc, + } + impl QueryClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl QueryClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> QueryClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + QueryClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + /// ClassTrace queries a class trace information. + pub async fn class_trace( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.applications.nft_transfer.v1.Query/ClassTrace", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "ibc.applications.nft_transfer.v1.Query", + "ClassTrace", + ), + ); + self.inner.unary(req, path, codec).await + } + /// ClassTraces queries all class traces. + pub async fn class_traces( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.applications.nft_transfer.v1.Query/ClassTraces", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "ibc.applications.nft_transfer.v1.Query", + "ClassTraces", + ), + ); + self.inner.unary(req, path, codec).await + } + /// ClassHash queries a class hash information. + pub async fn class_hash( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.applications.nft_transfer.v1.Query/ClassHash", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "ibc.applications.nft_transfer.v1.Query", + "ClassHash", + ), + ); + self.inner.unary(req, path, codec).await + } + /// EscrowAddress returns the escrow address for a particular port and channel + /// id. + pub async fn escrow_address( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.applications.nft_transfer.v1.Query/EscrowAddress", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "ibc.applications.nft_transfer.v1.Query", + "EscrowAddress", + ), + ); + self.inner.unary(req, path, codec).await + } + /// Params queries all parameters of the nft-transfer module. + pub async fn params( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.applications.nft_transfer.v1.Query/Params", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("ibc.applications.nft_transfer.v1.Query", "Params"), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +#[cfg(feature = "server")] +pub mod query_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with QueryServer. + #[async_trait] + pub trait Query: Send + Sync + 'static { + /// ClassTrace queries a class trace information. + async fn class_trace( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// ClassTraces queries all class traces. + async fn class_traces( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// ClassHash queries a class hash information. + async fn class_hash( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// EscrowAddress returns the escrow address for a particular port and channel + /// id. + async fn escrow_address( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Params queries all parameters of the nft-transfer module. + async fn params( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + /// Query provides defines the gRPC querier service. + #[derive(Debug)] + pub struct QueryServer { + inner: _Inner, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + struct _Inner(Arc); + impl QueryServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + let inner = _Inner(inner); + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for QueryServer + where + T: Query, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + let inner = self.inner.clone(); + match req.uri().path() { + "/ibc.applications.nft_transfer.v1.Query/ClassTrace" => { + #[allow(non_camel_case_types)] + struct ClassTraceSvc(pub Arc); + impl< + T: Query, + > tonic::server::UnaryService + for ClassTraceSvc { + type Response = super::QueryClassTraceResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::class_trace(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ClassTraceSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/ibc.applications.nft_transfer.v1.Query/ClassTraces" => { + #[allow(non_camel_case_types)] + struct ClassTracesSvc(pub Arc); + impl< + T: Query, + > tonic::server::UnaryService + for ClassTracesSvc { + type Response = super::QueryClassTracesResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::class_traces(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ClassTracesSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/ibc.applications.nft_transfer.v1.Query/ClassHash" => { + #[allow(non_camel_case_types)] + struct ClassHashSvc(pub Arc); + impl< + T: Query, + > tonic::server::UnaryService + for ClassHashSvc { + type Response = super::QueryClassHashResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::class_hash(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ClassHashSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/ibc.applications.nft_transfer.v1.Query/EscrowAddress" => { + #[allow(non_camel_case_types)] + struct EscrowAddressSvc(pub Arc); + impl< + T: Query, + > tonic::server::UnaryService + for EscrowAddressSvc { + type Response = super::QueryEscrowAddressResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::escrow_address(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = EscrowAddressSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/ibc.applications.nft_transfer.v1.Query/Params" => { + #[allow(non_camel_case_types)] + struct ParamsSvc(pub Arc); + impl tonic::server::UnaryService + for ParamsSvc { + type Response = super::QueryParamsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::params(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ParamsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", "12") + .header("content-type", "application/grpc") + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for QueryServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl Clone for _Inner { + fn clone(&self) -> Self { + Self(Arc::clone(&self.0)) + } + } + impl std::fmt::Debug for _Inner { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", self.0) + } + } + impl tonic::server::NamedService for QueryServer { + const NAME: &'static str = "ibc.applications.nft_transfer.v1.Query"; + } +} +/// GenesisState defines the ibc-nft-transfer genesis state +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GenesisState { + #[prost(string, tag = "1")] + pub port_id: ::prost::alloc::string::String, + #[prost(message, repeated, tag = "2")] + pub traces: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "3")] + pub params: ::core::option::Option, +} +impl ::prost::Name for GenesisState { + const NAME: &'static str = "GenesisState"; + const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + } +} diff --git a/src/prost/proto_descriptor.bin b/src/prost/proto_descriptor.bin index bb1bdf04b84fa0804aba2499b430697819814b7f..9d83ee5d592e7502f7178572c482d91b0767e012 100644 GIT binary patch delta 7328 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 I`K*2YAGKg~&j0`b delta 29 lcmaESMf=!it%erH7N!>F7M2#)7Pc1l7LFFqEnLTT0sy$s3se9A diff --git a/tools/proto-compiler/src/cmd/clone.rs b/tools/proto-compiler/src/cmd/clone.rs index 79dbaa03..b7c742f2 100644 --- a/tools/proto-compiler/src/cmd/clone.rs +++ b/tools/proto-compiler/src/cmd/clone.rs @@ -24,6 +24,10 @@ pub struct CloneCmd { #[argh(option, short = 's')] ics_commit: Option, + /// commit to checkout for the nft-transfer repo + #[argh(option, short = 'n')] + nft_commit: Option, + /// where to checkout the repository #[argh(option, short = 'o')] out: PathBuf, @@ -32,6 +36,7 @@ pub struct CloneCmd { pub const COSMOS_SDK_URL: &str = "https://github.com/cosmos/cosmos-sdk"; pub const IBC_GO_URL: &str = "https://github.com/cosmos/ibc-go"; pub const ICS_URL: &str = "https://github.com/cosmos/interchain-security"; +pub const NFT_TRANSFER_URL: &str = "https://github.com/bianjieai/nft-transfer"; impl CloneCmd { pub fn validate(&self) { @@ -59,6 +64,12 @@ impl CloneCmd { ics_path } + pub fn nft_subdir(&self) -> PathBuf { + let mut nft_path = self.out.clone(); + nft_path.push("nft/"); + nft_path + } + pub fn run(&self) { self.validate(); @@ -164,6 +175,42 @@ impl CloneCmd { println!("[info ] No `-i`/`--ics_commit` option passed. Skipping the ICS repo.") } } + + match &self.nft_commit { + Some(nft_commit) => { + let nft_path = self.nft_subdir(); + let nft_repo = if nft_path.exists() { + println!( + "[info ] Found nft-transfer source at '{}'", + nft_path.display() + ); + + Repository::open(&nft_path).unwrap_or_else(|e| { + println!("[error] Failed to open repository: {}", e); + process::exit(1) + }) + } else { + Repository::clone(NFT_TRANSFER_URL, &nft_path).unwrap_or_else(|e| { + println!("[error] Failed to clone the nft-transfer repository: {}", e); + process::exit(1) + }) + }; + + println!("[info ] Cloned at '{}'", nft_path.display()); + checkout_commit(&nft_repo, nft_commit).unwrap_or_else(|e| { + println!( + "[error] Failed to checkout nft-transfer commit {}: {}", + nft_commit, e + ); + process::exit(1) + }); + } + None => { + println!( + "[info ] No `-n`/`--nft-commit` option passed. Skipping the nft-transfer repo." + ) + } + } } } diff --git a/tools/proto-compiler/src/cmd/compile.rs b/tools/proto-compiler/src/cmd/compile.rs index 90164458..25814666 100644 --- a/tools/proto-compiler/src/cmd/compile.rs +++ b/tools/proto-compiler/src/cmd/compile.rs @@ -21,6 +21,10 @@ pub struct CompileCmd { /// path to the Cosmos ICS proto files ics: PathBuf, + #[argh(option, short = 'n')] + /// path to the nft-transfer proto files + nft: PathBuf, + #[argh(option, short = 'o')] /// path to output the generated Rust sources into out: PathBuf, @@ -32,6 +36,7 @@ impl CompileCmd { self.ibc.as_ref(), self.sdk.as_ref(), self.ics.as_ref(), + self.nft.as_ref(), self.out.as_ref(), ) .unwrap_or_else(|e| { @@ -56,6 +61,7 @@ impl CompileCmd { ibc_dir: &Path, sdk_dir: &Path, ics_dir: &Path, + nft_dir: &Path, out_dir: &Path, ) -> Result<(), Box> { println!( @@ -82,12 +88,14 @@ impl CompileCmd { format!("{}/interchain_security/ccv/v1", ics_dir.display()), format!("{}/interchain_security/ccv/provider", ics_dir.display()), format!("{}/interchain_security/ccv/consumer", ics_dir.display()), + format!("{}/ibc", nft_dir.display()), ]; let proto_includes_paths = [ format!("{}", sdk_dir.display()), format!("{}", ibc_dir.display()), format!("{}", ics_dir.display()), + format!("{}", nft_dir.display()), format!("{}/../../definitions/mock", root), format!("{}/../../definitions/ibc/lightclients/localhost/v1", root), format!("{}/../../definitions/stride/interchainquery/v1", root), From 4c2673b2e7210f19b4778dc0ec4455ea1a8a6de3 Mon Sep 17 00:00:00 2001 From: yito88 Date: Wed, 27 Dec 2023 11:17:17 +0100 Subject: [PATCH 02/10] add serde(default) --- src/prost/ibc.applications.nft_transfer.v1.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/prost/ibc.applications.nft_transfer.v1.rs b/src/prost/ibc.applications.nft_transfer.v1.rs index fe683b62..50673870 100644 --- a/src/prost/ibc.applications.nft_transfer.v1.rs +++ b/src/prost/ibc.applications.nft_transfer.v1.rs @@ -539,9 +539,11 @@ pub struct NonFungibleTokenPacketData { pub class_id: ::prost::alloc::string::String, /// the class_uri of class to be transferred #[prost(string, tag = "2")] + #[cfg_attr(feature = "serde", serde(default))] pub class_uri: ::prost::alloc::string::String, /// the class_data of class to be transferred #[prost(string, tag = "3")] + #[cfg_attr(feature = "serde", serde(default))] pub class_data: ::prost::alloc::string::String, /// the non fungible tokens to be transferred #[prost(string, repeated, tag = "4")] @@ -560,6 +562,7 @@ pub struct NonFungibleTokenPacketData { pub receiver: ::prost::alloc::string::String, /// optional memo #[prost(string, tag = "9")] + #[cfg_attr(feature = "serde", serde(default))] pub memo: ::prost::alloc::string::String, } impl ::prost::Name for NonFungibleTokenPacketData { From b859adabb922b4d1237f2fd940f6796dc3e30bfe Mon Sep 17 00:00:00 2001 From: yito88 Date: Wed, 27 Dec 2023 22:27:29 +0100 Subject: [PATCH 03/10] add serde(default) for token_uri and token_data --- src/prost/ibc.applications.nft_transfer.v1.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/prost/ibc.applications.nft_transfer.v1.rs b/src/prost/ibc.applications.nft_transfer.v1.rs index 50673870..791e6ef5 100644 --- a/src/prost/ibc.applications.nft_transfer.v1.rs +++ b/src/prost/ibc.applications.nft_transfer.v1.rs @@ -550,9 +550,11 @@ pub struct NonFungibleTokenPacketData { pub token_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// the non fungible tokens's uri to be transferred #[prost(string, repeated, tag = "5")] + #[cfg_attr(feature = "serde", serde(default))] pub token_uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// the non fungible tokens's data to be transferred #[prost(string, repeated, tag = "6")] + #[cfg_attr(feature = "serde", serde(default))] pub token_data: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// the sender address #[prost(string, tag = "7")] From 2971bf7ecf0b19b23085092167945ac5d5802932 Mon Sep 17 00:00:00 2001 From: yito88 Date: Wed, 3 Jan 2024 23:49:17 +0100 Subject: [PATCH 04/10] rebase for 0.40.0 --- src/prost/ibc.applications.nft_transfer.v1.rs | 24 - .../ibc.applications.nft_transfer.v1.serde.rs | 2014 +++++++++++++++++ 2 files changed, 2014 insertions(+), 24 deletions(-) create mode 100644 src/prost/ibc.applications.nft_transfer.v1.serde.rs diff --git a/src/prost/ibc.applications.nft_transfer.v1.rs b/src/prost/ibc.applications.nft_transfer.v1.rs index 791e6ef5..6da29460 100644 --- a/src/prost/ibc.applications.nft_transfer.v1.rs +++ b/src/prost/ibc.applications.nft_transfer.v1.rs @@ -1,6 +1,5 @@ /// ClassTrace contains the base classID for ICS721 non-fungible tokens and the /// source tracing information path. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ClassTrace { @@ -22,7 +21,6 @@ impl ::prost::Name for ClassTrace { /// Params defines the set of IBC nft-transfer parameters. /// NOTE: To prevent a nft from being transferred, set the /// TransfersEnabled parameter to false. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Params { @@ -45,7 +43,6 @@ impl ::prost::Name for Params { /// MsgTransfer defines a msg to transfer non fungible tokens between /// ICS721 enabled chains. See ICS Spec here: /// -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgTransfer { @@ -79,7 +76,6 @@ pub struct MsgTransfer { pub timeout_timestamp: u64, /// optional memo #[prost(string, tag = "9")] - #[cfg_attr(feature = "serde", serde(default))] pub memo: ::prost::alloc::string::String, } impl ::prost::Name for MsgTransfer { @@ -90,7 +86,6 @@ impl ::prost::Name for MsgTransfer { } } /// MsgTransferResponse defines the Msg/Transfer response type. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgTransferResponse { @@ -107,7 +102,6 @@ impl ::prost::Name for MsgTransferResponse { } /// MsgUpdateParams is the Msg/UpdateParams request type. /// -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgUpdateParams { @@ -130,7 +124,6 @@ impl ::prost::Name for MsgUpdateParams { /// MsgUpdateParamsResponse defines the response structure for executing a /// MsgUpdateParams message. /// -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgUpdateParamsResponse {} @@ -530,7 +523,6 @@ pub mod msg_server { /// NonFungibleTokenPacketData defines a struct for the packet payload /// See NonFungibleTokenPacketData spec: /// -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct NonFungibleTokenPacketData { @@ -539,22 +531,18 @@ pub struct NonFungibleTokenPacketData { pub class_id: ::prost::alloc::string::String, /// the class_uri of class to be transferred #[prost(string, tag = "2")] - #[cfg_attr(feature = "serde", serde(default))] pub class_uri: ::prost::alloc::string::String, /// the class_data of class to be transferred #[prost(string, tag = "3")] - #[cfg_attr(feature = "serde", serde(default))] pub class_data: ::prost::alloc::string::String, /// the non fungible tokens to be transferred #[prost(string, repeated, tag = "4")] pub token_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// the non fungible tokens's uri to be transferred #[prost(string, repeated, tag = "5")] - #[cfg_attr(feature = "serde", serde(default))] pub token_uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// the non fungible tokens's data to be transferred #[prost(string, repeated, tag = "6")] - #[cfg_attr(feature = "serde", serde(default))] pub token_data: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// the sender address #[prost(string, tag = "7")] @@ -564,7 +552,6 @@ pub struct NonFungibleTokenPacketData { pub receiver: ::prost::alloc::string::String, /// optional memo #[prost(string, tag = "9")] - #[cfg_attr(feature = "serde", serde(default))] pub memo: ::prost::alloc::string::String, } impl ::prost::Name for NonFungibleTokenPacketData { @@ -576,7 +563,6 @@ impl ::prost::Name for NonFungibleTokenPacketData { } /// QueryClassTraceRequest is the request type for the Query/ClassDenom RPC /// method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryClassTraceRequest { @@ -594,7 +580,6 @@ impl ::prost::Name for QueryClassTraceRequest { } /// QueryClassTraceResponse is the response type for the Query/ClassDenom RPC /// method. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryClassTraceResponse { @@ -611,7 +596,6 @@ impl ::prost::Name for QueryClassTraceResponse { } /// QueryConnectionsRequest is the request type for the Query/ClassTraces RPC /// method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryClassTracesRequest { @@ -630,7 +614,6 @@ impl ::prost::Name for QueryClassTracesRequest { } /// QueryClassTracesResponse is the response type for the Query/ClassTraces RPC /// method. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryClassTracesResponse { @@ -652,7 +635,6 @@ impl ::prost::Name for QueryClassTracesResponse { } /// QueryClassHashRequest is the request type for the Query/ClassHash RPC /// method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryClassHashRequest { @@ -669,7 +651,6 @@ impl ::prost::Name for QueryClassHashRequest { } /// QueryClassHashResponse is the response type for the Query/ClassHash RPC /// method. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryClassHashResponse { @@ -686,7 +667,6 @@ impl ::prost::Name for QueryClassHashResponse { } /// QueryEscrowAddressRequest is the request type for the EscrowAddress RPC /// method. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryEscrowAddressRequest { @@ -706,7 +686,6 @@ impl ::prost::Name for QueryEscrowAddressRequest { } /// QueryEscrowAddressResponse is the response type of the EscrowAddress RPC /// method. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryEscrowAddressResponse { @@ -722,7 +701,6 @@ impl ::prost::Name for QueryEscrowAddressResponse { } } /// QueryParamsRequest is request type for the Query/Params RPC method. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryParamsRequest {} @@ -734,7 +712,6 @@ impl ::prost::Name for QueryParamsRequest { } } /// QueryParamsResponse is response type for the Query/Params RPC method. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryParamsResponse { @@ -1391,7 +1368,6 @@ pub mod query_server { } } /// GenesisState defines the ibc-nft-transfer genesis state -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct GenesisState { diff --git a/src/prost/ibc.applications.nft_transfer.v1.serde.rs b/src/prost/ibc.applications.nft_transfer.v1.serde.rs new file mode 100644 index 00000000..b7073db8 --- /dev/null +++ b/src/prost/ibc.applications.nft_transfer.v1.serde.rs @@ -0,0 +1,2014 @@ +impl serde::Serialize for ClassTrace { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.applications.nft_transfer.v1.ClassTrace", len)?; + if true { + struct_ser.serialize_field("path", &self.path)?; + } + if true { + struct_ser.serialize_field("baseClassId", &self.base_class_id)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ClassTrace { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "path", + "base_class_id", + "baseClassId", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Path, + BaseClassId, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "path" => Ok(GeneratedField::Path), + "baseClassId" | "base_class_id" => Ok(GeneratedField::BaseClassId), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ClassTrace; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.nft_transfer.v1.ClassTrace") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut path__ = None; + let mut base_class_id__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Path => { + if path__.is_some() { + return Err(serde::de::Error::duplicate_field("path")); + } + path__ = Some(map.next_value()?); + } + GeneratedField::BaseClassId => { + if base_class_id__.is_some() { + return Err(serde::de::Error::duplicate_field("baseClassId")); + } + base_class_id__ = Some(map.next_value()?); + } + } + } + Ok(ClassTrace { + path: path__.unwrap_or_default(), + base_class_id: base_class_id__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.nft_transfer.v1.ClassTrace", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for GenesisState { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.applications.nft_transfer.v1.GenesisState", len)?; + if true { + struct_ser.serialize_field("portId", &self.port_id)?; + } + if true { + struct_ser.serialize_field("traces", &self.traces)?; + } + if let Some(v) = self.params.as_ref() { + struct_ser.serialize_field("params", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for GenesisState { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "port_id", + "portId", + "traces", + "params", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + PortId, + Traces, + Params, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "portId" | "port_id" => Ok(GeneratedField::PortId), + "traces" => Ok(GeneratedField::Traces), + "params" => Ok(GeneratedField::Params), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GenesisState; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.nft_transfer.v1.GenesisState") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut port_id__ = None; + let mut traces__ = None; + let mut params__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::PortId => { + if port_id__.is_some() { + return Err(serde::de::Error::duplicate_field("portId")); + } + port_id__ = Some(map.next_value()?); + } + GeneratedField::Traces => { + if traces__.is_some() { + return Err(serde::de::Error::duplicate_field("traces")); + } + traces__ = Some(map.next_value()?); + } + GeneratedField::Params => { + if params__.is_some() { + return Err(serde::de::Error::duplicate_field("params")); + } + params__ = map.next_value()?; + } + } + } + Ok(GenesisState { + port_id: port_id__.unwrap_or_default(), + traces: traces__.unwrap_or_default(), + params: params__, + }) + } + } + deserializer.deserialize_struct("ibc.applications.nft_transfer.v1.GenesisState", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MsgTransfer { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.applications.nft_transfer.v1.MsgTransfer", len)?; + if true { + struct_ser.serialize_field("sourcePort", &self.source_port)?; + } + if true { + struct_ser.serialize_field("sourceChannel", &self.source_channel)?; + } + if true { + struct_ser.serialize_field("classId", &self.class_id)?; + } + if true { + struct_ser.serialize_field("tokenIds", &self.token_ids)?; + } + if true { + struct_ser.serialize_field("sender", &self.sender)?; + } + if true { + struct_ser.serialize_field("receiver", &self.receiver)?; + } + if let Some(v) = self.timeout_height.as_ref() { + struct_ser.serialize_field("timeoutHeight", v)?; + } + if true { + struct_ser.serialize_field("timeoutTimestamp", ::alloc::string::ToString::to_string(&self.timeout_timestamp).as_str())?; + } + if true { + struct_ser.serialize_field("memo", &self.memo)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgTransfer { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "source_port", + "sourcePort", + "source_channel", + "sourceChannel", + "class_id", + "classId", + "token_ids", + "tokenIds", + "sender", + "receiver", + "timeout_height", + "timeoutHeight", + "timeout_timestamp", + "timeoutTimestamp", + "memo", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + SourcePort, + SourceChannel, + ClassId, + TokenIds, + Sender, + Receiver, + TimeoutHeight, + TimeoutTimestamp, + Memo, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "sourcePort" | "source_port" => Ok(GeneratedField::SourcePort), + "sourceChannel" | "source_channel" => Ok(GeneratedField::SourceChannel), + "classId" | "class_id" => Ok(GeneratedField::ClassId), + "tokenIds" | "token_ids" => Ok(GeneratedField::TokenIds), + "sender" => Ok(GeneratedField::Sender), + "receiver" => Ok(GeneratedField::Receiver), + "timeoutHeight" | "timeout_height" => Ok(GeneratedField::TimeoutHeight), + "timeoutTimestamp" | "timeout_timestamp" => Ok(GeneratedField::TimeoutTimestamp), + "memo" => Ok(GeneratedField::Memo), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgTransfer; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.nft_transfer.v1.MsgTransfer") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut source_port__ = None; + let mut source_channel__ = None; + let mut class_id__ = None; + let mut token_ids__ = None; + let mut sender__ = None; + let mut receiver__ = None; + let mut timeout_height__ = None; + let mut timeout_timestamp__ = None; + let mut memo__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::SourcePort => { + if source_port__.is_some() { + return Err(serde::de::Error::duplicate_field("sourcePort")); + } + source_port__ = Some(map.next_value()?); + } + GeneratedField::SourceChannel => { + if source_channel__.is_some() { + return Err(serde::de::Error::duplicate_field("sourceChannel")); + } + source_channel__ = Some(map.next_value()?); + } + GeneratedField::ClassId => { + if class_id__.is_some() { + return Err(serde::de::Error::duplicate_field("classId")); + } + class_id__ = Some(map.next_value()?); + } + GeneratedField::TokenIds => { + if token_ids__.is_some() { + return Err(serde::de::Error::duplicate_field("tokenIds")); + } + token_ids__ = Some(map.next_value()?); + } + GeneratedField::Sender => { + if sender__.is_some() { + return Err(serde::de::Error::duplicate_field("sender")); + } + sender__ = Some(map.next_value()?); + } + GeneratedField::Receiver => { + if receiver__.is_some() { + return Err(serde::de::Error::duplicate_field("receiver")); + } + receiver__ = Some(map.next_value()?); + } + GeneratedField::TimeoutHeight => { + if timeout_height__.is_some() { + return Err(serde::de::Error::duplicate_field("timeoutHeight")); + } + timeout_height__ = map.next_value()?; + } + GeneratedField::TimeoutTimestamp => { + if timeout_timestamp__.is_some() { + return Err(serde::de::Error::duplicate_field("timeoutTimestamp")); + } + timeout_timestamp__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Memo => { + if memo__.is_some() { + return Err(serde::de::Error::duplicate_field("memo")); + } + memo__ = Some(map.next_value()?); + } + } + } + Ok(MsgTransfer { + source_port: source_port__.unwrap_or_default(), + source_channel: source_channel__.unwrap_or_default(), + class_id: class_id__.unwrap_or_default(), + token_ids: token_ids__.unwrap_or_default(), + sender: sender__.unwrap_or_default(), + receiver: receiver__.unwrap_or_default(), + timeout_height: timeout_height__, + timeout_timestamp: timeout_timestamp__.unwrap_or_default(), + memo: memo__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.nft_transfer.v1.MsgTransfer", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MsgTransferResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.applications.nft_transfer.v1.MsgTransferResponse", len)?; + if true { + struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgTransferResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "sequence", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Sequence, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "sequence" => Ok(GeneratedField::Sequence), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgTransferResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.nft_transfer.v1.MsgTransferResponse") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut sequence__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Sequence => { + if sequence__.is_some() { + return Err(serde::de::Error::duplicate_field("sequence")); + } + sequence__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(MsgTransferResponse { + sequence: sequence__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.nft_transfer.v1.MsgTransferResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MsgUpdateParams { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.applications.nft_transfer.v1.MsgUpdateParams", len)?; + if true { + struct_ser.serialize_field("authority", &self.authority)?; + } + if let Some(v) = self.params.as_ref() { + struct_ser.serialize_field("params", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgUpdateParams { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "authority", + "params", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Authority, + Params, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "authority" => Ok(GeneratedField::Authority), + "params" => Ok(GeneratedField::Params), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgUpdateParams; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.nft_transfer.v1.MsgUpdateParams") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut authority__ = None; + let mut params__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Authority => { + if authority__.is_some() { + return Err(serde::de::Error::duplicate_field("authority")); + } + authority__ = Some(map.next_value()?); + } + GeneratedField::Params => { + if params__.is_some() { + return Err(serde::de::Error::duplicate_field("params")); + } + params__ = map.next_value()?; + } + } + } + Ok(MsgUpdateParams { + authority: authority__.unwrap_or_default(), + params: params__, + }) + } + } + deserializer.deserialize_struct("ibc.applications.nft_transfer.v1.MsgUpdateParams", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MsgUpdateParamsResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("ibc.applications.nft_transfer.v1.MsgUpdateParamsResponse", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgUpdateParamsResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgUpdateParamsResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.nft_transfer.v1.MsgUpdateParamsResponse") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map.next_key::()?.is_some() { + let _ = map.next_value::()?; + } + Ok(MsgUpdateParamsResponse { + }) + } + } + deserializer.deserialize_struct("ibc.applications.nft_transfer.v1.MsgUpdateParamsResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for NonFungibleTokenPacketData { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.applications.nft_transfer.v1.NonFungibleTokenPacketData", len)?; + if true { + struct_ser.serialize_field("classId", &self.class_id)?; + } + if true { + struct_ser.serialize_field("classUri", &self.class_uri)?; + } + if true { + struct_ser.serialize_field("classData", &self.class_data)?; + } + if true { + struct_ser.serialize_field("tokenIds", &self.token_ids)?; + } + if true { + struct_ser.serialize_field("tokenUris", &self.token_uris)?; + } + if true { + struct_ser.serialize_field("tokenData", &self.token_data)?; + } + if true { + struct_ser.serialize_field("sender", &self.sender)?; + } + if true { + struct_ser.serialize_field("receiver", &self.receiver)?; + } + if true { + struct_ser.serialize_field("memo", &self.memo)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for NonFungibleTokenPacketData { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "class_id", + "classId", + "class_uri", + "classUri", + "class_data", + "classData", + "token_ids", + "tokenIds", + "token_uris", + "tokenUris", + "token_data", + "tokenData", + "sender", + "receiver", + "memo", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ClassId, + ClassUri, + ClassData, + TokenIds, + TokenUris, + TokenData, + Sender, + Receiver, + Memo, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "classId" | "class_id" => Ok(GeneratedField::ClassId), + "classUri" | "class_uri" => Ok(GeneratedField::ClassUri), + "classData" | "class_data" => Ok(GeneratedField::ClassData), + "tokenIds" | "token_ids" => Ok(GeneratedField::TokenIds), + "tokenUris" | "token_uris" => Ok(GeneratedField::TokenUris), + "tokenData" | "token_data" => Ok(GeneratedField::TokenData), + "sender" => Ok(GeneratedField::Sender), + "receiver" => Ok(GeneratedField::Receiver), + "memo" => Ok(GeneratedField::Memo), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = NonFungibleTokenPacketData; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.nft_transfer.v1.NonFungibleTokenPacketData") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut class_id__ = None; + let mut class_uri__ = None; + let mut class_data__ = None; + let mut token_ids__ = None; + let mut token_uris__ = None; + let mut token_data__ = None; + let mut sender__ = None; + let mut receiver__ = None; + let mut memo__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::ClassId => { + if class_id__.is_some() { + return Err(serde::de::Error::duplicate_field("classId")); + } + class_id__ = Some(map.next_value()?); + } + GeneratedField::ClassUri => { + if class_uri__.is_some() { + return Err(serde::de::Error::duplicate_field("classUri")); + } + class_uri__ = Some(map.next_value()?); + } + GeneratedField::ClassData => { + if class_data__.is_some() { + return Err(serde::de::Error::duplicate_field("classData")); + } + class_data__ = Some(map.next_value()?); + } + GeneratedField::TokenIds => { + if token_ids__.is_some() { + return Err(serde::de::Error::duplicate_field("tokenIds")); + } + token_ids__ = Some(map.next_value()?); + } + GeneratedField::TokenUris => { + if token_uris__.is_some() { + return Err(serde::de::Error::duplicate_field("tokenUris")); + } + token_uris__ = Some(map.next_value()?); + } + GeneratedField::TokenData => { + if token_data__.is_some() { + return Err(serde::de::Error::duplicate_field("tokenData")); + } + token_data__ = Some(map.next_value()?); + } + GeneratedField::Sender => { + if sender__.is_some() { + return Err(serde::de::Error::duplicate_field("sender")); + } + sender__ = Some(map.next_value()?); + } + GeneratedField::Receiver => { + if receiver__.is_some() { + return Err(serde::de::Error::duplicate_field("receiver")); + } + receiver__ = Some(map.next_value()?); + } + GeneratedField::Memo => { + if memo__.is_some() { + return Err(serde::de::Error::duplicate_field("memo")); + } + memo__ = Some(map.next_value()?); + } + } + } + Ok(NonFungibleTokenPacketData { + class_id: class_id__.unwrap_or_default(), + class_uri: class_uri__.unwrap_or_default(), + class_data: class_data__.unwrap_or_default(), + token_ids: token_ids__.unwrap_or_default(), + token_uris: token_uris__.unwrap_or_default(), + token_data: token_data__.unwrap_or_default(), + sender: sender__.unwrap_or_default(), + receiver: receiver__.unwrap_or_default(), + memo: memo__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.nft_transfer.v1.NonFungibleTokenPacketData", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Params { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.applications.nft_transfer.v1.Params", len)?; + if true { + struct_ser.serialize_field("sendEnabled", &self.send_enabled)?; + } + if true { + struct_ser.serialize_field("receiveEnabled", &self.receive_enabled)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Params { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "send_enabled", + "sendEnabled", + "receive_enabled", + "receiveEnabled", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + SendEnabled, + ReceiveEnabled, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "sendEnabled" | "send_enabled" => Ok(GeneratedField::SendEnabled), + "receiveEnabled" | "receive_enabled" => Ok(GeneratedField::ReceiveEnabled), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Params; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.nft_transfer.v1.Params") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut send_enabled__ = None; + let mut receive_enabled__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::SendEnabled => { + if send_enabled__.is_some() { + return Err(serde::de::Error::duplicate_field("sendEnabled")); + } + send_enabled__ = Some(map.next_value()?); + } + GeneratedField::ReceiveEnabled => { + if receive_enabled__.is_some() { + return Err(serde::de::Error::duplicate_field("receiveEnabled")); + } + receive_enabled__ = Some(map.next_value()?); + } + } + } + Ok(Params { + send_enabled: send_enabled__.unwrap_or_default(), + receive_enabled: receive_enabled__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.nft_transfer.v1.Params", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for QueryClassHashRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.applications.nft_transfer.v1.QueryClassHashRequest", len)?; + if true { + struct_ser.serialize_field("trace", &self.trace)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryClassHashRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "trace", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Trace, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "trace" => Ok(GeneratedField::Trace), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryClassHashRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.nft_transfer.v1.QueryClassHashRequest") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut trace__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Trace => { + if trace__.is_some() { + return Err(serde::de::Error::duplicate_field("trace")); + } + trace__ = Some(map.next_value()?); + } + } + } + Ok(QueryClassHashRequest { + trace: trace__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.nft_transfer.v1.QueryClassHashRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for QueryClassHashResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.applications.nft_transfer.v1.QueryClassHashResponse", len)?; + if true { + struct_ser.serialize_field("hash", &self.hash)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryClassHashResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "hash", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Hash, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "hash" => Ok(GeneratedField::Hash), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryClassHashResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.nft_transfer.v1.QueryClassHashResponse") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut hash__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Hash => { + if hash__.is_some() { + return Err(serde::de::Error::duplicate_field("hash")); + } + hash__ = Some(map.next_value()?); + } + } + } + Ok(QueryClassHashResponse { + hash: hash__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.nft_transfer.v1.QueryClassHashResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for QueryClassTraceRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.applications.nft_transfer.v1.QueryClassTraceRequest", len)?; + if true { + struct_ser.serialize_field("hash", &self.hash)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryClassTraceRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "hash", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Hash, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "hash" => Ok(GeneratedField::Hash), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryClassTraceRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.nft_transfer.v1.QueryClassTraceRequest") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut hash__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Hash => { + if hash__.is_some() { + return Err(serde::de::Error::duplicate_field("hash")); + } + hash__ = Some(map.next_value()?); + } + } + } + Ok(QueryClassTraceRequest { + hash: hash__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.nft_transfer.v1.QueryClassTraceRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for QueryClassTraceResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.applications.nft_transfer.v1.QueryClassTraceResponse", len)?; + if let Some(v) = self.class_trace.as_ref() { + struct_ser.serialize_field("classTrace", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryClassTraceResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "class_trace", + "classTrace", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ClassTrace, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "classTrace" | "class_trace" => Ok(GeneratedField::ClassTrace), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryClassTraceResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.nft_transfer.v1.QueryClassTraceResponse") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut class_trace__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::ClassTrace => { + if class_trace__.is_some() { + return Err(serde::de::Error::duplicate_field("classTrace")); + } + class_trace__ = map.next_value()?; + } + } + } + Ok(QueryClassTraceResponse { + class_trace: class_trace__, + }) + } + } + deserializer.deserialize_struct("ibc.applications.nft_transfer.v1.QueryClassTraceResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for QueryClassTracesRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.applications.nft_transfer.v1.QueryClassTracesRequest", len)?; + if let Some(v) = self.pagination.as_ref() { + struct_ser.serialize_field("pagination", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryClassTracesRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "pagination", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Pagination, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "pagination" => Ok(GeneratedField::Pagination), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryClassTracesRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.nft_transfer.v1.QueryClassTracesRequest") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut pagination__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Pagination => { + if pagination__.is_some() { + return Err(serde::de::Error::duplicate_field("pagination")); + } + pagination__ = map.next_value()?; + } + } + } + Ok(QueryClassTracesRequest { + pagination: pagination__, + }) + } + } + deserializer.deserialize_struct("ibc.applications.nft_transfer.v1.QueryClassTracesRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for QueryClassTracesResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.applications.nft_transfer.v1.QueryClassTracesResponse", len)?; + if true { + struct_ser.serialize_field("classTraces", &self.class_traces)?; + } + if let Some(v) = self.pagination.as_ref() { + struct_ser.serialize_field("pagination", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryClassTracesResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "class_traces", + "classTraces", + "pagination", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ClassTraces, + Pagination, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "classTraces" | "class_traces" => Ok(GeneratedField::ClassTraces), + "pagination" => Ok(GeneratedField::Pagination), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryClassTracesResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.nft_transfer.v1.QueryClassTracesResponse") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut class_traces__ = None; + let mut pagination__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::ClassTraces => { + if class_traces__.is_some() { + return Err(serde::de::Error::duplicate_field("classTraces")); + } + class_traces__ = Some(map.next_value()?); + } + GeneratedField::Pagination => { + if pagination__.is_some() { + return Err(serde::de::Error::duplicate_field("pagination")); + } + pagination__ = map.next_value()?; + } + } + } + Ok(QueryClassTracesResponse { + class_traces: class_traces__.unwrap_or_default(), + pagination: pagination__, + }) + } + } + deserializer.deserialize_struct("ibc.applications.nft_transfer.v1.QueryClassTracesResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for QueryEscrowAddressRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.applications.nft_transfer.v1.QueryEscrowAddressRequest", len)?; + if true { + struct_ser.serialize_field("portId", &self.port_id)?; + } + if true { + struct_ser.serialize_field("channelId", &self.channel_id)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryEscrowAddressRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "port_id", + "portId", + "channel_id", + "channelId", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + PortId, + ChannelId, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "portId" | "port_id" => Ok(GeneratedField::PortId), + "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryEscrowAddressRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.nft_transfer.v1.QueryEscrowAddressRequest") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut port_id__ = None; + let mut channel_id__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::PortId => { + if port_id__.is_some() { + return Err(serde::de::Error::duplicate_field("portId")); + } + port_id__ = Some(map.next_value()?); + } + GeneratedField::ChannelId => { + if channel_id__.is_some() { + return Err(serde::de::Error::duplicate_field("channelId")); + } + channel_id__ = Some(map.next_value()?); + } + } + } + Ok(QueryEscrowAddressRequest { + port_id: port_id__.unwrap_or_default(), + channel_id: channel_id__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.nft_transfer.v1.QueryEscrowAddressRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for QueryEscrowAddressResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.applications.nft_transfer.v1.QueryEscrowAddressResponse", len)?; + if true { + struct_ser.serialize_field("escrowAddress", &self.escrow_address)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryEscrowAddressResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "escrow_address", + "escrowAddress", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + EscrowAddress, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "escrowAddress" | "escrow_address" => Ok(GeneratedField::EscrowAddress), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryEscrowAddressResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.nft_transfer.v1.QueryEscrowAddressResponse") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut escrow_address__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::EscrowAddress => { + if escrow_address__.is_some() { + return Err(serde::de::Error::duplicate_field("escrowAddress")); + } + escrow_address__ = Some(map.next_value()?); + } + } + } + Ok(QueryEscrowAddressResponse { + escrow_address: escrow_address__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.nft_transfer.v1.QueryEscrowAddressResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for QueryParamsRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("ibc.applications.nft_transfer.v1.QueryParamsRequest", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryParamsRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryParamsRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.nft_transfer.v1.QueryParamsRequest") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map.next_key::()?.is_some() { + let _ = map.next_value::()?; + } + Ok(QueryParamsRequest { + }) + } + } + deserializer.deserialize_struct("ibc.applications.nft_transfer.v1.QueryParamsRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for QueryParamsResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.applications.nft_transfer.v1.QueryParamsResponse", len)?; + if let Some(v) = self.params.as_ref() { + struct_ser.serialize_field("params", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryParamsResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "params", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Params, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "params" => Ok(GeneratedField::Params), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryParamsResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.nft_transfer.v1.QueryParamsResponse") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut params__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Params => { + if params__.is_some() { + return Err(serde::de::Error::duplicate_field("params")); + } + params__ = map.next_value()?; + } + } + } + Ok(QueryParamsResponse { + params: params__, + }) + } + } + deserializer.deserialize_struct("ibc.applications.nft_transfer.v1.QueryParamsResponse", FIELDS, GeneratedVisitor) + } +} From cee4e6daf9c37b1c790a33aeb6607a2a70cdae65 Mon Sep 17 00:00:00 2001 From: yito88 Date: Thu, 4 Jan 2024 00:01:46 +0100 Subject: [PATCH 05/10] fix to add serde for nft --- src/lib.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/lib.rs b/src/lib.rs index cfd42ea5..8ecd3b6e 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -305,6 +305,8 @@ pub mod ibc { pub mod nft_transfer { pub mod v1 { include_proto!("ibc.applications.nft_transfer.v1.rs"); + #[cfg(feature = "serde")] + include_proto!("ibc.applications.nft_transfer.v1.serde.rs"); } } } From f6f1a8484372d6188ab65dfc826a10bdb44a5e9f Mon Sep 17 00:00:00 2001 From: yito88 Date: Fri, 5 Jan 2024 17:47:58 +0100 Subject: [PATCH 06/10] fix doc --- src/prost/ibc.applications.nft_transfer.v1.rs | 2 +- tools/proto-compiler/src/cmd/compile.rs | 8 ++++++++ 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/src/prost/ibc.applications.nft_transfer.v1.rs b/src/prost/ibc.applications.nft_transfer.v1.rs index 6da29460..bea5ee5a 100644 --- a/src/prost/ibc.applications.nft_transfer.v1.rs +++ b/src/prost/ibc.applications.nft_transfer.v1.rs @@ -638,7 +638,7 @@ impl ::prost::Name for QueryClassTracesResponse { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryClassHashRequest { - /// The class trace (\[port_id\]/[channel_id])+/\[denom\] + /// The class trace `([port_id]/[channel_id])+/[class]` #[prost(string, tag = "1")] pub trace: ::prost::alloc::string::String, } diff --git a/tools/proto-compiler/src/cmd/compile.rs b/tools/proto-compiler/src/cmd/compile.rs index 25814666..cf8274e4 100644 --- a/tools/proto-compiler/src/cmd/compile.rs +++ b/tools/proto-compiler/src/cmd/compile.rs @@ -236,6 +236,14 @@ impl CompileCmd { "The denomination trace `([port_id]/[channel_id])+/[denom]`", )], ), + ( + "ibc.applications.nft_transfer.v1.rs", + &[( + "The class trace (\\[port_id\\]/[channel_id])+/\\[denom\\]", + "The class trace `([port_id]/[channel_id])+/[class]`", + )], + ), + ]; for (file, patches) in PATCHES { From a7e345fb912d62554fb3d58e6590bb5fa14f8a0f Mon Sep 17 00:00:00 2001 From: yito88 Date: Fri, 5 Jan 2024 21:09:31 +0100 Subject: [PATCH 07/10] rebuild with protoc 25.1 --- src/prost/google.protobuf.rs | 783 +++++++++- src/prost/google.protobuf.serde.rs | 2337 +++++++++++++++++++++++++--- src/prost/proto_descriptor.bin | Bin 722953 -> 740247 bytes 3 files changed, 2891 insertions(+), 229 deletions(-) diff --git a/src/prost/google.protobuf.rs b/src/prost/google.protobuf.rs index d58b594a..5976a8b1 100644 --- a/src/prost/google.protobuf.rs +++ b/src/prost/google.protobuf.rs @@ -22,8 +22,12 @@ /// if (any.is(Foo.class)) { /// foo = any.unpack(Foo.class); /// } +/// // or ... +/// if (any.isSameTypeAs(Foo.getDefaultInstance())) { +/// foo = any.unpack(Foo.getDefaultInstance()); +/// } /// -/// Example 3: Pack and unpack a message in Python. +/// Example 3: Pack and unpack a message in Python. /// /// foo = Foo(...) /// any = Any() @@ -33,7 +37,7 @@ /// any.Unpack(foo) /// ... /// -/// Example 4: Pack and unpack a message in Go +/// Example 4: Pack and unpack a message in Go /// /// foo := &pb.Foo{...} /// any, err := anypb.New(foo) @@ -52,9 +56,8 @@ /// in the type URL, for example "foo.bar.com/x/y.z" will yield type /// name "y.z". /// -/// /// JSON -/// +/// ==== /// The JSON representation of an `Any` value uses the regular /// representation of the deserialized, embedded message, with an /// additional field `@type` which contains the type URL. Example: @@ -112,7 +115,8 @@ pub struct Any { /// /// Note: this functionality is not currently available in the official /// protobuf release, and it is not used for type URLs beginning with - /// type.googleapis.com. + /// type.googleapis.com. As of May 2023, there are no widely used type server + /// implementations and no plans to implement one. /// /// Schemes other than `http`, `https` (or the empty scheme) might be /// used with implementation specific semantics. @@ -183,9 +187,14 @@ pub struct FileDescriptorProto { #[prost(message, optional, tag = "9")] pub source_code_info: ::core::option::Option, /// The syntax of the proto file. - /// The supported values are "proto2" and "proto3". + /// The supported values are "proto2", "proto3", and "editions". + /// + /// If `edition` is present, this value must be "editions". #[prost(string, optional, tag = "12")] pub syntax: ::core::option::Option<::prost::alloc::string::String>, + /// The edition of the proto file. + #[prost(enumeration = "Edition", optional, tag = "14")] + pub edition: ::core::option::Option, } impl ::prost::Name for FileDescriptorProto { const NAME: &'static str = "FileDescriptorProto"; @@ -276,6 +285,99 @@ pub struct ExtensionRangeOptions { /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, + /// For external users: DO NOT USE. We are in the process of open sourcing + /// extension declaration and executing internal cleanups before it can be + /// used externally. + #[prost(message, repeated, tag = "2")] + pub declaration: ::prost::alloc::vec::Vec, + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "50")] + pub features: ::core::option::Option, + /// The verification state of the range. + /// TODO: flip the default to DECLARATION once all empty ranges + /// are marked as UNVERIFIED. + #[prost( + enumeration = "extension_range_options::VerificationState", + optional, + tag = "3", + default = "Unverified" + )] + pub verification: ::core::option::Option, +} +/// Nested message and enum types in `ExtensionRangeOptions`. +pub mod extension_range_options { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct Declaration { + /// The extension number declared within the extension range. + #[prost(int32, optional, tag = "1")] + pub number: ::core::option::Option, + /// The fully-qualified name of the extension field. There must be a leading + /// dot in front of the full name. + #[prost(string, optional, tag = "2")] + pub full_name: ::core::option::Option<::prost::alloc::string::String>, + /// The fully-qualified type name of the extension field. Unlike + /// Metadata.type, Declaration.type must have a leading dot for messages + /// and enums. + #[prost(string, optional, tag = "3")] + pub r#type: ::core::option::Option<::prost::alloc::string::String>, + /// If true, indicates that the number is reserved in the extension range, + /// and any extension field with the number will fail to compile. Set this + /// when a declared extension field is deleted. + #[prost(bool, optional, tag = "5")] + pub reserved: ::core::option::Option, + /// If true, indicates that the extension must be defined as repeated. + /// Otherwise the extension must be defined as optional. + #[prost(bool, optional, tag = "6")] + pub repeated: ::core::option::Option, + } + impl ::prost::Name for Declaration { + const NAME: &'static str = "Declaration"; + const PACKAGE: &'static str = "google.protobuf"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!( + "google.protobuf.ExtensionRangeOptions.{}", Self::NAME + ) + } + } + /// The verification state of the extension range. + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum VerificationState { + /// All the extensions of the range must be declared. + Declaration = 0, + Unverified = 1, + } + impl VerificationState { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + VerificationState::Declaration => "DECLARATION", + VerificationState::Unverified => "UNVERIFIED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "DECLARATION" => Some(Self::Declaration), + "UNVERIFIED" => Some(Self::Unverified), + _ => None, + } + } + } } impl ::prost::Name for ExtensionRangeOptions { const NAME: &'static str = "ExtensionRangeOptions"; @@ -382,9 +484,10 @@ pub mod field_descriptor_proto { Bool = 8, String = 9, /// Tag-delimited aggregate. - /// Group type is deprecated and not supported in proto3. However, Proto3 + /// Group type is deprecated and not supported after google.protobuf. However, Proto3 /// implementations should still be able to parse the group wire format and - /// treat group fields as unknown fields. + /// treat group fields as unknown fields. In Editions, the group wire format + /// can be enabled via the `message_encoding` feature. Group = 10, /// Length-delimited aggregate. Message = 11, @@ -466,8 +569,11 @@ pub mod field_descriptor_proto { pub enum Label { /// 0 is reserved for errors Optional = 1, - Required = 2, Repeated = 3, + /// The required label is only allowed in google.protobuf. In proto3 and Editions + /// it's explicitly prohibited. In Editions, the `field_presence` feature + /// can be used to get this behavior. + Required = 2, } impl Label { /// String value of the enum field names used in the ProtoBuf definition. @@ -477,16 +583,16 @@ pub mod field_descriptor_proto { pub fn as_str_name(&self) -> &'static str { match self { Label::Optional => "LABEL_OPTIONAL", - Label::Required => "LABEL_REQUIRED", Label::Repeated => "LABEL_REPEATED", + Label::Required => "LABEL_REQUIRED", } } /// Creates an enum from field names used in the ProtoBuf definition. pub fn from_str_name(value: &str) -> ::core::option::Option { match value { "LABEL_OPTIONAL" => Some(Self::Optional), - "LABEL_REQUIRED" => Some(Self::Required), "LABEL_REPEATED" => Some(Self::Repeated), + "LABEL_REQUIRED" => Some(Self::Required), _ => None, } } @@ -744,6 +850,9 @@ pub struct FileOptions { /// determining the ruby package. #[prost(string, optional, tag = "45")] pub ruby_package: ::core::option::Option<::prost::alloc::string::String>, + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "50")] + pub features: ::core::option::Option, /// The parser stores options it doesn't recognize here. /// See the documentation for the "Options" section above. #[prost(message, repeated, tag = "999")] @@ -838,6 +947,10 @@ pub struct MessageOptions { /// this is a formalization for deprecating messages. #[prost(bool, optional, tag = "3", default = "false")] pub deprecated: ::core::option::Option, + /// NOTE: Do not set the option in .proto files. Always use the maps syntax + /// instead. The option should only be implicitly set by the proto compiler + /// parser. + /// /// Whether the message is an automatically generated map entry type for the /// maps field. /// @@ -855,12 +968,24 @@ pub struct MessageOptions { /// use a native map in the target language to hold the keys and values. /// The reflection APIs in such implementations still need to work as /// if the field is a repeated message field. - /// - /// NOTE: Do not set the option in .proto files. Always use the maps syntax - /// instead. The option should only be implicitly set by the proto compiler - /// parser. #[prost(bool, optional, tag = "7")] pub map_entry: ::core::option::Option, + /// Enable the legacy handling of JSON field name conflicts. This lowercases + /// and strips underscored from the fields before comparison in proto3 only. + /// The new behavior takes `json_name` into account and applies to proto2 as + /// well. + /// + /// This should only be used as a temporary measure against broken builds due + /// to the change in behavior for JSON field name conflicts. + /// + /// TODO This is legacy behavior we plan to remove once downstream + /// teams have had time to migrate. + #[deprecated] + #[prost(bool, optional, tag = "11")] + pub deprecated_legacy_json_field_conflicts: ::core::option::Option, + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "12")] + pub features: ::core::option::Option, /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, @@ -877,8 +1002,10 @@ impl ::prost::Name for MessageOptions { pub struct FieldOptions { /// The ctype option instructs the C++ code generator to use a different /// representation of the field than it normally would. See the specific - /// options below. This option is not yet implemented in the open source - /// release -- sorry, we'll try to include it in a future version! + /// options below. This option is only implemented to support use of + /// \[ctype=CORD\] and \[ctype=STRING\] (the default) on non-repeated fields of + /// type "bytes" in the open source release -- sorry, we'll try to include + /// other types in a future version! #[prost( enumeration = "field_options::CType", optional, @@ -890,7 +1017,9 @@ pub struct FieldOptions { /// a more efficient representation on the wire. Rather than repeatedly /// writing the tag and type for each element, the entire array is encoded as /// a single length-delimited blob. In proto3, only explicit setting it to - /// false will avoid using packed encoding. + /// false will avoid using packed encoding. This option is prohibited in + /// Editions, but the `repeated_field_encoding` feature can be used to control + /// the behavior. #[prost(bool, optional, tag = "2")] pub packed: ::core::option::Option, /// The jstype option determines the JavaScript type used for values of the @@ -928,7 +1057,6 @@ pub struct FieldOptions { /// call from multiple threads concurrently, while non-const methods continue /// to require exclusive access. /// - /// /// Note that implementations may choose not to check required fields within /// a lazy sub-message. That is, calling IsInitialized() on the outer message /// may return true even if the inner message has missing required fields. @@ -940,11 +1068,8 @@ pub struct FieldOptions { /// check its required fields, regardless of whether or not the message has /// been parsed. /// - /// As of 2021, lazy does no correctness checks on the byte stream during - /// parsing. This may lead to crashes if and when an invalid byte stream is - /// finally parsed upon access. - /// - /// TODO(b/211906113): Enable validation on lazy fields. + /// As of May 2022, lazy verifies the contents of the byte stream during + /// parsing. An invalid byte stream will cause the overall parsing to fail. #[prost(bool, optional, tag = "5", default = "false")] pub lazy: ::core::option::Option, /// unverified_lazy does no correctness checks on the byte stream. This should @@ -961,12 +1086,46 @@ pub struct FieldOptions { /// For Google-internal migration only. Do not use. #[prost(bool, optional, tag = "10", default = "false")] pub weak: ::core::option::Option, + /// Indicate that the field value should not be printed out when using debug + /// formats, e.g. when the field contains sensitive credentials. + #[prost(bool, optional, tag = "16", default = "false")] + pub debug_redact: ::core::option::Option, + #[prost(enumeration = "field_options::OptionRetention", optional, tag = "17")] + pub retention: ::core::option::Option, + #[prost( + enumeration = "field_options::OptionTargetType", + repeated, + packed = "false", + tag = "19" + )] + pub targets: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag = "20")] + pub edition_defaults: ::prost::alloc::vec::Vec, + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "21")] + pub features: ::core::option::Option, /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, } /// Nested message and enum types in `FieldOptions`. pub mod field_options { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct EditionDefault { + #[prost(enumeration = "super::Edition", optional, tag = "3")] + pub edition: ::core::option::Option, + /// Textproto value. + #[prost(string, optional, tag = "2")] + pub value: ::core::option::Option<::prost::alloc::string::String>, + } + impl ::prost::Name for EditionDefault { + const NAME: &'static str = "EditionDefault"; + const PACKAGE: &'static str = "google.protobuf"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("google.protobuf.FieldOptions.{}", Self::NAME) + } + } #[derive( Clone, Copy, @@ -982,6 +1141,12 @@ pub mod field_options { pub enum CType { /// Default mode. String = 0, + /// The option \[ctype=CORD\] may be applied to a non-repeated field of type + /// "bytes". It indicates that in C++, the data should be stored in a Cord + /// instead of a string. For very large strings, this may reduce memory + /// fragmentation. It may also allow better performance when parsing from a + /// Cord, or when parsing with aliasing enabled, as the parsed Cord may then + /// alias the original buffer. Cord = 1, StringPiece = 2, } @@ -1049,6 +1214,114 @@ pub mod field_options { } } } + /// If set to RETENTION_SOURCE, the option will be omitted from the binary. + /// Note: as of January 2023, support for this is in progress and does not yet + /// have an effect (b/264593489). + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum OptionRetention { + RetentionUnknown = 0, + RetentionRuntime = 1, + RetentionSource = 2, + } + impl OptionRetention { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + OptionRetention::RetentionUnknown => "RETENTION_UNKNOWN", + OptionRetention::RetentionRuntime => "RETENTION_RUNTIME", + OptionRetention::RetentionSource => "RETENTION_SOURCE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "RETENTION_UNKNOWN" => Some(Self::RetentionUnknown), + "RETENTION_RUNTIME" => Some(Self::RetentionRuntime), + "RETENTION_SOURCE" => Some(Self::RetentionSource), + _ => None, + } + } + } + /// This indicates the types of entities that the field may apply to when used + /// as an option. If it is unset, then the field may be freely used as an + /// option on any kind of entity. Note: as of January 2023, support for this is + /// in progress and does not yet have an effect (b/264593489). + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum OptionTargetType { + TargetTypeUnknown = 0, + TargetTypeFile = 1, + TargetTypeExtensionRange = 2, + TargetTypeMessage = 3, + TargetTypeField = 4, + TargetTypeOneof = 5, + TargetTypeEnum = 6, + TargetTypeEnumEntry = 7, + TargetTypeService = 8, + TargetTypeMethod = 9, + } + impl OptionTargetType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + OptionTargetType::TargetTypeUnknown => "TARGET_TYPE_UNKNOWN", + OptionTargetType::TargetTypeFile => "TARGET_TYPE_FILE", + OptionTargetType::TargetTypeExtensionRange => { + "TARGET_TYPE_EXTENSION_RANGE" + } + OptionTargetType::TargetTypeMessage => "TARGET_TYPE_MESSAGE", + OptionTargetType::TargetTypeField => "TARGET_TYPE_FIELD", + OptionTargetType::TargetTypeOneof => "TARGET_TYPE_ONEOF", + OptionTargetType::TargetTypeEnum => "TARGET_TYPE_ENUM", + OptionTargetType::TargetTypeEnumEntry => "TARGET_TYPE_ENUM_ENTRY", + OptionTargetType::TargetTypeService => "TARGET_TYPE_SERVICE", + OptionTargetType::TargetTypeMethod => "TARGET_TYPE_METHOD", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "TARGET_TYPE_UNKNOWN" => Some(Self::TargetTypeUnknown), + "TARGET_TYPE_FILE" => Some(Self::TargetTypeFile), + "TARGET_TYPE_EXTENSION_RANGE" => Some(Self::TargetTypeExtensionRange), + "TARGET_TYPE_MESSAGE" => Some(Self::TargetTypeMessage), + "TARGET_TYPE_FIELD" => Some(Self::TargetTypeField), + "TARGET_TYPE_ONEOF" => Some(Self::TargetTypeOneof), + "TARGET_TYPE_ENUM" => Some(Self::TargetTypeEnum), + "TARGET_TYPE_ENUM_ENTRY" => Some(Self::TargetTypeEnumEntry), + "TARGET_TYPE_SERVICE" => Some(Self::TargetTypeService), + "TARGET_TYPE_METHOD" => Some(Self::TargetTypeMethod), + _ => None, + } + } + } } impl ::prost::Name for FieldOptions { const NAME: &'static str = "FieldOptions"; @@ -1060,6 +1333,9 @@ impl ::prost::Name for FieldOptions { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct OneofOptions { + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "1")] + pub features: ::core::option::Option, /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, @@ -1084,6 +1360,18 @@ pub struct EnumOptions { /// is a formalization for deprecating enums. #[prost(bool, optional, tag = "3", default = "false")] pub deprecated: ::core::option::Option, + /// Enable the legacy handling of JSON field name conflicts. This lowercases + /// and strips underscored from the fields before comparison in proto3 only. + /// The new behavior takes `json_name` into account and applies to proto2 as + /// well. + /// TODO Remove this legacy behavior once downstream teams have + /// had time to migrate. + #[deprecated] + #[prost(bool, optional, tag = "6")] + pub deprecated_legacy_json_field_conflicts: ::core::option::Option, + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "7")] + pub features: ::core::option::Option, /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, @@ -1104,6 +1392,14 @@ pub struct EnumValueOptions { /// this is a formalization for deprecating enum values. #[prost(bool, optional, tag = "1", default = "false")] pub deprecated: ::core::option::Option, + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "2")] + pub features: ::core::option::Option, + /// Indicate that fields annotated with this enum value should not be printed + /// out when using debug formats, e.g. when the field contains sensitive + /// credentials. + #[prost(bool, optional, tag = "3", default = "false")] + pub debug_redact: ::core::option::Option, /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, @@ -1118,6 +1414,9 @@ impl ::prost::Name for EnumValueOptions { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ServiceOptions { + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "34")] + pub features: ::core::option::Option, /// Is this service deprecated? /// Depending on the target platform, this can emit Deprecated annotations /// for the service, or it will be completely ignored; in the very least, @@ -1151,6 +1450,9 @@ pub struct MethodOptions { default = "IdempotencyUnknown" )] pub idempotency_level: ::core::option::Option, + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "35")] + pub features: ::core::option::Option, /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, @@ -1265,6 +1567,324 @@ impl ::prost::Name for UninterpretedOption { ::prost::alloc::format!("google.protobuf.{}", Self::NAME) } } +/// TODO Enums in C++ gencode (and potentially other languages) are +/// not well scoped. This means that each of the feature enums below can clash +/// with each other. The short names we've chosen maximize call-site +/// readability, but leave us very open to this scenario. A future feature will +/// be designed and implemented to handle this, hopefully before we ever hit a +/// conflict here. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FeatureSet { + #[prost(enumeration = "feature_set::FieldPresence", optional, tag = "1")] + pub field_presence: ::core::option::Option, + #[prost(enumeration = "feature_set::EnumType", optional, tag = "2")] + pub enum_type: ::core::option::Option, + #[prost(enumeration = "feature_set::RepeatedFieldEncoding", optional, tag = "3")] + pub repeated_field_encoding: ::core::option::Option, + #[prost(enumeration = "feature_set::Utf8Validation", optional, tag = "4")] + pub utf8_validation: ::core::option::Option, + #[prost(enumeration = "feature_set::MessageEncoding", optional, tag = "5")] + pub message_encoding: ::core::option::Option, + #[prost(enumeration = "feature_set::JsonFormat", optional, tag = "6")] + pub json_format: ::core::option::Option, +} +/// Nested message and enum types in `FeatureSet`. +pub mod feature_set { + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum FieldPresence { + Unknown = 0, + Explicit = 1, + Implicit = 2, + LegacyRequired = 3, + } + impl FieldPresence { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + FieldPresence::Unknown => "FIELD_PRESENCE_UNKNOWN", + FieldPresence::Explicit => "EXPLICIT", + FieldPresence::Implicit => "IMPLICIT", + FieldPresence::LegacyRequired => "LEGACY_REQUIRED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "FIELD_PRESENCE_UNKNOWN" => Some(Self::Unknown), + "EXPLICIT" => Some(Self::Explicit), + "IMPLICIT" => Some(Self::Implicit), + "LEGACY_REQUIRED" => Some(Self::LegacyRequired), + _ => None, + } + } + } + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum EnumType { + Unknown = 0, + Open = 1, + Closed = 2, + } + impl EnumType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + EnumType::Unknown => "ENUM_TYPE_UNKNOWN", + EnumType::Open => "OPEN", + EnumType::Closed => "CLOSED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ENUM_TYPE_UNKNOWN" => Some(Self::Unknown), + "OPEN" => Some(Self::Open), + "CLOSED" => Some(Self::Closed), + _ => None, + } + } + } + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum RepeatedFieldEncoding { + Unknown = 0, + Packed = 1, + Expanded = 2, + } + impl RepeatedFieldEncoding { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + RepeatedFieldEncoding::Unknown => "REPEATED_FIELD_ENCODING_UNKNOWN", + RepeatedFieldEncoding::Packed => "PACKED", + RepeatedFieldEncoding::Expanded => "EXPANDED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "REPEATED_FIELD_ENCODING_UNKNOWN" => Some(Self::Unknown), + "PACKED" => Some(Self::Packed), + "EXPANDED" => Some(Self::Expanded), + _ => None, + } + } + } + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum Utf8Validation { + Unknown = 0, + None = 1, + Verify = 2, + } + impl Utf8Validation { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Utf8Validation::Unknown => "UTF8_VALIDATION_UNKNOWN", + Utf8Validation::None => "NONE", + Utf8Validation::Verify => "VERIFY", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UTF8_VALIDATION_UNKNOWN" => Some(Self::Unknown), + "NONE" => Some(Self::None), + "VERIFY" => Some(Self::Verify), + _ => None, + } + } + } + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum MessageEncoding { + Unknown = 0, + LengthPrefixed = 1, + Delimited = 2, + } + impl MessageEncoding { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + MessageEncoding::Unknown => "MESSAGE_ENCODING_UNKNOWN", + MessageEncoding::LengthPrefixed => "LENGTH_PREFIXED", + MessageEncoding::Delimited => "DELIMITED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "MESSAGE_ENCODING_UNKNOWN" => Some(Self::Unknown), + "LENGTH_PREFIXED" => Some(Self::LengthPrefixed), + "DELIMITED" => Some(Self::Delimited), + _ => None, + } + } + } + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum JsonFormat { + Unknown = 0, + Allow = 1, + LegacyBestEffort = 2, + } + impl JsonFormat { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + JsonFormat::Unknown => "JSON_FORMAT_UNKNOWN", + JsonFormat::Allow => "ALLOW", + JsonFormat::LegacyBestEffort => "LEGACY_BEST_EFFORT", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "JSON_FORMAT_UNKNOWN" => Some(Self::Unknown), + "ALLOW" => Some(Self::Allow), + "LEGACY_BEST_EFFORT" => Some(Self::LegacyBestEffort), + _ => None, + } + } + } +} +impl ::prost::Name for FeatureSet { + const NAME: &'static str = "FeatureSet"; + const PACKAGE: &'static str = "google.protobuf"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + } +} +/// A compiled specification for the defaults of a set of features. These +/// messages are generated from FeatureSet extensions and can be used to seed +/// feature resolution. The resolution with this object becomes a simple search +/// for the closest matching edition, followed by proto merges. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FeatureSetDefaults { + #[prost(message, repeated, tag = "1")] + pub defaults: ::prost::alloc::vec::Vec< + feature_set_defaults::FeatureSetEditionDefault, + >, + /// The minimum supported edition (inclusive) when this was constructed. + /// Editions before this will not have defaults. + #[prost(enumeration = "Edition", optional, tag = "4")] + pub minimum_edition: ::core::option::Option, + /// The maximum known edition (inclusive) when this was constructed. Editions + /// after this will not have reliable defaults. + #[prost(enumeration = "Edition", optional, tag = "5")] + pub maximum_edition: ::core::option::Option, +} +/// Nested message and enum types in `FeatureSetDefaults`. +pub mod feature_set_defaults { + /// A map from every known edition with a unique set of defaults to its + /// defaults. Not all editions may be contained here. For a given edition, + /// the defaults at the closest matching edition ordered at or before it should + /// be used. This field must be in strict ascending order by edition. + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct FeatureSetEditionDefault { + #[prost(enumeration = "super::Edition", optional, tag = "3")] + pub edition: ::core::option::Option, + #[prost(message, optional, tag = "2")] + pub features: ::core::option::Option, + } + impl ::prost::Name for FeatureSetEditionDefault { + const NAME: &'static str = "FeatureSetEditionDefault"; + const PACKAGE: &'static str = "google.protobuf"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("google.protobuf.FeatureSetDefaults.{}", Self::NAME) + } + } +} +impl ::prost::Name for FeatureSetDefaults { + const NAME: &'static str = "FeatureSetDefaults"; + const PACKAGE: &'static str = "google.protobuf"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + } +} /// Encapsulates information about the original source file from which a /// FileDescriptorProto was generated. #[allow(clippy::derive_partial_eq_without_eq)] @@ -1452,10 +2072,59 @@ pub mod generated_code_info { #[prost(int32, optional, tag = "3")] pub begin: ::core::option::Option, /// Identifies the ending offset in bytes in the generated code that - /// relates to the identified offset. The end offset should be one past + /// relates to the identified object. The end offset should be one past /// the last relevant byte (so the length of the text = end - begin). #[prost(int32, optional, tag = "4")] pub end: ::core::option::Option, + #[prost(enumeration = "annotation::Semantic", optional, tag = "5")] + pub semantic: ::core::option::Option, + } + /// Nested message and enum types in `Annotation`. + pub mod annotation { + /// Represents the identified object's effect on the element in the original + /// .proto file. + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum Semantic { + /// There is no effect or the effect is indescribable. + None = 0, + /// The element is set or otherwise mutated. + Set = 1, + /// An alias to the element is returned. + Alias = 2, + } + impl Semantic { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Semantic::None => "NONE", + Semantic::Set => "SET", + Semantic::Alias => "ALIAS", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "NONE" => Some(Self::None), + "SET" => Some(Self::Set), + "ALIAS" => Some(Self::Alias), + _ => None, + } + } + } } impl ::prost::Name for Annotation { const NAME: &'static str = "Annotation"; @@ -1472,6 +2141,64 @@ impl ::prost::Name for GeneratedCodeInfo { ::prost::alloc::format!("google.protobuf.{}", Self::NAME) } } +/// The full set of known editions. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum Edition { + /// A placeholder for an unknown edition value. + Unknown = 0, + /// Legacy syntax "editions". These pre-date editions, but behave much like + /// distinct editions. These can't be used to specify the edition of proto + /// files, but feature definitions must supply proto2/proto3 defaults for + /// backwards compatibility. + Proto2 = 998, + Proto3 = 999, + /// Editions that have been released. The specific values are arbitrary and + /// should not be depended on, but they will always be time-ordered for easy + /// comparison. + Edition2023 = 1000, + /// Placeholder editions for testing feature resolution. These should not be + /// used or relyed on outside of tests. + Edition1TestOnly = 1, + Edition2TestOnly = 2, + Edition99997TestOnly = 99997, + Edition99998TestOnly = 99998, + Edition99999TestOnly = 99999, +} +impl Edition { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Edition::Unknown => "EDITION_UNKNOWN", + Edition::Proto2 => "EDITION_PROTO2", + Edition::Proto3 => "EDITION_PROTO3", + Edition::Edition2023 => "EDITION_2023", + Edition::Edition1TestOnly => "EDITION_1_TEST_ONLY", + Edition::Edition2TestOnly => "EDITION_2_TEST_ONLY", + Edition::Edition99997TestOnly => "EDITION_99997_TEST_ONLY", + Edition::Edition99998TestOnly => "EDITION_99998_TEST_ONLY", + Edition::Edition99999TestOnly => "EDITION_99999_TEST_ONLY", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "EDITION_UNKNOWN" => Some(Self::Unknown), + "EDITION_PROTO2" => Some(Self::Proto2), + "EDITION_PROTO3" => Some(Self::Proto3), + "EDITION_2023" => Some(Self::Edition2023), + "EDITION_1_TEST_ONLY" => Some(Self::Edition1TestOnly), + "EDITION_2_TEST_ONLY" => Some(Self::Edition2TestOnly), + "EDITION_99997_TEST_ONLY" => Some(Self::Edition99997TestOnly), + "EDITION_99998_TEST_ONLY" => Some(Self::Edition99998TestOnly), + "EDITION_99999_TEST_ONLY" => Some(Self::Edition99999TestOnly), + _ => None, + } + } +} /// A Timestamp represents a point in time independent of any time zone or local /// calendar, encoded as a count of seconds and fractions of seconds at /// nanosecond resolution. The count is relative to an epoch at UTC midnight on @@ -1522,7 +2249,6 @@ impl ::prost::Name for GeneratedCodeInfo { /// Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) /// .setNanos((int) ((millis % 1000) * 1000000)).build(); /// -/// /// Example 5: Compute Timestamp from Java `Instant.now()`. /// /// Instant now = Instant.now(); @@ -1531,7 +2257,6 @@ impl ::prost::Name for GeneratedCodeInfo { /// Timestamp.newBuilder().setSeconds(now.getEpochSecond()) /// .setNanos(now.getNano()).build(); /// -/// /// Example 6: Compute Timestamp from current time in Python. /// /// timestamp = Timestamp() @@ -1561,10 +2286,9 @@ impl ::prost::Name for GeneratedCodeInfo { /// [`strftime`]() with /// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use /// the Joda Time's [`ISODateTimeFormat.dateTime()`]( -/// +/// ) /// ) to obtain a formatter capable of generating timestamps in this format. /// -/// #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Timestamp { @@ -1646,7 +2370,6 @@ impl ::prost::Name for Timestamp { /// be expressed in JSON format as "3.000000001s", and 3 seconds and 1 /// microsecond should be expressed in JSON format as "3.000001s". /// -/// #[derive(Eq)] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] diff --git a/src/prost/google.protobuf.serde.rs b/src/prost/google.protobuf.serde.rs index 34f08208..78b50e08 100644 --- a/src/prost/google.protobuf.serde.rs +++ b/src/prost/google.protobuf.serde.rs @@ -712,6 +712,100 @@ impl<'de> serde::Deserialize<'de> for Duration { deserializer.deserialize_struct("google.protobuf.Duration", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for Edition { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "EDITION_UNKNOWN", + Self::Proto2 => "EDITION_PROTO2", + Self::Proto3 => "EDITION_PROTO3", + Self::Edition2023 => "EDITION_2023", + Self::Edition1TestOnly => "EDITION_1_TEST_ONLY", + Self::Edition2TestOnly => "EDITION_2_TEST_ONLY", + Self::Edition99997TestOnly => "EDITION_99997_TEST_ONLY", + Self::Edition99998TestOnly => "EDITION_99998_TEST_ONLY", + Self::Edition99999TestOnly => "EDITION_99999_TEST_ONLY", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for Edition { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "EDITION_UNKNOWN", + "EDITION_PROTO2", + "EDITION_PROTO3", + "EDITION_2023", + "EDITION_1_TEST_ONLY", + "EDITION_2_TEST_ONLY", + "EDITION_99997_TEST_ONLY", + "EDITION_99998_TEST_ONLY", + "EDITION_99999_TEST_ONLY", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Edition; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(Edition::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(Edition::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "EDITION_UNKNOWN" => Ok(Edition::Unknown), + "EDITION_PROTO2" => Ok(Edition::Proto2), + "EDITION_PROTO3" => Ok(Edition::Proto3), + "EDITION_2023" => Ok(Edition::Edition2023), + "EDITION_1_TEST_ONLY" => Ok(Edition::Edition1TestOnly), + "EDITION_2_TEST_ONLY" => Ok(Edition::Edition2TestOnly), + "EDITION_99997_TEST_ONLY" => Ok(Edition::Edition99997TestOnly), + "EDITION_99998_TEST_ONLY" => Ok(Edition::Edition99998TestOnly), + "EDITION_99999_TEST_ONLY" => Ok(Edition::Edition99999TestOnly), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} impl serde::Serialize for EnumDescriptorProto { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result @@ -1002,6 +1096,12 @@ impl serde::Serialize for EnumOptions { if true { len += 1; } + if true { + len += 1; + } + if true { + len += 1; + } let mut struct_ser = serializer.serialize_struct("google.protobuf.EnumOptions", len)?; if let Some(v) = self.allow_alias.as_ref() { struct_ser.serialize_field("allowAlias", v)?; @@ -1009,6 +1109,12 @@ impl serde::Serialize for EnumOptions { if let Some(v) = self.deprecated.as_ref() { struct_ser.serialize_field("deprecated", v)?; } + if let Some(v) = self.deprecated_legacy_json_field_conflicts.as_ref() { + struct_ser.serialize_field("deprecatedLegacyJsonFieldConflicts", v)?; + } + if let Some(v) = self.features.as_ref() { + struct_ser.serialize_field("features", v)?; + } if true { struct_ser.serialize_field("uninterpretedOption", &self.uninterpreted_option)?; } @@ -1025,6 +1131,9 @@ impl<'de> serde::Deserialize<'de> for EnumOptions { "allow_alias", "allowAlias", "deprecated", + "deprecated_legacy_json_field_conflicts", + "deprecatedLegacyJsonFieldConflicts", + "features", "uninterpreted_option", "uninterpretedOption", ]; @@ -1033,6 +1142,8 @@ impl<'de> serde::Deserialize<'de> for EnumOptions { enum GeneratedField { AllowAlias, Deprecated, + DeprecatedLegacyJsonFieldConflicts, + Features, UninterpretedOption, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -1057,6 +1168,8 @@ impl<'de> serde::Deserialize<'de> for EnumOptions { match value { "allowAlias" | "allow_alias" => Ok(GeneratedField::AllowAlias), "deprecated" => Ok(GeneratedField::Deprecated), + "deprecatedLegacyJsonFieldConflicts" | "deprecated_legacy_json_field_conflicts" => Ok(GeneratedField::DeprecatedLegacyJsonFieldConflicts), + "features" => Ok(GeneratedField::Features), "uninterpretedOption" | "uninterpreted_option" => Ok(GeneratedField::UninterpretedOption), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } @@ -1079,6 +1192,8 @@ impl<'de> serde::Deserialize<'de> for EnumOptions { { let mut allow_alias__ = None; let mut deprecated__ = None; + let mut deprecated_legacy_json_field_conflicts__ = None; + let mut features__ = None; let mut uninterpreted_option__ = None; while let Some(k) = map.next_key()? { match k { @@ -1094,6 +1209,18 @@ impl<'de> serde::Deserialize<'de> for EnumOptions { } deprecated__ = map.next_value()?; } + GeneratedField::DeprecatedLegacyJsonFieldConflicts => { + if deprecated_legacy_json_field_conflicts__.is_some() { + return Err(serde::de::Error::duplicate_field("deprecatedLegacyJsonFieldConflicts")); + } + deprecated_legacy_json_field_conflicts__ = map.next_value()?; + } + GeneratedField::Features => { + if features__.is_some() { + return Err(serde::de::Error::duplicate_field("features")); + } + features__ = map.next_value()?; + } GeneratedField::UninterpretedOption => { if uninterpreted_option__.is_some() { return Err(serde::de::Error::duplicate_field("uninterpretedOption")); @@ -1105,6 +1232,8 @@ impl<'de> serde::Deserialize<'de> for EnumOptions { Ok(EnumOptions { allow_alias: allow_alias__, deprecated: deprecated__, + deprecated_legacy_json_field_conflicts: deprecated_legacy_json_field_conflicts__, + features: features__, uninterpreted_option: uninterpreted_option__.unwrap_or_default(), }) } @@ -1253,10 +1382,22 @@ impl serde::Serialize for EnumValueOptions { if true { len += 1; } + if true { + len += 1; + } + if true { + len += 1; + } let mut struct_ser = serializer.serialize_struct("google.protobuf.EnumValueOptions", len)?; if let Some(v) = self.deprecated.as_ref() { struct_ser.serialize_field("deprecated", v)?; } + if let Some(v) = self.features.as_ref() { + struct_ser.serialize_field("features", v)?; + } + if let Some(v) = self.debug_redact.as_ref() { + struct_ser.serialize_field("debugRedact", v)?; + } if true { struct_ser.serialize_field("uninterpretedOption", &self.uninterpreted_option)?; } @@ -1271,6 +1412,9 @@ impl<'de> serde::Deserialize<'de> for EnumValueOptions { { const FIELDS: &[&str] = &[ "deprecated", + "features", + "debug_redact", + "debugRedact", "uninterpreted_option", "uninterpretedOption", ]; @@ -1278,6 +1422,8 @@ impl<'de> serde::Deserialize<'de> for EnumValueOptions { #[allow(clippy::enum_variant_names)] enum GeneratedField { Deprecated, + Features, + DebugRedact, UninterpretedOption, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -1301,6 +1447,8 @@ impl<'de> serde::Deserialize<'de> for EnumValueOptions { { match value { "deprecated" => Ok(GeneratedField::Deprecated), + "features" => Ok(GeneratedField::Features), + "debugRedact" | "debug_redact" => Ok(GeneratedField::DebugRedact), "uninterpretedOption" | "uninterpreted_option" => Ok(GeneratedField::UninterpretedOption), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } @@ -1322,6 +1470,8 @@ impl<'de> serde::Deserialize<'de> for EnumValueOptions { V: serde::de::MapAccess<'de>, { let mut deprecated__ = None; + let mut features__ = None; + let mut debug_redact__ = None; let mut uninterpreted_option__ = None; while let Some(k) = map.next_key()? { match k { @@ -1331,6 +1481,18 @@ impl<'de> serde::Deserialize<'de> for EnumValueOptions { } deprecated__ = map.next_value()?; } + GeneratedField::Features => { + if features__.is_some() { + return Err(serde::de::Error::duplicate_field("features")); + } + features__ = map.next_value()?; + } + GeneratedField::DebugRedact => { + if debug_redact__.is_some() { + return Err(serde::de::Error::duplicate_field("debugRedact")); + } + debug_redact__ = map.next_value()?; + } GeneratedField::UninterpretedOption => { if uninterpreted_option__.is_some() { return Err(serde::de::Error::duplicate_field("uninterpretedOption")); @@ -1341,6 +1503,8 @@ impl<'de> serde::Deserialize<'de> for EnumValueOptions { } Ok(EnumValueOptions { deprecated: deprecated__, + features: features__, + debug_redact: debug_redact__, uninterpreted_option: uninterpreted_option__.unwrap_or_default(), }) } @@ -1359,10 +1523,30 @@ impl serde::Serialize for ExtensionRangeOptions { if true { len += 1; } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } let mut struct_ser = serializer.serialize_struct("google.protobuf.ExtensionRangeOptions", len)?; if true { struct_ser.serialize_field("uninterpretedOption", &self.uninterpreted_option)?; } + if true { + struct_ser.serialize_field("declaration", &self.declaration)?; + } + if let Some(v) = self.features.as_ref() { + struct_ser.serialize_field("features", v)?; + } + if let Some(v) = self.verification.as_ref() { + let v = extension_range_options::VerificationState::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("verification", &v)?; + } struct_ser.end() } } @@ -1375,11 +1559,17 @@ impl<'de> serde::Deserialize<'de> for ExtensionRangeOptions { const FIELDS: &[&str] = &[ "uninterpreted_option", "uninterpretedOption", + "declaration", + "features", + "verification", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { UninterpretedOption, + Declaration, + Features, + Verification, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -1402,6 +1592,9 @@ impl<'de> serde::Deserialize<'de> for ExtensionRangeOptions { { match value { "uninterpretedOption" | "uninterpreted_option" => Ok(GeneratedField::UninterpretedOption), + "declaration" => Ok(GeneratedField::Declaration), + "features" => Ok(GeneratedField::Features), + "verification" => Ok(GeneratedField::Verification), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -1422,6 +1615,9 @@ impl<'de> serde::Deserialize<'de> for ExtensionRangeOptions { V: serde::de::MapAccess<'de>, { let mut uninterpreted_option__ = None; + let mut declaration__ = None; + let mut features__ = None; + let mut verification__ = None; while let Some(k) = map.next_key()? { match k { GeneratedField::UninterpretedOption => { @@ -1430,17 +1626,38 @@ impl<'de> serde::Deserialize<'de> for ExtensionRangeOptions { } uninterpreted_option__ = Some(map.next_value()?); } + GeneratedField::Declaration => { + if declaration__.is_some() { + return Err(serde::de::Error::duplicate_field("declaration")); + } + declaration__ = Some(map.next_value()?); + } + GeneratedField::Features => { + if features__.is_some() { + return Err(serde::de::Error::duplicate_field("features")); + } + features__ = map.next_value()?; + } + GeneratedField::Verification => { + if verification__.is_some() { + return Err(serde::de::Error::duplicate_field("verification")); + } + verification__ = map.next_value::<::core::option::Option>()?.map(|x| x as i32); + } } } Ok(ExtensionRangeOptions { uninterpreted_option: uninterpreted_option__.unwrap_or_default(), + declaration: declaration__.unwrap_or_default(), + features: features__, + verification: verification__, }) } } deserializer.deserialize_struct("google.protobuf.ExtensionRangeOptions", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for FieldDescriptorProto { +impl serde::Serialize for extension_range_options::Declaration { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -1463,103 +1680,47 @@ impl serde::Serialize for FieldDescriptorProto { if true { len += 1; } - if true { - len += 1; - } - if true { - len += 1; - } - if true { - len += 1; - } - if true { - len += 1; - } - if true { - len += 1; - } - if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("google.protobuf.FieldDescriptorProto", len)?; - if let Some(v) = self.name.as_ref() { - struct_ser.serialize_field("name", v)?; - } + let mut struct_ser = serializer.serialize_struct("google.protobuf.ExtensionRangeOptions.Declaration", len)?; if let Some(v) = self.number.as_ref() { struct_ser.serialize_field("number", v)?; } - if let Some(v) = self.label.as_ref() { - let v = field_descriptor_proto::Label::from_i32(*v) - .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; - struct_ser.serialize_field("label", &v)?; + if let Some(v) = self.full_name.as_ref() { + struct_ser.serialize_field("fullName", v)?; } if let Some(v) = self.r#type.as_ref() { - let v = field_descriptor_proto::Type::from_i32(*v) - .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; - struct_ser.serialize_field("type", &v)?; - } - if let Some(v) = self.type_name.as_ref() { - struct_ser.serialize_field("typeName", v)?; - } - if let Some(v) = self.extendee.as_ref() { - struct_ser.serialize_field("extendee", v)?; - } - if let Some(v) = self.default_value.as_ref() { - struct_ser.serialize_field("defaultValue", v)?; - } - if let Some(v) = self.oneof_index.as_ref() { - struct_ser.serialize_field("oneofIndex", v)?; + struct_ser.serialize_field("type", v)?; } - if let Some(v) = self.json_name.as_ref() { - struct_ser.serialize_field("jsonName", v)?; - } - if let Some(v) = self.options.as_ref() { - struct_ser.serialize_field("options", v)?; + if let Some(v) = self.reserved.as_ref() { + struct_ser.serialize_field("reserved", v)?; } - if let Some(v) = self.proto3_optional.as_ref() { - struct_ser.serialize_field("proto3Optional", v)?; + if let Some(v) = self.repeated.as_ref() { + struct_ser.serialize_field("repeated", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for FieldDescriptorProto { +impl<'de> serde::Deserialize<'de> for extension_range_options::Declaration { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "name", "number", - "label", + "full_name", + "fullName", "type", - "type_name", - "typeName", - "extendee", - "default_value", - "defaultValue", - "oneof_index", - "oneofIndex", - "json_name", - "jsonName", - "options", - "proto3_optional", - "proto3Optional", + "reserved", + "repeated", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Name, Number, - Label, + FullName, Type, - TypeName, - Extendee, - DefaultValue, - OneofIndex, - JsonName, - Options, - Proto3Optional, + Reserved, + Repeated, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -1581,17 +1742,11 @@ impl<'de> serde::Deserialize<'de> for FieldDescriptorProto { E: serde::de::Error, { match value { - "name" => Ok(GeneratedField::Name), "number" => Ok(GeneratedField::Number), - "label" => Ok(GeneratedField::Label), + "fullName" | "full_name" => Ok(GeneratedField::FullName), "type" => Ok(GeneratedField::Type), - "typeName" | "type_name" => Ok(GeneratedField::TypeName), - "extendee" => Ok(GeneratedField::Extendee), - "defaultValue" | "default_value" => Ok(GeneratedField::DefaultValue), - "oneofIndex" | "oneof_index" => Ok(GeneratedField::OneofIndex), - "jsonName" | "json_name" => Ok(GeneratedField::JsonName), - "options" => Ok(GeneratedField::Options), - "proto3Optional" | "proto3_optional" => Ok(GeneratedField::Proto3Optional), + "reserved" => Ok(GeneratedField::Reserved), + "repeated" => Ok(GeneratedField::Repeated), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -1601,35 +1756,23 @@ impl<'de> serde::Deserialize<'de> for FieldDescriptorProto { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = FieldDescriptorProto; + type Value = extension_range_options::Declaration; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct google.protobuf.FieldDescriptorProto") + formatter.write_str("struct google.protobuf.ExtensionRangeOptions.Declaration") } - fn visit_map(self, mut map: V) -> core::result::Result + fn visit_map(self, mut map: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut name__ = None; let mut number__ = None; - let mut label__ = None; + let mut full_name__ = None; let mut r#type__ = None; - let mut type_name__ = None; - let mut extendee__ = None; - let mut default_value__ = None; - let mut oneof_index__ = None; - let mut json_name__ = None; - let mut options__ = None; - let mut proto3_optional__ = None; + let mut reserved__ = None; + let mut repeated__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); - } - name__ = map.next_value()?; - } GeneratedField::Number => { if number__.is_some() { return Err(serde::de::Error::duplicate_field("number")); @@ -1638,71 +1781,1274 @@ impl<'de> serde::Deserialize<'de> for FieldDescriptorProto { map.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) ; } - GeneratedField::Label => { - if label__.is_some() { - return Err(serde::de::Error::duplicate_field("label")); + GeneratedField::FullName => { + if full_name__.is_some() { + return Err(serde::de::Error::duplicate_field("fullName")); } - label__ = map.next_value::<::core::option::Option>()?.map(|x| x as i32); + full_name__ = map.next_value()?; } GeneratedField::Type => { if r#type__.is_some() { return Err(serde::de::Error::duplicate_field("type")); } - r#type__ = map.next_value::<::core::option::Option>()?.map(|x| x as i32); - } - GeneratedField::TypeName => { - if type_name__.is_some() { - return Err(serde::de::Error::duplicate_field("typeName")); - } - type_name__ = map.next_value()?; - } - GeneratedField::Extendee => { - if extendee__.is_some() { - return Err(serde::de::Error::duplicate_field("extendee")); - } - extendee__ = map.next_value()?; - } - GeneratedField::DefaultValue => { - if default_value__.is_some() { - return Err(serde::de::Error::duplicate_field("defaultValue")); - } - default_value__ = map.next_value()?; - } - GeneratedField::OneofIndex => { - if oneof_index__.is_some() { - return Err(serde::de::Error::duplicate_field("oneofIndex")); - } - oneof_index__ = - map.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) - ; - } - GeneratedField::JsonName => { - if json_name__.is_some() { - return Err(serde::de::Error::duplicate_field("jsonName")); - } - json_name__ = map.next_value()?; + r#type__ = map.next_value()?; } - GeneratedField::Options => { - if options__.is_some() { - return Err(serde::de::Error::duplicate_field("options")); + GeneratedField::Reserved => { + if reserved__.is_some() { + return Err(serde::de::Error::duplicate_field("reserved")); } - options__ = map.next_value()?; + reserved__ = map.next_value()?; } - GeneratedField::Proto3Optional => { - if proto3_optional__.is_some() { - return Err(serde::de::Error::duplicate_field("proto3Optional")); + GeneratedField::Repeated => { + if repeated__.is_some() { + return Err(serde::de::Error::duplicate_field("repeated")); } - proto3_optional__ = map.next_value()?; + repeated__ = map.next_value()?; } } } - Ok(FieldDescriptorProto { - name: name__, + Ok(extension_range_options::Declaration { number: number__, - label: label__, + full_name: full_name__, r#type: r#type__, - type_name: type_name__, - extendee: extendee__, + reserved: reserved__, + repeated: repeated__, + }) + } + } + deserializer.deserialize_struct("google.protobuf.ExtensionRangeOptions.Declaration", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for extension_range_options::VerificationState { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Declaration => "DECLARATION", + Self::Unverified => "UNVERIFIED", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for extension_range_options::VerificationState { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "DECLARATION", + "UNVERIFIED", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = extension_range_options::VerificationState; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(extension_range_options::VerificationState::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(extension_range_options::VerificationState::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "DECLARATION" => Ok(extension_range_options::VerificationState::Declaration), + "UNVERIFIED" => Ok(extension_range_options::VerificationState::Unverified), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for FeatureSet { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("google.protobuf.FeatureSet", len)?; + if let Some(v) = self.field_presence.as_ref() { + let v = feature_set::FieldPresence::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("fieldPresence", &v)?; + } + if let Some(v) = self.enum_type.as_ref() { + let v = feature_set::EnumType::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("enumType", &v)?; + } + if let Some(v) = self.repeated_field_encoding.as_ref() { + let v = feature_set::RepeatedFieldEncoding::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("repeatedFieldEncoding", &v)?; + } + if let Some(v) = self.utf8_validation.as_ref() { + let v = feature_set::Utf8Validation::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("utf8Validation", &v)?; + } + if let Some(v) = self.message_encoding.as_ref() { + let v = feature_set::MessageEncoding::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("messageEncoding", &v)?; + } + if let Some(v) = self.json_format.as_ref() { + let v = feature_set::JsonFormat::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("jsonFormat", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for FeatureSet { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "field_presence", + "fieldPresence", + "enum_type", + "enumType", + "repeated_field_encoding", + "repeatedFieldEncoding", + "utf8_validation", + "utf8Validation", + "message_encoding", + "messageEncoding", + "json_format", + "jsonFormat", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + FieldPresence, + EnumType, + RepeatedFieldEncoding, + Utf8Validation, + MessageEncoding, + JsonFormat, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "fieldPresence" | "field_presence" => Ok(GeneratedField::FieldPresence), + "enumType" | "enum_type" => Ok(GeneratedField::EnumType), + "repeatedFieldEncoding" | "repeated_field_encoding" => Ok(GeneratedField::RepeatedFieldEncoding), + "utf8Validation" | "utf8_validation" => Ok(GeneratedField::Utf8Validation), + "messageEncoding" | "message_encoding" => Ok(GeneratedField::MessageEncoding), + "jsonFormat" | "json_format" => Ok(GeneratedField::JsonFormat), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = FeatureSet; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct google.protobuf.FeatureSet") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut field_presence__ = None; + let mut enum_type__ = None; + let mut repeated_field_encoding__ = None; + let mut utf8_validation__ = None; + let mut message_encoding__ = None; + let mut json_format__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::FieldPresence => { + if field_presence__.is_some() { + return Err(serde::de::Error::duplicate_field("fieldPresence")); + } + field_presence__ = map.next_value::<::core::option::Option>()?.map(|x| x as i32); + } + GeneratedField::EnumType => { + if enum_type__.is_some() { + return Err(serde::de::Error::duplicate_field("enumType")); + } + enum_type__ = map.next_value::<::core::option::Option>()?.map(|x| x as i32); + } + GeneratedField::RepeatedFieldEncoding => { + if repeated_field_encoding__.is_some() { + return Err(serde::de::Error::duplicate_field("repeatedFieldEncoding")); + } + repeated_field_encoding__ = map.next_value::<::core::option::Option>()?.map(|x| x as i32); + } + GeneratedField::Utf8Validation => { + if utf8_validation__.is_some() { + return Err(serde::de::Error::duplicate_field("utf8Validation")); + } + utf8_validation__ = map.next_value::<::core::option::Option>()?.map(|x| x as i32); + } + GeneratedField::MessageEncoding => { + if message_encoding__.is_some() { + return Err(serde::de::Error::duplicate_field("messageEncoding")); + } + message_encoding__ = map.next_value::<::core::option::Option>()?.map(|x| x as i32); + } + GeneratedField::JsonFormat => { + if json_format__.is_some() { + return Err(serde::de::Error::duplicate_field("jsonFormat")); + } + json_format__ = map.next_value::<::core::option::Option>()?.map(|x| x as i32); + } + } + } + Ok(FeatureSet { + field_presence: field_presence__, + enum_type: enum_type__, + repeated_field_encoding: repeated_field_encoding__, + utf8_validation: utf8_validation__, + message_encoding: message_encoding__, + json_format: json_format__, + }) + } + } + deserializer.deserialize_struct("google.protobuf.FeatureSet", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for feature_set::EnumType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "ENUM_TYPE_UNKNOWN", + Self::Open => "OPEN", + Self::Closed => "CLOSED", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for feature_set::EnumType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ENUM_TYPE_UNKNOWN", + "OPEN", + "CLOSED", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = feature_set::EnumType; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(feature_set::EnumType::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(feature_set::EnumType::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "ENUM_TYPE_UNKNOWN" => Ok(feature_set::EnumType::Unknown), + "OPEN" => Ok(feature_set::EnumType::Open), + "CLOSED" => Ok(feature_set::EnumType::Closed), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for feature_set::FieldPresence { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "FIELD_PRESENCE_UNKNOWN", + Self::Explicit => "EXPLICIT", + Self::Implicit => "IMPLICIT", + Self::LegacyRequired => "LEGACY_REQUIRED", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for feature_set::FieldPresence { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "FIELD_PRESENCE_UNKNOWN", + "EXPLICIT", + "IMPLICIT", + "LEGACY_REQUIRED", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = feature_set::FieldPresence; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(feature_set::FieldPresence::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(feature_set::FieldPresence::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "FIELD_PRESENCE_UNKNOWN" => Ok(feature_set::FieldPresence::Unknown), + "EXPLICIT" => Ok(feature_set::FieldPresence::Explicit), + "IMPLICIT" => Ok(feature_set::FieldPresence::Implicit), + "LEGACY_REQUIRED" => Ok(feature_set::FieldPresence::LegacyRequired), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for feature_set::JsonFormat { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "JSON_FORMAT_UNKNOWN", + Self::Allow => "ALLOW", + Self::LegacyBestEffort => "LEGACY_BEST_EFFORT", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for feature_set::JsonFormat { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "JSON_FORMAT_UNKNOWN", + "ALLOW", + "LEGACY_BEST_EFFORT", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = feature_set::JsonFormat; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(feature_set::JsonFormat::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(feature_set::JsonFormat::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "JSON_FORMAT_UNKNOWN" => Ok(feature_set::JsonFormat::Unknown), + "ALLOW" => Ok(feature_set::JsonFormat::Allow), + "LEGACY_BEST_EFFORT" => Ok(feature_set::JsonFormat::LegacyBestEffort), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for feature_set::MessageEncoding { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "MESSAGE_ENCODING_UNKNOWN", + Self::LengthPrefixed => "LENGTH_PREFIXED", + Self::Delimited => "DELIMITED", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for feature_set::MessageEncoding { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "MESSAGE_ENCODING_UNKNOWN", + "LENGTH_PREFIXED", + "DELIMITED", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = feature_set::MessageEncoding; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(feature_set::MessageEncoding::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(feature_set::MessageEncoding::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "MESSAGE_ENCODING_UNKNOWN" => Ok(feature_set::MessageEncoding::Unknown), + "LENGTH_PREFIXED" => Ok(feature_set::MessageEncoding::LengthPrefixed), + "DELIMITED" => Ok(feature_set::MessageEncoding::Delimited), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for feature_set::RepeatedFieldEncoding { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "REPEATED_FIELD_ENCODING_UNKNOWN", + Self::Packed => "PACKED", + Self::Expanded => "EXPANDED", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for feature_set::RepeatedFieldEncoding { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "REPEATED_FIELD_ENCODING_UNKNOWN", + "PACKED", + "EXPANDED", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = feature_set::RepeatedFieldEncoding; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(feature_set::RepeatedFieldEncoding::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(feature_set::RepeatedFieldEncoding::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "REPEATED_FIELD_ENCODING_UNKNOWN" => Ok(feature_set::RepeatedFieldEncoding::Unknown), + "PACKED" => Ok(feature_set::RepeatedFieldEncoding::Packed), + "EXPANDED" => Ok(feature_set::RepeatedFieldEncoding::Expanded), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for feature_set::Utf8Validation { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "UTF8_VALIDATION_UNKNOWN", + Self::None => "NONE", + Self::Verify => "VERIFY", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for feature_set::Utf8Validation { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "UTF8_VALIDATION_UNKNOWN", + "NONE", + "VERIFY", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = feature_set::Utf8Validation; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(feature_set::Utf8Validation::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(feature_set::Utf8Validation::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "UTF8_VALIDATION_UNKNOWN" => Ok(feature_set::Utf8Validation::Unknown), + "NONE" => Ok(feature_set::Utf8Validation::None), + "VERIFY" => Ok(feature_set::Utf8Validation::Verify), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for FeatureSetDefaults { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("google.protobuf.FeatureSetDefaults", len)?; + if true { + struct_ser.serialize_field("defaults", &self.defaults)?; + } + if let Some(v) = self.minimum_edition.as_ref() { + let v = Edition::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("minimumEdition", &v)?; + } + if let Some(v) = self.maximum_edition.as_ref() { + let v = Edition::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("maximumEdition", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for FeatureSetDefaults { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "defaults", + "minimum_edition", + "minimumEdition", + "maximum_edition", + "maximumEdition", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Defaults, + MinimumEdition, + MaximumEdition, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "defaults" => Ok(GeneratedField::Defaults), + "minimumEdition" | "minimum_edition" => Ok(GeneratedField::MinimumEdition), + "maximumEdition" | "maximum_edition" => Ok(GeneratedField::MaximumEdition), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = FeatureSetDefaults; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct google.protobuf.FeatureSetDefaults") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut defaults__ = None; + let mut minimum_edition__ = None; + let mut maximum_edition__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Defaults => { + if defaults__.is_some() { + return Err(serde::de::Error::duplicate_field("defaults")); + } + defaults__ = Some(map.next_value()?); + } + GeneratedField::MinimumEdition => { + if minimum_edition__.is_some() { + return Err(serde::de::Error::duplicate_field("minimumEdition")); + } + minimum_edition__ = map.next_value::<::core::option::Option>()?.map(|x| x as i32); + } + GeneratedField::MaximumEdition => { + if maximum_edition__.is_some() { + return Err(serde::de::Error::duplicate_field("maximumEdition")); + } + maximum_edition__ = map.next_value::<::core::option::Option>()?.map(|x| x as i32); + } + } + } + Ok(FeatureSetDefaults { + defaults: defaults__.unwrap_or_default(), + minimum_edition: minimum_edition__, + maximum_edition: maximum_edition__, + }) + } + } + deserializer.deserialize_struct("google.protobuf.FeatureSetDefaults", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for feature_set_defaults::FeatureSetEditionDefault { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault", len)?; + if let Some(v) = self.edition.as_ref() { + let v = Edition::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("edition", &v)?; + } + if let Some(v) = self.features.as_ref() { + struct_ser.serialize_field("features", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for feature_set_defaults::FeatureSetEditionDefault { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "edition", + "features", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Edition, + Features, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "edition" => Ok(GeneratedField::Edition), + "features" => Ok(GeneratedField::Features), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = feature_set_defaults::FeatureSetEditionDefault; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut edition__ = None; + let mut features__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Edition => { + if edition__.is_some() { + return Err(serde::de::Error::duplicate_field("edition")); + } + edition__ = map.next_value::<::core::option::Option>()?.map(|x| x as i32); + } + GeneratedField::Features => { + if features__.is_some() { + return Err(serde::de::Error::duplicate_field("features")); + } + features__ = map.next_value()?; + } + } + } + Ok(feature_set_defaults::FeatureSetEditionDefault { + edition: edition__, + features: features__, + }) + } + } + deserializer.deserialize_struct("google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for FieldDescriptorProto { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("google.protobuf.FieldDescriptorProto", len)?; + if let Some(v) = self.name.as_ref() { + struct_ser.serialize_field("name", v)?; + } + if let Some(v) = self.number.as_ref() { + struct_ser.serialize_field("number", v)?; + } + if let Some(v) = self.label.as_ref() { + let v = field_descriptor_proto::Label::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("label", &v)?; + } + if let Some(v) = self.r#type.as_ref() { + let v = field_descriptor_proto::Type::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("type", &v)?; + } + if let Some(v) = self.type_name.as_ref() { + struct_ser.serialize_field("typeName", v)?; + } + if let Some(v) = self.extendee.as_ref() { + struct_ser.serialize_field("extendee", v)?; + } + if let Some(v) = self.default_value.as_ref() { + struct_ser.serialize_field("defaultValue", v)?; + } + if let Some(v) = self.oneof_index.as_ref() { + struct_ser.serialize_field("oneofIndex", v)?; + } + if let Some(v) = self.json_name.as_ref() { + struct_ser.serialize_field("jsonName", v)?; + } + if let Some(v) = self.options.as_ref() { + struct_ser.serialize_field("options", v)?; + } + if let Some(v) = self.proto3_optional.as_ref() { + struct_ser.serialize_field("proto3Optional", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for FieldDescriptorProto { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "name", + "number", + "label", + "type", + "type_name", + "typeName", + "extendee", + "default_value", + "defaultValue", + "oneof_index", + "oneofIndex", + "json_name", + "jsonName", + "options", + "proto3_optional", + "proto3Optional", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Name, + Number, + Label, + Type, + TypeName, + Extendee, + DefaultValue, + OneofIndex, + JsonName, + Options, + Proto3Optional, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "name" => Ok(GeneratedField::Name), + "number" => Ok(GeneratedField::Number), + "label" => Ok(GeneratedField::Label), + "type" => Ok(GeneratedField::Type), + "typeName" | "type_name" => Ok(GeneratedField::TypeName), + "extendee" => Ok(GeneratedField::Extendee), + "defaultValue" | "default_value" => Ok(GeneratedField::DefaultValue), + "oneofIndex" | "oneof_index" => Ok(GeneratedField::OneofIndex), + "jsonName" | "json_name" => Ok(GeneratedField::JsonName), + "options" => Ok(GeneratedField::Options), + "proto3Optional" | "proto3_optional" => Ok(GeneratedField::Proto3Optional), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = FieldDescriptorProto; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct google.protobuf.FieldDescriptorProto") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut name__ = None; + let mut number__ = None; + let mut label__ = None; + let mut r#type__ = None; + let mut type_name__ = None; + let mut extendee__ = None; + let mut default_value__ = None; + let mut oneof_index__ = None; + let mut json_name__ = None; + let mut options__ = None; + let mut proto3_optional__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = map.next_value()?; + } + GeneratedField::Number => { + if number__.is_some() { + return Err(serde::de::Error::duplicate_field("number")); + } + number__ = + map.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::Label => { + if label__.is_some() { + return Err(serde::de::Error::duplicate_field("label")); + } + label__ = map.next_value::<::core::option::Option>()?.map(|x| x as i32); + } + GeneratedField::Type => { + if r#type__.is_some() { + return Err(serde::de::Error::duplicate_field("type")); + } + r#type__ = map.next_value::<::core::option::Option>()?.map(|x| x as i32); + } + GeneratedField::TypeName => { + if type_name__.is_some() { + return Err(serde::de::Error::duplicate_field("typeName")); + } + type_name__ = map.next_value()?; + } + GeneratedField::Extendee => { + if extendee__.is_some() { + return Err(serde::de::Error::duplicate_field("extendee")); + } + extendee__ = map.next_value()?; + } + GeneratedField::DefaultValue => { + if default_value__.is_some() { + return Err(serde::de::Error::duplicate_field("defaultValue")); + } + default_value__ = map.next_value()?; + } + GeneratedField::OneofIndex => { + if oneof_index__.is_some() { + return Err(serde::de::Error::duplicate_field("oneofIndex")); + } + oneof_index__ = + map.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::JsonName => { + if json_name__.is_some() { + return Err(serde::de::Error::duplicate_field("jsonName")); + } + json_name__ = map.next_value()?; + } + GeneratedField::Options => { + if options__.is_some() { + return Err(serde::de::Error::duplicate_field("options")); + } + options__ = map.next_value()?; + } + GeneratedField::Proto3Optional => { + if proto3_optional__.is_some() { + return Err(serde::de::Error::duplicate_field("proto3Optional")); + } + proto3_optional__ = map.next_value()?; + } + } + } + Ok(FieldDescriptorProto { + name: name__, + number: number__, + label: label__, + r#type: r#type__, + type_name: type_name__, + extendee: extendee__, default_value: default_value__, oneof_index: oneof_index__, json_name: json_name__, @@ -1722,8 +3068,8 @@ impl serde::Serialize for field_descriptor_proto::Label { { let variant = match self { Self::Optional => "LABEL_OPTIONAL", - Self::Required => "LABEL_REQUIRED", Self::Repeated => "LABEL_REPEATED", + Self::Required => "LABEL_REQUIRED", }; serializer.serialize_str(variant) } @@ -1736,8 +3082,8 @@ impl<'de> serde::Deserialize<'de> for field_descriptor_proto::Label { { const FIELDS: &[&str] = &[ "LABEL_OPTIONAL", - "LABEL_REQUIRED", "LABEL_REPEATED", + "LABEL_REQUIRED", ]; struct GeneratedVisitor; @@ -1781,8 +3127,8 @@ impl<'de> serde::Deserialize<'de> for field_descriptor_proto::Label { { match value { "LABEL_OPTIONAL" => Ok(field_descriptor_proto::Label::Optional), - "LABEL_REQUIRED" => Ok(field_descriptor_proto::Label::Required), "LABEL_REPEATED" => Ok(field_descriptor_proto::Label::Repeated), + "LABEL_REQUIRED" => Ok(field_descriptor_proto::Label::Required), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -1943,6 +3289,21 @@ impl serde::Serialize for FieldOptions { if true { len += 1; } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } let mut struct_ser = serializer.serialize_struct("google.protobuf.FieldOptions", len)?; if let Some(v) = self.ctype.as_ref() { let v = field_options::CType::from_i32(*v) @@ -1969,6 +3330,27 @@ impl serde::Serialize for FieldOptions { if let Some(v) = self.weak.as_ref() { struct_ser.serialize_field("weak", v)?; } + if let Some(v) = self.debug_redact.as_ref() { + struct_ser.serialize_field("debugRedact", v)?; + } + if let Some(v) = self.retention.as_ref() { + let v = field_options::OptionRetention::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("retention", &v)?; + } + if true { + let v = self.targets.iter().cloned().map(|v| { + field_options::OptionTargetType::from_i32(v) + .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", v))) + }).collect::, _>>()?; + struct_ser.serialize_field("targets", &v)?; + } + if true { + struct_ser.serialize_field("editionDefaults", &self.edition_defaults)?; + } + if let Some(v) = self.features.as_ref() { + struct_ser.serialize_field("features", v)?; + } if true { struct_ser.serialize_field("uninterpretedOption", &self.uninterpreted_option)?; } @@ -1990,6 +3372,13 @@ impl<'de> serde::Deserialize<'de> for FieldOptions { "unverifiedLazy", "deprecated", "weak", + "debug_redact", + "debugRedact", + "retention", + "targets", + "edition_defaults", + "editionDefaults", + "features", "uninterpreted_option", "uninterpretedOption", ]; @@ -2003,6 +3392,11 @@ impl<'de> serde::Deserialize<'de> for FieldOptions { UnverifiedLazy, Deprecated, Weak, + DebugRedact, + Retention, + Targets, + EditionDefaults, + Features, UninterpretedOption, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -2032,6 +3426,11 @@ impl<'de> serde::Deserialize<'de> for FieldOptions { "unverifiedLazy" | "unverified_lazy" => Ok(GeneratedField::UnverifiedLazy), "deprecated" => Ok(GeneratedField::Deprecated), "weak" => Ok(GeneratedField::Weak), + "debugRedact" | "debug_redact" => Ok(GeneratedField::DebugRedact), + "retention" => Ok(GeneratedField::Retention), + "targets" => Ok(GeneratedField::Targets), + "editionDefaults" | "edition_defaults" => Ok(GeneratedField::EditionDefaults), + "features" => Ok(GeneratedField::Features), "uninterpretedOption" | "uninterpreted_option" => Ok(GeneratedField::UninterpretedOption), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } @@ -2059,6 +3458,11 @@ impl<'de> serde::Deserialize<'de> for FieldOptions { let mut unverified_lazy__ = None; let mut deprecated__ = None; let mut weak__ = None; + let mut debug_redact__ = None; + let mut retention__ = None; + let mut targets__ = None; + let mut edition_defaults__ = None; + let mut features__ = None; let mut uninterpreted_option__ = None; while let Some(k) = map.next_key()? { match k { @@ -2098,65 +3502,286 @@ impl<'de> serde::Deserialize<'de> for FieldOptions { } deprecated__ = map.next_value()?; } - GeneratedField::Weak => { - if weak__.is_some() { - return Err(serde::de::Error::duplicate_field("weak")); + GeneratedField::Weak => { + if weak__.is_some() { + return Err(serde::de::Error::duplicate_field("weak")); + } + weak__ = map.next_value()?; + } + GeneratedField::DebugRedact => { + if debug_redact__.is_some() { + return Err(serde::de::Error::duplicate_field("debugRedact")); + } + debug_redact__ = map.next_value()?; + } + GeneratedField::Retention => { + if retention__.is_some() { + return Err(serde::de::Error::duplicate_field("retention")); + } + retention__ = map.next_value::<::core::option::Option>()?.map(|x| x as i32); + } + GeneratedField::Targets => { + if targets__.is_some() { + return Err(serde::de::Error::duplicate_field("targets")); + } + targets__ = Some(map.next_value::<::alloc::vec::Vec>()?.into_iter().map(|x| x as i32).collect()); + } + GeneratedField::EditionDefaults => { + if edition_defaults__.is_some() { + return Err(serde::de::Error::duplicate_field("editionDefaults")); + } + edition_defaults__ = Some(map.next_value()?); + } + GeneratedField::Features => { + if features__.is_some() { + return Err(serde::de::Error::duplicate_field("features")); + } + features__ = map.next_value()?; + } + GeneratedField::UninterpretedOption => { + if uninterpreted_option__.is_some() { + return Err(serde::de::Error::duplicate_field("uninterpretedOption")); + } + uninterpreted_option__ = Some(map.next_value()?); + } + } + } + Ok(FieldOptions { + ctype: ctype__, + packed: packed__, + jstype: jstype__, + lazy: lazy__, + unverified_lazy: unverified_lazy__, + deprecated: deprecated__, + weak: weak__, + debug_redact: debug_redact__, + retention: retention__, + targets: targets__.unwrap_or_default(), + edition_defaults: edition_defaults__.unwrap_or_default(), + features: features__, + uninterpreted_option: uninterpreted_option__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("google.protobuf.FieldOptions", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for field_options::CType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::String => "STRING", + Self::Cord => "CORD", + Self::StringPiece => "STRING_PIECE", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for field_options::CType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "STRING", + "CORD", + "STRING_PIECE", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = field_options::CType; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(field_options::CType::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(field_options::CType::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "STRING" => Ok(field_options::CType::String), + "CORD" => Ok(field_options::CType::Cord), + "STRING_PIECE" => Ok(field_options::CType::StringPiece), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for field_options::EditionDefault { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("google.protobuf.FieldOptions.EditionDefault", len)?; + if let Some(v) = self.edition.as_ref() { + let v = Edition::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("edition", &v)?; + } + if let Some(v) = self.value.as_ref() { + struct_ser.serialize_field("value", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for field_options::EditionDefault { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "edition", + "value", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Edition, + Value, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "edition" => Ok(GeneratedField::Edition), + "value" => Ok(GeneratedField::Value), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = field_options::EditionDefault; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct google.protobuf.FieldOptions.EditionDefault") + } + + fn visit_map(self, mut map: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut edition__ = None; + let mut value__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Edition => { + if edition__.is_some() { + return Err(serde::de::Error::duplicate_field("edition")); } - weak__ = map.next_value()?; + edition__ = map.next_value::<::core::option::Option>()?.map(|x| x as i32); } - GeneratedField::UninterpretedOption => { - if uninterpreted_option__.is_some() { - return Err(serde::de::Error::duplicate_field("uninterpretedOption")); + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); } - uninterpreted_option__ = Some(map.next_value()?); + value__ = map.next_value()?; } } } - Ok(FieldOptions { - ctype: ctype__, - packed: packed__, - jstype: jstype__, - lazy: lazy__, - unverified_lazy: unverified_lazy__, - deprecated: deprecated__, - weak: weak__, - uninterpreted_option: uninterpreted_option__.unwrap_or_default(), + Ok(field_options::EditionDefault { + edition: edition__, + value: value__, }) } } - deserializer.deserialize_struct("google.protobuf.FieldOptions", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("google.protobuf.FieldOptions.EditionDefault", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for field_options::CType { +impl serde::Serialize for field_options::JsType { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where S: serde::Serializer, { let variant = match self { - Self::String => "STRING", - Self::Cord => "CORD", - Self::StringPiece => "STRING_PIECE", + Self::JsNormal => "JS_NORMAL", + Self::JsString => "JS_STRING", + Self::JsNumber => "JS_NUMBER", }; serializer.serialize_str(variant) } } -impl<'de> serde::Deserialize<'de> for field_options::CType { +impl<'de> serde::Deserialize<'de> for field_options::JsType { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "STRING", - "CORD", - "STRING_PIECE", + "JS_NORMAL", + "JS_STRING", + "JS_NUMBER", ]; struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = field_options::CType; + type Value = field_options::JsType; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { write!(formatter, "expected one of: {:?}", &FIELDS) @@ -2169,7 +3794,7 @@ impl<'de> serde::Deserialize<'de> for field_options::CType { use core::convert::TryFrom; i32::try_from(v) .ok() - .and_then(field_options::CType::from_i32) + .and_then(field_options::JsType::from_i32) .ok_or_else(|| { serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) }) @@ -2182,7 +3807,7 @@ impl<'de> serde::Deserialize<'de> for field_options::CType { use core::convert::TryFrom; i32::try_from(v) .ok() - .and_then(field_options::CType::from_i32) + .and_then(field_options::JsType::from_i32) .ok_or_else(|| { serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) }) @@ -2193,9 +3818,9 @@ impl<'de> serde::Deserialize<'de> for field_options::CType { E: serde::de::Error, { match value { - "STRING" => Ok(field_options::CType::String), - "CORD" => Ok(field_options::CType::Cord), - "STRING_PIECE" => Ok(field_options::CType::StringPiece), + "JS_NORMAL" => Ok(field_options::JsType::JsNormal), + "JS_STRING" => Ok(field_options::JsType::JsString), + "JS_NUMBER" => Ok(field_options::JsType::JsNumber), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -2203,36 +3828,36 @@ impl<'de> serde::Deserialize<'de> for field_options::CType { deserializer.deserialize_any(GeneratedVisitor) } } -impl serde::Serialize for field_options::JsType { +impl serde::Serialize for field_options::OptionRetention { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where S: serde::Serializer, { let variant = match self { - Self::JsNormal => "JS_NORMAL", - Self::JsString => "JS_STRING", - Self::JsNumber => "JS_NUMBER", + Self::RetentionUnknown => "RETENTION_UNKNOWN", + Self::RetentionRuntime => "RETENTION_RUNTIME", + Self::RetentionSource => "RETENTION_SOURCE", }; serializer.serialize_str(variant) } } -impl<'de> serde::Deserialize<'de> for field_options::JsType { +impl<'de> serde::Deserialize<'de> for field_options::OptionRetention { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "JS_NORMAL", - "JS_STRING", - "JS_NUMBER", + "RETENTION_UNKNOWN", + "RETENTION_RUNTIME", + "RETENTION_SOURCE", ]; struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = field_options::JsType; + type Value = field_options::OptionRetention; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { write!(formatter, "expected one of: {:?}", &FIELDS) @@ -2245,7 +3870,7 @@ impl<'de> serde::Deserialize<'de> for field_options::JsType { use core::convert::TryFrom; i32::try_from(v) .ok() - .and_then(field_options::JsType::from_i32) + .and_then(field_options::OptionRetention::from_i32) .ok_or_else(|| { serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) }) @@ -2258,7 +3883,7 @@ impl<'de> serde::Deserialize<'de> for field_options::JsType { use core::convert::TryFrom; i32::try_from(v) .ok() - .and_then(field_options::JsType::from_i32) + .and_then(field_options::OptionRetention::from_i32) .ok_or_else(|| { serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) }) @@ -2269,9 +3894,106 @@ impl<'de> serde::Deserialize<'de> for field_options::JsType { E: serde::de::Error, { match value { - "JS_NORMAL" => Ok(field_options::JsType::JsNormal), - "JS_STRING" => Ok(field_options::JsType::JsString), - "JS_NUMBER" => Ok(field_options::JsType::JsNumber), + "RETENTION_UNKNOWN" => Ok(field_options::OptionRetention::RetentionUnknown), + "RETENTION_RUNTIME" => Ok(field_options::OptionRetention::RetentionRuntime), + "RETENTION_SOURCE" => Ok(field_options::OptionRetention::RetentionSource), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for field_options::OptionTargetType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::TargetTypeUnknown => "TARGET_TYPE_UNKNOWN", + Self::TargetTypeFile => "TARGET_TYPE_FILE", + Self::TargetTypeExtensionRange => "TARGET_TYPE_EXTENSION_RANGE", + Self::TargetTypeMessage => "TARGET_TYPE_MESSAGE", + Self::TargetTypeField => "TARGET_TYPE_FIELD", + Self::TargetTypeOneof => "TARGET_TYPE_ONEOF", + Self::TargetTypeEnum => "TARGET_TYPE_ENUM", + Self::TargetTypeEnumEntry => "TARGET_TYPE_ENUM_ENTRY", + Self::TargetTypeService => "TARGET_TYPE_SERVICE", + Self::TargetTypeMethod => "TARGET_TYPE_METHOD", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for field_options::OptionTargetType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "TARGET_TYPE_UNKNOWN", + "TARGET_TYPE_FILE", + "TARGET_TYPE_EXTENSION_RANGE", + "TARGET_TYPE_MESSAGE", + "TARGET_TYPE_FIELD", + "TARGET_TYPE_ONEOF", + "TARGET_TYPE_ENUM", + "TARGET_TYPE_ENUM_ENTRY", + "TARGET_TYPE_SERVICE", + "TARGET_TYPE_METHOD", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = field_options::OptionTargetType; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(field_options::OptionTargetType::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(field_options::OptionTargetType::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "TARGET_TYPE_UNKNOWN" => Ok(field_options::OptionTargetType::TargetTypeUnknown), + "TARGET_TYPE_FILE" => Ok(field_options::OptionTargetType::TargetTypeFile), + "TARGET_TYPE_EXTENSION_RANGE" => Ok(field_options::OptionTargetType::TargetTypeExtensionRange), + "TARGET_TYPE_MESSAGE" => Ok(field_options::OptionTargetType::TargetTypeMessage), + "TARGET_TYPE_FIELD" => Ok(field_options::OptionTargetType::TargetTypeField), + "TARGET_TYPE_ONEOF" => Ok(field_options::OptionTargetType::TargetTypeOneof), + "TARGET_TYPE_ENUM" => Ok(field_options::OptionTargetType::TargetTypeEnum), + "TARGET_TYPE_ENUM_ENTRY" => Ok(field_options::OptionTargetType::TargetTypeEnumEntry), + "TARGET_TYPE_SERVICE" => Ok(field_options::OptionTargetType::TargetTypeService), + "TARGET_TYPE_METHOD" => Ok(field_options::OptionTargetType::TargetTypeMethod), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -2323,6 +4045,9 @@ impl serde::Serialize for FileDescriptorProto { if true { len += 1; } + if true { + len += 1; + } let mut struct_ser = serializer.serialize_struct("google.protobuf.FileDescriptorProto", len)?; if let Some(v) = self.name.as_ref() { struct_ser.serialize_field("name", v)?; @@ -2360,6 +4085,11 @@ impl serde::Serialize for FileDescriptorProto { if let Some(v) = self.syntax.as_ref() { struct_ser.serialize_field("syntax", v)?; } + if let Some(v) = self.edition.as_ref() { + let v = Edition::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("edition", &v)?; + } struct_ser.end() } } @@ -2387,6 +4117,7 @@ impl<'de> serde::Deserialize<'de> for FileDescriptorProto { "source_code_info", "sourceCodeInfo", "syntax", + "edition", ]; #[allow(clippy::enum_variant_names)] @@ -2403,6 +4134,7 @@ impl<'de> serde::Deserialize<'de> for FileDescriptorProto { Options, SourceCodeInfo, Syntax, + Edition, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -2436,6 +4168,7 @@ impl<'de> serde::Deserialize<'de> for FileDescriptorProto { "options" => Ok(GeneratedField::Options), "sourceCodeInfo" | "source_code_info" => Ok(GeneratedField::SourceCodeInfo), "syntax" => Ok(GeneratedField::Syntax), + "edition" => Ok(GeneratedField::Edition), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -2467,6 +4200,7 @@ impl<'de> serde::Deserialize<'de> for FileDescriptorProto { let mut options__ = None; let mut source_code_info__ = None; let mut syntax__ = None; + let mut edition__ = None; while let Some(k) = map.next_key()? { match k { GeneratedField::Name => { @@ -2547,6 +4281,12 @@ impl<'de> serde::Deserialize<'de> for FileDescriptorProto { } syntax__ = map.next_value()?; } + GeneratedField::Edition => { + if edition__.is_some() { + return Err(serde::de::Error::duplicate_field("edition")); + } + edition__ = map.next_value::<::core::option::Option>()?.map(|x| x as i32); + } } } Ok(FileDescriptorProto { @@ -2562,6 +4302,7 @@ impl<'de> serde::Deserialize<'de> for FileDescriptorProto { options: options__, source_code_info: source_code_info__, syntax: syntax__, + edition: edition__, }) } } @@ -2730,6 +4471,9 @@ impl serde::Serialize for FileOptions { if true { len += 1; } + if true { + len += 1; + } let mut struct_ser = serializer.serialize_struct("google.protobuf.FileOptions", len)?; if let Some(v) = self.java_package.as_ref() { struct_ser.serialize_field("javaPackage", v)?; @@ -2793,6 +4537,9 @@ impl serde::Serialize for FileOptions { if let Some(v) = self.ruby_package.as_ref() { struct_ser.serialize_field("rubyPackage", v)?; } + if let Some(v) = self.features.as_ref() { + struct_ser.serialize_field("features", v)?; + } if true { struct_ser.serialize_field("uninterpretedOption", &self.uninterpreted_option)?; } @@ -2845,6 +4592,7 @@ impl<'de> serde::Deserialize<'de> for FileOptions { "phpMetadataNamespace", "ruby_package", "rubyPackage", + "features", "uninterpreted_option", "uninterpretedOption", ]; @@ -2871,6 +4619,7 @@ impl<'de> serde::Deserialize<'de> for FileOptions { PhpNamespace, PhpMetadataNamespace, RubyPackage, + Features, UninterpretedOption, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -2913,6 +4662,7 @@ impl<'de> serde::Deserialize<'de> for FileOptions { "phpNamespace" | "php_namespace" => Ok(GeneratedField::PhpNamespace), "phpMetadataNamespace" | "php_metadata_namespace" => Ok(GeneratedField::PhpMetadataNamespace), "rubyPackage" | "ruby_package" => Ok(GeneratedField::RubyPackage), + "features" => Ok(GeneratedField::Features), "uninterpretedOption" | "uninterpreted_option" => Ok(GeneratedField::UninterpretedOption), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } @@ -2953,6 +4703,7 @@ impl<'de> serde::Deserialize<'de> for FileOptions { let mut php_namespace__ = None; let mut php_metadata_namespace__ = None; let mut ruby_package__ = None; + let mut features__ = None; let mut uninterpreted_option__ = None; while let Some(k) = map.next_key()? { match k { @@ -3076,6 +4827,12 @@ impl<'de> serde::Deserialize<'de> for FileOptions { } ruby_package__ = map.next_value()?; } + GeneratedField::Features => { + if features__.is_some() { + return Err(serde::de::Error::duplicate_field("features")); + } + features__ = map.next_value()?; + } GeneratedField::UninterpretedOption => { if uninterpreted_option__.is_some() { return Err(serde::de::Error::duplicate_field("uninterpretedOption")); @@ -3105,6 +4862,7 @@ impl<'de> serde::Deserialize<'de> for FileOptions { php_namespace: php_namespace__, php_metadata_namespace: php_metadata_namespace__, ruby_package: ruby_package__, + features: features__, uninterpreted_option: uninterpreted_option__.unwrap_or_default(), }) } @@ -3299,6 +5057,9 @@ impl serde::Serialize for generated_code_info::Annotation { if true { len += 1; } + if true { + len += 1; + } let mut struct_ser = serializer.serialize_struct("google.protobuf.GeneratedCodeInfo.Annotation", len)?; if true { struct_ser.serialize_field("path", &self.path)?; @@ -3312,6 +5073,11 @@ impl serde::Serialize for generated_code_info::Annotation { if let Some(v) = self.end.as_ref() { struct_ser.serialize_field("end", v)?; } + if let Some(v) = self.semantic.as_ref() { + let v = generated_code_info::annotation::Semantic::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("semantic", &v)?; + } struct_ser.end() } } @@ -3327,6 +5093,7 @@ impl<'de> serde::Deserialize<'de> for generated_code_info::Annotation { "sourceFile", "begin", "end", + "semantic", ]; #[allow(clippy::enum_variant_names)] @@ -3335,6 +5102,7 @@ impl<'de> serde::Deserialize<'de> for generated_code_info::Annotation { SourceFile, Begin, End, + Semantic, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -3360,6 +5128,7 @@ impl<'de> serde::Deserialize<'de> for generated_code_info::Annotation { "sourceFile" | "source_file" => Ok(GeneratedField::SourceFile), "begin" => Ok(GeneratedField::Begin), "end" => Ok(GeneratedField::End), + "semantic" => Ok(GeneratedField::Semantic), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3383,6 +5152,7 @@ impl<'de> serde::Deserialize<'de> for generated_code_info::Annotation { let mut source_file__ = None; let mut begin__ = None; let mut end__ = None; + let mut semantic__ = None; while let Some(k) = map.next_key()? { match k { GeneratedField::Path => { @@ -3416,6 +5186,12 @@ impl<'de> serde::Deserialize<'de> for generated_code_info::Annotation { map.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) ; } + GeneratedField::Semantic => { + if semantic__.is_some() { + return Err(serde::de::Error::duplicate_field("semantic")); + } + semantic__ = map.next_value::<::core::option::Option>()?.map(|x| x as i32); + } } } Ok(generated_code_info::Annotation { @@ -3423,12 +5199,89 @@ impl<'de> serde::Deserialize<'de> for generated_code_info::Annotation { source_file: source_file__, begin: begin__, end: end__, + semantic: semantic__, }) } } deserializer.deserialize_struct("google.protobuf.GeneratedCodeInfo.Annotation", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for generated_code_info::annotation::Semantic { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::None => "NONE", + Self::Set => "SET", + Self::Alias => "ALIAS", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for generated_code_info::annotation::Semantic { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "NONE", + "SET", + "ALIAS", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = generated_code_info::annotation::Semantic; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(generated_code_info::annotation::Semantic::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> core::result::Result + where + E: serde::de::Error, + { + use core::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(generated_code_info::annotation::Semantic::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "NONE" => Ok(generated_code_info::annotation::Semantic::None), + "SET" => Ok(generated_code_info::annotation::Semantic::Set), + "ALIAS" => Ok(generated_code_info::annotation::Semantic::Alias), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} impl serde::Serialize for MessageOptions { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result @@ -3452,6 +5305,12 @@ impl serde::Serialize for MessageOptions { if true { len += 1; } + if true { + len += 1; + } + if true { + len += 1; + } let mut struct_ser = serializer.serialize_struct("google.protobuf.MessageOptions", len)?; if let Some(v) = self.message_set_wire_format.as_ref() { struct_ser.serialize_field("messageSetWireFormat", v)?; @@ -3465,6 +5324,12 @@ impl serde::Serialize for MessageOptions { if let Some(v) = self.map_entry.as_ref() { struct_ser.serialize_field("mapEntry", v)?; } + if let Some(v) = self.deprecated_legacy_json_field_conflicts.as_ref() { + struct_ser.serialize_field("deprecatedLegacyJsonFieldConflicts", v)?; + } + if let Some(v) = self.features.as_ref() { + struct_ser.serialize_field("features", v)?; + } if true { struct_ser.serialize_field("uninterpretedOption", &self.uninterpreted_option)?; } @@ -3485,6 +5350,9 @@ impl<'de> serde::Deserialize<'de> for MessageOptions { "deprecated", "map_entry", "mapEntry", + "deprecated_legacy_json_field_conflicts", + "deprecatedLegacyJsonFieldConflicts", + "features", "uninterpreted_option", "uninterpretedOption", ]; @@ -3495,6 +5363,8 @@ impl<'de> serde::Deserialize<'de> for MessageOptions { NoStandardDescriptorAccessor, Deprecated, MapEntry, + DeprecatedLegacyJsonFieldConflicts, + Features, UninterpretedOption, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -3521,6 +5391,8 @@ impl<'de> serde::Deserialize<'de> for MessageOptions { "noStandardDescriptorAccessor" | "no_standard_descriptor_accessor" => Ok(GeneratedField::NoStandardDescriptorAccessor), "deprecated" => Ok(GeneratedField::Deprecated), "mapEntry" | "map_entry" => Ok(GeneratedField::MapEntry), + "deprecatedLegacyJsonFieldConflicts" | "deprecated_legacy_json_field_conflicts" => Ok(GeneratedField::DeprecatedLegacyJsonFieldConflicts), + "features" => Ok(GeneratedField::Features), "uninterpretedOption" | "uninterpreted_option" => Ok(GeneratedField::UninterpretedOption), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } @@ -3545,6 +5417,8 @@ impl<'de> serde::Deserialize<'de> for MessageOptions { let mut no_standard_descriptor_accessor__ = None; let mut deprecated__ = None; let mut map_entry__ = None; + let mut deprecated_legacy_json_field_conflicts__ = None; + let mut features__ = None; let mut uninterpreted_option__ = None; while let Some(k) = map.next_key()? { match k { @@ -3572,6 +5446,18 @@ impl<'de> serde::Deserialize<'de> for MessageOptions { } map_entry__ = map.next_value()?; } + GeneratedField::DeprecatedLegacyJsonFieldConflicts => { + if deprecated_legacy_json_field_conflicts__.is_some() { + return Err(serde::de::Error::duplicate_field("deprecatedLegacyJsonFieldConflicts")); + } + deprecated_legacy_json_field_conflicts__ = map.next_value()?; + } + GeneratedField::Features => { + if features__.is_some() { + return Err(serde::de::Error::duplicate_field("features")); + } + features__ = map.next_value()?; + } GeneratedField::UninterpretedOption => { if uninterpreted_option__.is_some() { return Err(serde::de::Error::duplicate_field("uninterpretedOption")); @@ -3585,6 +5471,8 @@ impl<'de> serde::Deserialize<'de> for MessageOptions { no_standard_descriptor_accessor: no_standard_descriptor_accessor__, deprecated: deprecated__, map_entry: map_entry__, + deprecated_legacy_json_field_conflicts: deprecated_legacy_json_field_conflicts__, + features: features__, uninterpreted_option: uninterpreted_option__.unwrap_or_default(), }) } @@ -3789,6 +5677,9 @@ impl serde::Serialize for MethodOptions { if true { len += 1; } + if true { + len += 1; + } let mut struct_ser = serializer.serialize_struct("google.protobuf.MethodOptions", len)?; if let Some(v) = self.deprecated.as_ref() { struct_ser.serialize_field("deprecated", v)?; @@ -3798,6 +5689,9 @@ impl serde::Serialize for MethodOptions { .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; struct_ser.serialize_field("idempotencyLevel", &v)?; } + if let Some(v) = self.features.as_ref() { + struct_ser.serialize_field("features", v)?; + } if true { struct_ser.serialize_field("uninterpretedOption", &self.uninterpreted_option)?; } @@ -3814,6 +5708,7 @@ impl<'de> serde::Deserialize<'de> for MethodOptions { "deprecated", "idempotency_level", "idempotencyLevel", + "features", "uninterpreted_option", "uninterpretedOption", ]; @@ -3822,6 +5717,7 @@ impl<'de> serde::Deserialize<'de> for MethodOptions { enum GeneratedField { Deprecated, IdempotencyLevel, + Features, UninterpretedOption, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -3846,6 +5742,7 @@ impl<'de> serde::Deserialize<'de> for MethodOptions { match value { "deprecated" => Ok(GeneratedField::Deprecated), "idempotencyLevel" | "idempotency_level" => Ok(GeneratedField::IdempotencyLevel), + "features" => Ok(GeneratedField::Features), "uninterpretedOption" | "uninterpreted_option" => Ok(GeneratedField::UninterpretedOption), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } @@ -3868,6 +5765,7 @@ impl<'de> serde::Deserialize<'de> for MethodOptions { { let mut deprecated__ = None; let mut idempotency_level__ = None; + let mut features__ = None; let mut uninterpreted_option__ = None; while let Some(k) = map.next_key()? { match k { @@ -3883,6 +5781,12 @@ impl<'de> serde::Deserialize<'de> for MethodOptions { } idempotency_level__ = map.next_value::<::core::option::Option>()?.map(|x| x as i32); } + GeneratedField::Features => { + if features__.is_some() { + return Err(serde::de::Error::duplicate_field("features")); + } + features__ = map.next_value()?; + } GeneratedField::UninterpretedOption => { if uninterpreted_option__.is_some() { return Err(serde::de::Error::duplicate_field("uninterpretedOption")); @@ -3894,6 +5798,7 @@ impl<'de> serde::Deserialize<'de> for MethodOptions { Ok(MethodOptions { deprecated: deprecated__, idempotency_level: idempotency_level__, + features: features__, uninterpreted_option: uninterpreted_option__.unwrap_or_default(), }) } @@ -4096,7 +6001,13 @@ impl serde::Serialize for OneofOptions { if true { len += 1; } + if true { + len += 1; + } let mut struct_ser = serializer.serialize_struct("google.protobuf.OneofOptions", len)?; + if let Some(v) = self.features.as_ref() { + struct_ser.serialize_field("features", v)?; + } if true { struct_ser.serialize_field("uninterpretedOption", &self.uninterpreted_option)?; } @@ -4110,12 +6021,14 @@ impl<'de> serde::Deserialize<'de> for OneofOptions { D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "features", "uninterpreted_option", "uninterpretedOption", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + Features, UninterpretedOption, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -4138,6 +6051,7 @@ impl<'de> serde::Deserialize<'de> for OneofOptions { E: serde::de::Error, { match value { + "features" => Ok(GeneratedField::Features), "uninterpretedOption" | "uninterpreted_option" => Ok(GeneratedField::UninterpretedOption), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } @@ -4158,9 +6072,16 @@ impl<'de> serde::Deserialize<'de> for OneofOptions { where V: serde::de::MapAccess<'de>, { + let mut features__ = None; let mut uninterpreted_option__ = None; while let Some(k) = map.next_key()? { match k { + GeneratedField::Features => { + if features__.is_some() { + return Err(serde::de::Error::duplicate_field("features")); + } + features__ = map.next_value()?; + } GeneratedField::UninterpretedOption => { if uninterpreted_option__.is_some() { return Err(serde::de::Error::duplicate_field("uninterpretedOption")); @@ -4170,6 +6091,7 @@ impl<'de> serde::Deserialize<'de> for OneofOptions { } } Ok(OneofOptions { + features: features__, uninterpreted_option: uninterpreted_option__.unwrap_or_default(), }) } @@ -4316,7 +6238,13 @@ impl serde::Serialize for ServiceOptions { if true { len += 1; } + if true { + len += 1; + } let mut struct_ser = serializer.serialize_struct("google.protobuf.ServiceOptions", len)?; + if let Some(v) = self.features.as_ref() { + struct_ser.serialize_field("features", v)?; + } if let Some(v) = self.deprecated.as_ref() { struct_ser.serialize_field("deprecated", v)?; } @@ -4333,6 +6261,7 @@ impl<'de> serde::Deserialize<'de> for ServiceOptions { D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "features", "deprecated", "uninterpreted_option", "uninterpretedOption", @@ -4340,6 +6269,7 @@ impl<'de> serde::Deserialize<'de> for ServiceOptions { #[allow(clippy::enum_variant_names)] enum GeneratedField { + Features, Deprecated, UninterpretedOption, } @@ -4363,6 +6293,7 @@ impl<'de> serde::Deserialize<'de> for ServiceOptions { E: serde::de::Error, { match value { + "features" => Ok(GeneratedField::Features), "deprecated" => Ok(GeneratedField::Deprecated), "uninterpretedOption" | "uninterpreted_option" => Ok(GeneratedField::UninterpretedOption), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), @@ -4384,10 +6315,17 @@ impl<'de> serde::Deserialize<'de> for ServiceOptions { where V: serde::de::MapAccess<'de>, { + let mut features__ = None; let mut deprecated__ = None; let mut uninterpreted_option__ = None; while let Some(k) = map.next_key()? { match k { + GeneratedField::Features => { + if features__.is_some() { + return Err(serde::de::Error::duplicate_field("features")); + } + features__ = map.next_value()?; + } GeneratedField::Deprecated => { if deprecated__.is_some() { return Err(serde::de::Error::duplicate_field("deprecated")); @@ -4403,6 +6341,7 @@ impl<'de> serde::Deserialize<'de> for ServiceOptions { } } Ok(ServiceOptions { + features: features__, deprecated: deprecated__, uninterpreted_option: uninterpreted_option__.unwrap_or_default(), }) diff --git a/src/prost/proto_descriptor.bin b/src/prost/proto_descriptor.bin index ea90124b21520126f17ceb51b787026e176c50b8..ae805c553896cdb51d5db0025c7069d1c406032c 100644 GIT binary patch delta 36161 zcmd^oeSB2K)qn2$-JADK0&#iCCA>ojZ&m>j4G=I01VenUh9%iRG-P8o5wX@QR7I`$ zw#Y@)ijP`+RIHlns(npU3v!pPyQD&di)S zbLPyMGiT1+z4oRu*Bzl+FO*yEBhMOHCP5+D>X~)~_^73+vflZC}kZ8-2@}|Vx=%QHd zlGa#7V#u_3ynI2deQK;R+R@xz)skqBw$#Ul3>`Yu{snJl+l}$KeWFcGJ6c+!^%wql zqZ4?OUn-VmC#P7c&Tp(9a;80FZuM--J`w+P_Q)<*iX1c3`kzcoRWsy_uzIH?_lT^| z>^wVftJ+{!ByKVNTci?_$eTHoHFCg=6|mAYE9 z3X;(+1<5+Qs57_c1bKXTjAg_cnuyEd99tTaGp4wFK|H>oIabcv&hKa}ujJ)5Ud7U< zbSpPG#~#qxc1)onzo;gc_r9oS_-re)Ay(fUZDV6DmThH7=9n?bKD`GyUcn8qv2jkVYKmBS0IEQq_Qv8kT-sjv}@>)tpy zqIVCc{EW1kb1^Zo3D)Ve�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 delta 19475 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 Date: Fri, 5 Jan 2024 21:11:17 +0100 Subject: [PATCH 08/10] fix fmt --- tools/proto-compiler/src/cmd/compile.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/tools/proto-compiler/src/cmd/compile.rs b/tools/proto-compiler/src/cmd/compile.rs index b5122041..4e021e14 100644 --- a/tools/proto-compiler/src/cmd/compile.rs +++ b/tools/proto-compiler/src/cmd/compile.rs @@ -244,7 +244,6 @@ impl CompileCmd { "The class trace `([port_id]/[channel_id])+/[class]`", )], ), - ]; for (file, patches) in PATCHES { From d2ef9fcd849347a80d25f5f5a0b87858e5f7fb98 Mon Sep 17 00:00:00 2001 From: yito88 Date: Fri, 5 Jan 2024 21:15:38 +0100 Subject: [PATCH 09/10] fix for clippy --- src/prost/google.protobuf.serde.rs | 2 +- src/prost/ibc.core.channel.v1.serde.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/prost/google.protobuf.serde.rs b/src/prost/google.protobuf.serde.rs index 78b50e08..1467d307 100644 --- a/src/prost/google.protobuf.serde.rs +++ b/src/prost/google.protobuf.serde.rs @@ -6767,7 +6767,7 @@ impl serde::Serialize for UninterpretedOption { struct_ser.serialize_field("doubleValue", v)?; } if let Some(v) = self.string_value.as_ref() { - struct_ser.serialize_field("stringValue", pbjson::private::base64::encode(&v).as_str())?; + struct_ser.serialize_field("stringValue", pbjson::private::base64::encode(v).as_str())?; } if let Some(v) = self.aggregate_value.as_ref() { struct_ser.serialize_field("aggregateValue", v)?; diff --git a/src/prost/ibc.core.channel.v1.serde.rs b/src/prost/ibc.core.channel.v1.serde.rs index 8f746f11..cd67218c 100644 --- a/src/prost/ibc.core.channel.v1.serde.rs +++ b/src/prost/ibc.core.channel.v1.serde.rs @@ -13,7 +13,7 @@ impl serde::Serialize for Acknowledgement { if let Some(v) = self.response.as_ref() { match v { acknowledgement::Response::Result(v) => { - struct_ser.serialize_field("result", pbjson::private::base64::encode(&v).as_str())?; + struct_ser.serialize_field("result", pbjson::private::base64::encode(v).as_str())?; } acknowledgement::Response::Error(v) => { struct_ser.serialize_field("error", v)?; From 65354628a1085937d506c7ac94c3819315aa8494 Mon Sep 17 00:00:00 2001 From: yito88 Date: Fri, 5 Jan 2024 21:26:17 +0100 Subject: [PATCH 10/10] add changelog --- .changelog/unreleased/features/167-ics721-impl.md | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 .changelog/unreleased/features/167-ics721-impl.md diff --git a/.changelog/unreleased/features/167-ics721-impl.md b/.changelog/unreleased/features/167-ics721-impl.md new file mode 100644 index 00000000..1281b08b --- /dev/null +++ b/.changelog/unreleased/features/167-ics721-impl.md @@ -0,0 +1,2 @@ +- Add ICS-721 proto: ([\#167](https://github.com/cosmos/ibc-proto- + rs/issues/167)) \ No newline at end of file