impl serde::Serialize for ApiKey {
#[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.api_key_id.is_empty() {
len += 1;
}
if !self.name.is_empty() {
len += 1;
}
if self.created_date.is_some() {
len += 1;
}
if !self.created_by_user_id.is_empty() {
len += 1;
}
if !self.user_id.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.api_keys.v2.ApiKey", len)?;
if !self.api_key_id.is_empty() {
struct_ser.serialize_field("apiKeyId", &self.api_key_id)?;
}
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if let Some(v) = self.created_date.as_ref() {
struct_ser.serialize_field("createdDate", v)?;
}
if !self.created_by_user_id.is_empty() {
struct_ser.serialize_field("createdByUserId", &self.created_by_user_id)?;
}
if !self.user_id.is_empty() {
struct_ser.serialize_field("userId", &self.user_id)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ApiKey {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"api_key_id",
"apiKeyId",
"name",
"created_date",
"createdDate",
"created_by_user_id",
"createdByUserId",
"user_id",
"userId",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
ApiKeyId,
Name,
CreatedDate,
CreatedByUserId,
UserId,
}
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 {
"apiKeyId" | "api_key_id" => Ok(GeneratedField::ApiKeyId),
"name" => Ok(GeneratedField::Name),
"createdDate" | "created_date" => Ok(GeneratedField::CreatedDate),
"createdByUserId" | "created_by_user_id" => Ok(GeneratedField::CreatedByUserId),
"userId" | "user_id" => Ok(GeneratedField::UserId),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ApiKey;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.api_keys.v2.ApiKey")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApiKey, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut api_key_id__ = None;
let mut name__ = None;
let mut created_date__ = None;
let mut created_by_user_id__ = None;
let mut user_id__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::ApiKeyId => {
if api_key_id__.is_some() {
return Err(serde::de::Error::duplicate_field("apiKeyId"));
}
api_key_id__ = Some(map_.next_value()?);
}
GeneratedField::Name => {
if name__.is_some() {
return Err(serde::de::Error::duplicate_field("name"));
}
name__ = Some(map_.next_value()?);
}
GeneratedField::CreatedDate => {
if created_date__.is_some() {
return Err(serde::de::Error::duplicate_field("createdDate"));
}
created_date__ = map_.next_value()?;
}
GeneratedField::CreatedByUserId => {
if created_by_user_id__.is_some() {
return Err(serde::de::Error::duplicate_field("createdByUserId"));
}
created_by_user_id__ = Some(map_.next_value()?);
}
GeneratedField::UserId => {
if user_id__.is_some() {
return Err(serde::de::Error::duplicate_field("userId"));
}
user_id__ = Some(map_.next_value()?);
}
}
}
Ok(ApiKey {
api_key_id: api_key_id__.unwrap_or_default(),
name: name__.unwrap_or_default(),
created_date: created_date__,
created_by_user_id: created_by_user_id__.unwrap_or_default(),
user_id: user_id__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.api_keys.v2.ApiKey", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ApiKeyOrganizationRequest {
#[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("sift.api_keys.v2.ApiKeyOrganizationRequest", len)?;
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ApiKeyOrganizationRequest {
#[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 {
}
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,
{
Err(serde::de::Error::unknown_field(value, FIELDS))
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ApiKeyOrganizationRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.api_keys.v2.ApiKeyOrganizationRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApiKeyOrganizationRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(ApiKeyOrganizationRequest {
})
}
}
deserializer.deserialize_struct("sift.api_keys.v2.ApiKeyOrganizationRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ApiKeyOrganizationResponse {
#[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.organization.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.api_keys.v2.ApiKeyOrganizationResponse", len)?;
if let Some(v) = self.organization.as_ref() {
struct_ser.serialize_field("organization", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ApiKeyOrganizationResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"organization",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Organization,
}
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 {
"organization" => Ok(GeneratedField::Organization),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ApiKeyOrganizationResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.api_keys.v2.ApiKeyOrganizationResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApiKeyOrganizationResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut organization__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Organization => {
if organization__.is_some() {
return Err(serde::de::Error::duplicate_field("organization"));
}
organization__ = map_.next_value()?;
}
}
}
Ok(ApiKeyOrganizationResponse {
organization: organization__,
})
}
}
deserializer.deserialize_struct("sift.api_keys.v2.ApiKeyOrganizationResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for CreateApiKeyRequest {
#[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.name.is_empty() {
len += 1;
}
if !self.user_id.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.api_keys.v2.CreateApiKeyRequest", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if !self.user_id.is_empty() {
struct_ser.serialize_field("userId", &self.user_id)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for CreateApiKeyRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
"user_id",
"userId",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
UserId,
}
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),
"userId" | "user_id" => Ok(GeneratedField::UserId),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = CreateApiKeyRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.api_keys.v2.CreateApiKeyRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateApiKeyRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut user_id__ = 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::UserId => {
if user_id__.is_some() {
return Err(serde::de::Error::duplicate_field("userId"));
}
user_id__ = Some(map_.next_value()?);
}
}
}
Ok(CreateApiKeyRequest {
name: name__.unwrap_or_default(),
user_id: user_id__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.api_keys.v2.CreateApiKeyRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for CreateApiKeyResponse {
#[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.api_key.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.api_keys.v2.CreateApiKeyResponse", len)?;
if let Some(v) = self.api_key.as_ref() {
struct_ser.serialize_field("apiKey", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for CreateApiKeyResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"api_key",
"apiKey",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
ApiKey,
}
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 {
"apiKey" | "api_key" => Ok(GeneratedField::ApiKey),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = CreateApiKeyResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.api_keys.v2.CreateApiKeyResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateApiKeyResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut api_key__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::ApiKey => {
if api_key__.is_some() {
return Err(serde::de::Error::duplicate_field("apiKey"));
}
api_key__ = map_.next_value()?;
}
}
}
Ok(CreateApiKeyResponse {
api_key: api_key__,
})
}
}
deserializer.deserialize_struct("sift.api_keys.v2.CreateApiKeyResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for CreatedApiKey {
#[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.api_key_id.is_empty() {
len += 1;
}
if !self.name.is_empty() {
len += 1;
}
if !self.key.is_empty() {
len += 1;
}
if self.created_date.is_some() {
len += 1;
}
if !self.created_by_user_id.is_empty() {
len += 1;
}
if !self.user_id.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.api_keys.v2.CreatedApiKey", len)?;
if !self.api_key_id.is_empty() {
struct_ser.serialize_field("apiKeyId", &self.api_key_id)?;
}
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if !self.key.is_empty() {
struct_ser.serialize_field("key", &self.key)?;
}
if let Some(v) = self.created_date.as_ref() {
struct_ser.serialize_field("createdDate", v)?;
}
if !self.created_by_user_id.is_empty() {
struct_ser.serialize_field("createdByUserId", &self.created_by_user_id)?;
}
if !self.user_id.is_empty() {
struct_ser.serialize_field("userId", &self.user_id)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for CreatedApiKey {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"api_key_id",
"apiKeyId",
"name",
"key",
"created_date",
"createdDate",
"created_by_user_id",
"createdByUserId",
"user_id",
"userId",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
ApiKeyId,
Name,
Key,
CreatedDate,
CreatedByUserId,
UserId,
}
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 {
"apiKeyId" | "api_key_id" => Ok(GeneratedField::ApiKeyId),
"name" => Ok(GeneratedField::Name),
"key" => Ok(GeneratedField::Key),
"createdDate" | "created_date" => Ok(GeneratedField::CreatedDate),
"createdByUserId" | "created_by_user_id" => Ok(GeneratedField::CreatedByUserId),
"userId" | "user_id" => Ok(GeneratedField::UserId),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = CreatedApiKey;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.api_keys.v2.CreatedApiKey")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreatedApiKey, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut api_key_id__ = None;
let mut name__ = None;
let mut key__ = None;
let mut created_date__ = None;
let mut created_by_user_id__ = None;
let mut user_id__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::ApiKeyId => {
if api_key_id__.is_some() {
return Err(serde::de::Error::duplicate_field("apiKeyId"));
}
api_key_id__ = Some(map_.next_value()?);
}
GeneratedField::Name => {
if name__.is_some() {
return Err(serde::de::Error::duplicate_field("name"));
}
name__ = Some(map_.next_value()?);
}
GeneratedField::Key => {
if key__.is_some() {
return Err(serde::de::Error::duplicate_field("key"));
}
key__ = Some(map_.next_value()?);
}
GeneratedField::CreatedDate => {
if created_date__.is_some() {
return Err(serde::de::Error::duplicate_field("createdDate"));
}
created_date__ = map_.next_value()?;
}
GeneratedField::CreatedByUserId => {
if created_by_user_id__.is_some() {
return Err(serde::de::Error::duplicate_field("createdByUserId"));
}
created_by_user_id__ = Some(map_.next_value()?);
}
GeneratedField::UserId => {
if user_id__.is_some() {
return Err(serde::de::Error::duplicate_field("userId"));
}
user_id__ = Some(map_.next_value()?);
}
}
}
Ok(CreatedApiKey {
api_key_id: api_key_id__.unwrap_or_default(),
name: name__.unwrap_or_default(),
key: key__.unwrap_or_default(),
created_date: created_date__,
created_by_user_id: created_by_user_id__.unwrap_or_default(),
user_id: user_id__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.api_keys.v2.CreatedApiKey", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for DeleteApiKeyRequest {
#[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.api_key_id.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.api_keys.v2.DeleteApiKeyRequest", len)?;
if !self.api_key_id.is_empty() {
struct_ser.serialize_field("apiKeyId", &self.api_key_id)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for DeleteApiKeyRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"api_key_id",
"apiKeyId",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
ApiKeyId,
}
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 {
"apiKeyId" | "api_key_id" => Ok(GeneratedField::ApiKeyId),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = DeleteApiKeyRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.api_keys.v2.DeleteApiKeyRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteApiKeyRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut api_key_id__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::ApiKeyId => {
if api_key_id__.is_some() {
return Err(serde::de::Error::duplicate_field("apiKeyId"));
}
api_key_id__ = Some(map_.next_value()?);
}
}
}
Ok(DeleteApiKeyRequest {
api_key_id: api_key_id__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.api_keys.v2.DeleteApiKeyRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for DeleteApiKeyResponse {
#[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("sift.api_keys.v2.DeleteApiKeyResponse", len)?;
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for DeleteApiKeyResponse {
#[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 {
}
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,
{
Err(serde::de::Error::unknown_field(value, FIELDS))
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = DeleteApiKeyResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.api_keys.v2.DeleteApiKeyResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteApiKeyResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(DeleteApiKeyResponse {
})
}
}
deserializer.deserialize_struct("sift.api_keys.v2.DeleteApiKeyResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListApiKeysRequest {
#[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.page_size != 0 {
len += 1;
}
if !self.page_token.is_empty() {
len += 1;
}
if !self.filter.is_empty() {
len += 1;
}
if !self.order_by.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.api_keys.v2.ListApiKeysRequest", len)?;
if self.page_size != 0 {
struct_ser.serialize_field("pageSize", &self.page_size)?;
}
if !self.page_token.is_empty() {
struct_ser.serialize_field("pageToken", &self.page_token)?;
}
if !self.filter.is_empty() {
struct_ser.serialize_field("filter", &self.filter)?;
}
if !self.order_by.is_empty() {
struct_ser.serialize_field("orderBy", &self.order_by)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListApiKeysRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"page_size",
"pageSize",
"page_token",
"pageToken",
"filter",
"order_by",
"orderBy",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
PageSize,
PageToken,
Filter,
OrderBy,
}
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 {
"pageSize" | "page_size" => Ok(GeneratedField::PageSize),
"pageToken" | "page_token" => Ok(GeneratedField::PageToken),
"filter" => Ok(GeneratedField::Filter),
"orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListApiKeysRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.api_keys.v2.ListApiKeysRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListApiKeysRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut page_size__ = None;
let mut page_token__ = None;
let mut filter__ = None;
let mut order_by__ = None;
while let Some(k) = map_.next_key()? {
match k {
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::OrderBy => {
if order_by__.is_some() {
return Err(serde::de::Error::duplicate_field("orderBy"));
}
order_by__ = Some(map_.next_value()?);
}
}
}
Ok(ListApiKeysRequest {
page_size: page_size__.unwrap_or_default(),
page_token: page_token__.unwrap_or_default(),
filter: filter__.unwrap_or_default(),
order_by: order_by__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.api_keys.v2.ListApiKeysRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListApiKeysResponse {
#[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.api_keys.is_empty() {
len += 1;
}
if !self.next_page_token.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.api_keys.v2.ListApiKeysResponse", len)?;
if !self.api_keys.is_empty() {
struct_ser.serialize_field("apiKeys", &self.api_keys)?;
}
if !self.next_page_token.is_empty() {
struct_ser.serialize_field("nextPageToken", &self.next_page_token)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListApiKeysResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"api_keys",
"apiKeys",
"next_page_token",
"nextPageToken",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
ApiKeys,
NextPageToken,
}
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 {
"apiKeys" | "api_keys" => Ok(GeneratedField::ApiKeys),
"nextPageToken" | "next_page_token" => Ok(GeneratedField::NextPageToken),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListApiKeysResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.api_keys.v2.ListApiKeysResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListApiKeysResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut api_keys__ = None;
let mut next_page_token__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::ApiKeys => {
if api_keys__.is_some() {
return Err(serde::de::Error::duplicate_field("apiKeys"));
}
api_keys__ = 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()?);
}
}
}
Ok(ListApiKeysResponse {
api_keys: api_keys__.unwrap_or_default(),
next_page_token: next_page_token__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.api_keys.v2.ListApiKeysResponse", FIELDS, GeneratedVisitor)
}
}