impl serde::Serialize for AcknowledgeNotificationRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.notification.AcknowledgeNotificationRequest", len)?;
if true {
struct_ser.serialize_field("name", &self.name)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for AcknowledgeNotificationRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"name" => Ok(GeneratedField::Name),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = AcknowledgeNotificationRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.notification.AcknowledgeNotificationRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<AcknowledgeNotificationRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = 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__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(AcknowledgeNotificationRequest {
name: name__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.notification.AcknowledgeNotificationRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for FutureLpPageTarget {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
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("kdo.v1.notification.FutureLpPageTarget", len)?;
if true {
struct_ser.serialize_field("future_symbol", &self.future_symbol)?;
}
if true {
struct_ser.serialize_field("fund_code", &self.fund_code)?;
}
if true {
struct_ser.serialize_field("etf_symbol", &self.etf_symbol)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for FutureLpPageTarget {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"future_symbol",
"futureSymbol",
"fund_code",
"fundCode",
"etf_symbol",
"etfSymbol",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
FutureSymbol,
FundCode,
EtfSymbol,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"futureSymbol" | "future_symbol" => Ok(GeneratedField::FutureSymbol),
"fundCode" | "fund_code" => Ok(GeneratedField::FundCode),
"etfSymbol" | "etf_symbol" => Ok(GeneratedField::EtfSymbol),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = FutureLpPageTarget;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.notification.FutureLpPageTarget")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<FutureLpPageTarget, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut future_symbol__ = None;
let mut fund_code__ = None;
let mut etf_symbol__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::FutureSymbol => {
if future_symbol__.is_some() {
return Err(serde::de::Error::duplicate_field("futureSymbol"));
}
future_symbol__ = Some(map_.next_value()?);
}
GeneratedField::FundCode => {
if fund_code__.is_some() {
return Err(serde::de::Error::duplicate_field("fundCode"));
}
fund_code__ = Some(map_.next_value()?);
}
GeneratedField::EtfSymbol => {
if etf_symbol__.is_some() {
return Err(serde::de::Error::duplicate_field("etfSymbol"));
}
etf_symbol__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(FutureLpPageTarget {
future_symbol: future_symbol__.unwrap_or_default(),
fund_code: fund_code__.unwrap_or_default(),
etf_symbol: etf_symbol__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.notification.FutureLpPageTarget", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListNotificationsRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
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;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.notification.ListNotificationsRequest", len)?;
if true {
struct_ser.serialize_field("user", &self.user)?;
}
if true {
struct_ser.serialize_field("page_size", &self.page_size)?;
}
if true {
struct_ser.serialize_field("page_token", &self.page_token)?;
}
if true {
struct_ser.serialize_field("filter", &self.filter)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListNotificationsRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"user",
"page_size",
"pageSize",
"page_token",
"pageToken",
"filter",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
User,
PageSize,
PageToken,
Filter,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"user" => Ok(GeneratedField::User),
"pageSize" | "page_size" => Ok(GeneratedField::PageSize),
"pageToken" | "page_token" => Ok(GeneratedField::PageToken),
"filter" => Ok(GeneratedField::Filter),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListNotificationsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.notification.ListNotificationsRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListNotificationsRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut user__ = None;
let mut page_size__ = None;
let mut page_token__ = None;
let mut filter__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::User => {
if user__.is_some() {
return Err(serde::de::Error::duplicate_field("user"));
}
user__ = Some(map_.next_value()?);
}
GeneratedField::PageSize => {
if page_size__.is_some() {
return Err(serde::de::Error::duplicate_field("pageSize"));
}
page_size__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::PageToken => {
if page_token__.is_some() {
return Err(serde::de::Error::duplicate_field("pageToken"));
}
page_token__ = Some(map_.next_value()?);
}
GeneratedField::Filter => {
if filter__.is_some() {
return Err(serde::de::Error::duplicate_field("filter"));
}
filter__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ListNotificationsRequest {
user: user__.unwrap_or_default(),
page_size: page_size__.unwrap_or_default(),
page_token: page_token__.unwrap_or_default(),
filter: filter__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.notification.ListNotificationsRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListNotificationsResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
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("kdo.v1.notification.ListNotificationsResponse", len)?;
if true {
struct_ser.serialize_field("notifications", &self.notifications)?;
}
if true {
struct_ser.serialize_field("next_page_token", &self.next_page_token)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListNotificationsResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"notifications",
"next_page_token",
"nextPageToken",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Notifications,
NextPageToken,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"notifications" => Ok(GeneratedField::Notifications),
"nextPageToken" | "next_page_token" => Ok(GeneratedField::NextPageToken),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListNotificationsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.notification.ListNotificationsResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListNotificationsResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut notifications__ = None;
let mut next_page_token__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Notifications => {
if notifications__.is_some() {
return Err(serde::de::Error::duplicate_field("notifications"));
}
notifications__ = Some(map_.next_value()?);
}
GeneratedField::NextPageToken => {
if next_page_token__.is_some() {
return Err(serde::de::Error::duplicate_field("nextPageToken"));
}
next_page_token__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ListNotificationsResponse {
notifications: notifications__.unwrap_or_default(),
next_page_token: next_page_token__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.notification.ListNotificationsResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for LpPageTarget {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
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("kdo.v1.notification.LpPageTarget", len)?;
if true {
struct_ser.serialize_field("etf_code", &self.etf_code)?;
}
if true {
struct_ser.serialize_field("fund_code", &self.fund_code)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for LpPageTarget {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"etf_code",
"etfCode",
"fund_code",
"fundCode",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
EtfCode,
FundCode,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"etfCode" | "etf_code" => Ok(GeneratedField::EtfCode),
"fundCode" | "fund_code" => Ok(GeneratedField::FundCode),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = LpPageTarget;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.notification.LpPageTarget")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<LpPageTarget, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut etf_code__ = None;
let mut fund_code__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::EtfCode => {
if etf_code__.is_some() {
return Err(serde::de::Error::duplicate_field("etfCode"));
}
etf_code__ = Some(map_.next_value()?);
}
GeneratedField::FundCode => {
if fund_code__.is_some() {
return Err(serde::de::Error::duplicate_field("fundCode"));
}
fund_code__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(LpPageTarget {
etf_code: etf_code__.unwrap_or_default(),
fund_code: fund_code__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.notification.LpPageTarget", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MmPageTarget {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
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("kdo.v1.notification.MmPageTarget", len)?;
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
if true {
struct_ser.serialize_field("fund_code", &self.fund_code)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for MmPageTarget {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"symbol",
"fund_code",
"fundCode",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Symbol,
FundCode,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"symbol" => Ok(GeneratedField::Symbol),
"fundCode" | "fund_code" => Ok(GeneratedField::FundCode),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MmPageTarget;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.notification.MmPageTarget")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<MmPageTarget, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut symbol__ = None;
let mut fund_code__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Symbol => {
if symbol__.is_some() {
return Err(serde::de::Error::duplicate_field("symbol"));
}
symbol__ = Some(map_.next_value()?);
}
GeneratedField::FundCode => {
if fund_code__.is_some() {
return Err(serde::de::Error::duplicate_field("fundCode"));
}
fund_code__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(MmPageTarget {
symbol: symbol__.unwrap_or_default(),
fund_code: fund_code__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.notification.MmPageTarget", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for NavigateAction {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.target.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.notification.NavigateAction", len)?;
if let Some(v) = self.target.as_ref() {
match v {
navigate_action::Target::LpPage(v) => {
struct_ser.serialize_field("lp_page", v)?;
}
navigate_action::Target::FutureLpPage(v) => {
struct_ser.serialize_field("future_lp_page", v)?;
}
navigate_action::Target::MmPage(v) => {
struct_ser.serialize_field("mm_page", v)?;
}
}
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for NavigateAction {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"lp_page",
"lpPage",
"future_lp_page",
"futureLpPage",
"mm_page",
"mmPage",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
LpPage,
FutureLpPage,
MmPage,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"lpPage" | "lp_page" => Ok(GeneratedField::LpPage),
"futureLpPage" | "future_lp_page" => Ok(GeneratedField::FutureLpPage),
"mmPage" | "mm_page" => Ok(GeneratedField::MmPage),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = NavigateAction;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.notification.NavigateAction")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<NavigateAction, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut target__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::LpPage => {
if target__.is_some() {
return Err(serde::de::Error::duplicate_field("lpPage"));
}
target__ = map_.next_value::<::std::option::Option<_>>()?.map(navigate_action::Target::LpPage)
;
}
GeneratedField::FutureLpPage => {
if target__.is_some() {
return Err(serde::de::Error::duplicate_field("futureLpPage"));
}
target__ = map_.next_value::<::std::option::Option<_>>()?.map(navigate_action::Target::FutureLpPage)
;
}
GeneratedField::MmPage => {
if target__.is_some() {
return Err(serde::de::Error::duplicate_field("mmPage"));
}
target__ = map_.next_value::<::std::option::Option<_>>()?.map(navigate_action::Target::MmPage)
;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(NavigateAction {
target: target__,
})
}
}
deserializer.deserialize_struct("kdo.v1.notification.NavigateAction", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for NoOp {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let len = 0;
let struct_ser = serializer.serialize_struct("kdo.v1.notification.NoOp", len)?;
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for NoOp {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
Ok(GeneratedField::__SkipField__)
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = NoOp;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.notification.NoOp")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOp, V::Error>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(NoOp {
})
}
}
deserializer.deserialize_struct("kdo.v1.notification.NoOp", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for Notification {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
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;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.notification.Notification", len)?;
if true {
struct_ser.serialize_field("name", &self.name)?;
}
if true {
struct_ser.serialize_field("user", &self.user)?;
}
if let Some(v) = self.portfolio.as_ref() {
struct_ser.serialize_field("portfolio", v)?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
}
if true {
let v = NotificationType::try_from(self.r#type)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
struct_ser.serialize_field("type", &v)?;
}
if let Some(v) = self.action.as_ref() {
struct_ser.serialize_field("action", v)?;
}
if true {
let v = NotificationState::try_from(self.state)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
struct_ser.serialize_field("state", &v)?;
}
if true {
struct_ser.serialize_field("title", &self.title)?;
}
if true {
struct_ser.serialize_field("body", &self.body)?;
}
if true {
struct_ser.serialize_field("metadata", &self.metadata)?;
}
if let Some(v) = self.navigation_url.as_ref() {
struct_ser.serialize_field("navigation_url", v)?;
}
if let Some(v) = self.create_time.as_ref() {
struct_ser.serialize_field("create_time", v)?;
}
if let Some(v) = self.expire_time.as_ref() {
struct_ser.serialize_field("expire_time", v)?;
}
if let Some(v) = self.acknowledge_time.as_ref() {
struct_ser.serialize_field("acknowledge_time", v)?;
}
if let Some(v) = self.symbol.as_ref() {
struct_ser.serialize_field("symbol", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Notification {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
"user",
"portfolio",
"id",
"type",
"action",
"state",
"title",
"body",
"metadata",
"navigation_url",
"navigationUrl",
"create_time",
"createTime",
"expire_time",
"expireTime",
"acknowledge_time",
"acknowledgeTime",
"symbol",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
User,
Portfolio,
Id,
Type,
Action,
State,
Title,
Body,
Metadata,
NavigationUrl,
CreateTime,
ExpireTime,
AcknowledgeTime,
Symbol,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"name" => Ok(GeneratedField::Name),
"user" => Ok(GeneratedField::User),
"portfolio" => Ok(GeneratedField::Portfolio),
"id" => Ok(GeneratedField::Id),
"type" => Ok(GeneratedField::Type),
"action" => Ok(GeneratedField::Action),
"state" => Ok(GeneratedField::State),
"title" => Ok(GeneratedField::Title),
"body" => Ok(GeneratedField::Body),
"metadata" => Ok(GeneratedField::Metadata),
"navigationUrl" | "navigation_url" => Ok(GeneratedField::NavigationUrl),
"createTime" | "create_time" => Ok(GeneratedField::CreateTime),
"expireTime" | "expire_time" => Ok(GeneratedField::ExpireTime),
"acknowledgeTime" | "acknowledge_time" => Ok(GeneratedField::AcknowledgeTime),
"symbol" => Ok(GeneratedField::Symbol),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Notification;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.notification.Notification")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<Notification, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut user__ = None;
let mut portfolio__ = None;
let mut id__ = None;
let mut r#type__ = None;
let mut action__ = None;
let mut state__ = None;
let mut title__ = None;
let mut body__ = None;
let mut metadata__ = None;
let mut navigation_url__ = None;
let mut create_time__ = None;
let mut expire_time__ = None;
let mut acknowledge_time__ = None;
let mut symbol__ = 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__ = Some(map_.next_value()?);
}
GeneratedField::User => {
if user__.is_some() {
return Err(serde::de::Error::duplicate_field("user"));
}
user__ = Some(map_.next_value()?);
}
GeneratedField::Portfolio => {
if portfolio__.is_some() {
return Err(serde::de::Error::duplicate_field("portfolio"));
}
portfolio__ = map_.next_value()?;
}
GeneratedField::Id => {
if id__.is_some() {
return Err(serde::de::Error::duplicate_field("id"));
}
id__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::Type => {
if r#type__.is_some() {
return Err(serde::de::Error::duplicate_field("type"));
}
r#type__ = Some(map_.next_value::<NotificationType>()? as i32);
}
GeneratedField::Action => {
if action__.is_some() {
return Err(serde::de::Error::duplicate_field("action"));
}
action__ = map_.next_value()?;
}
GeneratedField::State => {
if state__.is_some() {
return Err(serde::de::Error::duplicate_field("state"));
}
state__ = Some(map_.next_value::<NotificationState>()? as i32);
}
GeneratedField::Title => {
if title__.is_some() {
return Err(serde::de::Error::duplicate_field("title"));
}
title__ = Some(map_.next_value()?);
}
GeneratedField::Body => {
if body__.is_some() {
return Err(serde::de::Error::duplicate_field("body"));
}
body__ = Some(map_.next_value()?);
}
GeneratedField::Metadata => {
if metadata__.is_some() {
return Err(serde::de::Error::duplicate_field("metadata"));
}
metadata__ = Some(
map_.next_value::<std::collections::HashMap<_, _>>()?
);
}
GeneratedField::NavigationUrl => {
if navigation_url__.is_some() {
return Err(serde::de::Error::duplicate_field("navigationUrl"));
}
navigation_url__ = map_.next_value()?;
}
GeneratedField::CreateTime => {
if create_time__.is_some() {
return Err(serde::de::Error::duplicate_field("createTime"));
}
create_time__ = map_.next_value()?;
}
GeneratedField::ExpireTime => {
if expire_time__.is_some() {
return Err(serde::de::Error::duplicate_field("expireTime"));
}
expire_time__ = map_.next_value()?;
}
GeneratedField::AcknowledgeTime => {
if acknowledge_time__.is_some() {
return Err(serde::de::Error::duplicate_field("acknowledgeTime"));
}
acknowledge_time__ = map_.next_value()?;
}
GeneratedField::Symbol => {
if symbol__.is_some() {
return Err(serde::de::Error::duplicate_field("symbol"));
}
symbol__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(Notification {
name: name__.unwrap_or_default(),
user: user__.unwrap_or_default(),
portfolio: portfolio__,
id: id__.unwrap_or_default(),
r#type: r#type__.unwrap_or_default(),
action: action__,
state: state__.unwrap_or_default(),
title: title__.unwrap_or_default(),
body: body__.unwrap_or_default(),
metadata: metadata__.unwrap_or_default(),
navigation_url: navigation_url__,
create_time: create_time__,
expire_time: expire_time__,
acknowledge_time: acknowledge_time__,
symbol: symbol__,
})
}
}
deserializer.deserialize_struct("kdo.v1.notification.Notification", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for NotificationAction {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.action.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.notification.NotificationAction", len)?;
if let Some(v) = self.action.as_ref() {
match v {
notification_action::Action::NoOp(v) => {
struct_ser.serialize_field("no_op", v)?;
}
notification_action::Action::Navigate(v) => {
struct_ser.serialize_field("navigate", v)?;
}
}
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for NotificationAction {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"no_op",
"noOp",
"navigate",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
NoOp,
Navigate,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"noOp" | "no_op" => Ok(GeneratedField::NoOp),
"navigate" => Ok(GeneratedField::Navigate),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = NotificationAction;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.notification.NotificationAction")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<NotificationAction, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut action__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::NoOp => {
if action__.is_some() {
return Err(serde::de::Error::duplicate_field("noOp"));
}
action__ = map_.next_value::<::std::option::Option<_>>()?.map(notification_action::Action::NoOp)
;
}
GeneratedField::Navigate => {
if action__.is_some() {
return Err(serde::de::Error::duplicate_field("navigate"));
}
action__ = map_.next_value::<::std::option::Option<_>>()?.map(notification_action::Action::Navigate)
;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(NotificationAction {
action: action__,
})
}
}
deserializer.deserialize_struct("kdo.v1.notification.NotificationAction", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for NotificationState {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let variant = match self {
Self::StateUnspecified => "STATE_UNSPECIFIED",
Self::Created => "CREATED",
Self::Acknowledged => "ACKNOWLEDGED",
Self::Expired => "EXPIRED",
};
serializer.serialize_str(variant)
}
}
impl<'de> serde::Deserialize<'de> for NotificationState {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"STATE_UNSPECIFIED",
"CREATED",
"ACKNOWLEDGED",
"EXPIRED",
];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = NotificationState;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
})
}
fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
})
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
match value {
"STATE_UNSPECIFIED" => Ok(NotificationState::StateUnspecified),
"CREATED" => Ok(NotificationState::Created),
"ACKNOWLEDGED" => Ok(NotificationState::Acknowledged),
"EXPIRED" => Ok(NotificationState::Expired),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}
impl serde::Serialize for NotificationType {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let variant = match self {
Self::TypeUnspecified => "TYPE_UNSPECIFIED",
Self::Info => "INFO",
Self::Error => "ERROR",
Self::Warning => "WARNING",
};
serializer.serialize_str(variant)
}
}
impl<'de> serde::Deserialize<'de> for NotificationType {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"TYPE_UNSPECIFIED",
"INFO",
"ERROR",
"WARNING",
];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = NotificationType;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
})
}
fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
})
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
match value {
"TYPE_UNSPECIFIED" => Ok(NotificationType::TypeUnspecified),
"INFO" => Ok(NotificationType::Info),
"ERROR" => Ok(NotificationType::Error),
"WARNING" => Ok(NotificationType::Warning),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}
impl serde::Serialize for SubscribeNotificationsRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
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("kdo.v1.notification.SubscribeNotificationsRequest", len)?;
if true {
struct_ser.serialize_field("user", &self.user)?;
}
if let Some(v) = self.portfolio.as_ref() {
struct_ser.serialize_field("portfolio", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for SubscribeNotificationsRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"user",
"portfolio",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
User,
Portfolio,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"user" => Ok(GeneratedField::User),
"portfolio" => Ok(GeneratedField::Portfolio),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = SubscribeNotificationsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.notification.SubscribeNotificationsRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeNotificationsRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut user__ = None;
let mut portfolio__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::User => {
if user__.is_some() {
return Err(serde::de::Error::duplicate_field("user"));
}
user__ = Some(map_.next_value()?);
}
GeneratedField::Portfolio => {
if portfolio__.is_some() {
return Err(serde::de::Error::duplicate_field("portfolio"));
}
portfolio__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(SubscribeNotificationsRequest {
user: user__.unwrap_or_default(),
portfolio: portfolio__,
})
}
}
deserializer.deserialize_struct("kdo.v1.notification.SubscribeNotificationsRequest", FIELDS, GeneratedVisitor)
}
}