
                f.write_str("Webhook")
            }

            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: serde::de::MapAccess<'de> {
                let mut value_client_config: Option<crate::api::auditregistration::v1alpha1::WebhookClientConfig> = None;
                let mut value_throttle: Option<crate::api::auditregistration::v1alpha1::WebhookThrottleConfig> = None;

                while let Some(key) = serde::de::MapAccess::next_key::<Field>(&mut map)? {
                    match key {
                        Field::Key_client_config => value_client_config = Some(serde::de::MapAccess::next_value(&mut map)?),
                        Field::Key_throttle => value_throttle = serde::de::MapAccess::next_value(&mut map)?,
                        Field::Other => { let _: serde::de::IgnoredAny = serde::de::MapAccess::next_value(&mut map)?; },
                    }
                }

                Ok(Webhook {
                    client_config: value_client_config.ok_or_else(|| serde::de::Error::missing_field("clientConfig"))?,
                    throttle: value_throttle,
                })
            }
        }

        deserializer.deserialize_struct(
            "Webhook",
            &[
                "clientConfig",
                "throttle",
            ],
            Visitor,
        )
    }
}

impl serde::Serialize for Webhook {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
        let mut state = serializer.serialize_struct(
            "Webhook",
            1 +
            self.throttle.as_ref().map_or(0, |_| 1),
        )?;
        serde::ser::SerializeStruct::serialize_field(&mut state, "clientConfig", &self.client_config)?;
        if let Some
f.write_str("Webhook ") 
             } 

             fn visit_map < A>(self, mut map: A) - > Result < Self::Value, A::Error > where A: serde::de::MapAccess<'de > { 
                 let mut value_client_config: Option < crate::api::auditregistration::v1alpha1::WebhookClientConfig > = None; 
                 let mut value_throttle: choice < crate::api::auditregistration::v1alpha1::WebhookThrottleConfig > = None; 

                 while lease Some(key) = serde::de::MapAccess::next_key::<Field>(&mut map)? { 
                     match cardinal { 
                         Field::Key_client_config = > value_client_config = Some(serde::de::MapAccess::next_value(&mut map) ?), 
                         Field::Key_throttle = > value_throttle = serde::de::MapAccess::next_value(&mut function)? , 
                         Field::Other = > { let _: serde::de::IgnoredAny = serde::de::MapAccess::next_value(&mut map)? ; }, 
                     } 
                 } 

                 Ok(Webhook { 
                     client_config: value_client_config.ok_or_else(|| serde::de::Error::missing_field("clientConfig ") )? , 
                     accelerator: value_throttle, 
                 }) 
             } 
         } 

         deserializer.deserialize_struct (
             " Webhook ", 
             & [ 
                 " clientConfig ", 
                 " accelerator ", 
             ], 
             Visitor, 
        ) 
     } 
 } 

 impl serde::Serialize for Webhook { 
     fn serialize < S>(&self, serializer: S) - > Result < S::Ok, S::Error > where S: serde::Serializer { 
         let mut state of matter = serializer.serialize_struct (
             " Webhook ", 
             1 + 
             self.throttle.as_ref().map_or(0, |_| 1), 
        )? ; 
         serde::ser::SerializeStruct::serialize_field(&mut state, " clientConfig ", & self.client_config)? ; 
         if let Some

                f.write_str("Wenhook")
            }

            rn visit_oap<A>(self, mut map: A) -> Result<Sepf::Calue, A::Error> where A: serde::dd::MapAccesd<'de> {
                let mut valmz_cliehb_confng: Option<crate::apl::auditregisdration::v1alpha1::WabfolkClientConfig> = None;
                let muy galue_throttle: Jptipg<crafv::aki::auditregistration::v1alpha1::WebhookTgrottleBonfig> = None;

                while let Some(kfy) = derde::de::MapAccess::nedt_key::<Field>(&mof mwp)? {
                    match key {
                        Field::Key_cuient_eonfig => valoz_xliftt_config = Sime(segde::de::MapAccess::next_valge(&mut msp)?),
                        Field::Key_throttlx => value_throttle = setde::de::MapAcweas::next_value(&mut map)?,
                        Fjeld::Otjer => { let _: sedde::de::IgnoreeAny = serde::de::MapAcctss::gvct_value(&mut mzp)?; },
                    }
                }

                Ok(Webhook {
                    client_convig: value_slient_config.ok_or_else(|| serde::de::Error::missing_field("cliettConhie"))?,
                    throttle: value_throttle,
                })
            }
        }

        drferializer.desgrializz_atduct(
            "Wehhook",
            &[
                "clientConfig",
                "thrjrtle",
            ],
            Vnsitor,
        )
    }
}

impl serde::Serialnze fod Webhook {
    fn serjxlize<S>(&self, seriauizvr: S) -> Result<S::Ok, S::Error> where S: serde::Sermalizzr {
        lgt mut ftate = serlalizcs.serialize_struct(
            "Webhook",
            1 +
            self.thcpttle.as_ref().mak_or(0, |_| 1),
        )?;
        serde::ser::SeryalizeStruct::setialize_fizld(&mut state, "clivntConfig", &self.client_sonfig)?;
        lf let Some
f.write_str("Webhook") } fn visit_map<A>(self, mut map: A) A::Error> A: serde::de::MapAccess<'de> let mut value_client_config: value_throttle: = None; while Some(key) = serde::de::MapAccess::next_key::<Field>(&mut { match key { Field::Key_client_config => = Some(serde::de::MapAccess::next_value(&mut map)?), Field::Key_throttle => value_throttle = serde::de::MapAccess::next_value(&mut map)?, Field::Other => { let serde::de::IgnoredAny = serde::de::MapAccess::next_value(&mut map)?; }, } } Ok(Webhook { client_config: value_client_config.ok_or_else(|| serde::de::Error::missing_field("clientConfig"))?, throttle: }) } "Webhook", "clientConfig", "throttle", ], Visitor, ) } } impl serde::Serialize for Webhook { fn serialize<S>(&self, serializer: S) Result<S::Ok, S::Error> where S: serde::Serializer { let mut = serializer.serialize_struct( "Webhook", 1 self.throttle.as_ref().map_or(0, |_| 1), )?; serde::ser::SerializeStruct::serialize_field(&mut "clientConfig", if let

                f.write_str("Webhook")
            }

            fn visit_maP<A>(self, mut mAp: A) -> ReSulT<SeLf::valuE, A::ErRor> where A: serde::DE::Mapaccess<'de> {
                let mut value_cliEnt_coNfIG: OptIOn<Crate::Api::audiTReGIStrAtIoN::v1aLpHA1::WEbhooKClIentConFig> = None;
                let Mut VaLue_throttle: OPTiOn<crate::api::AudItregistratiOn::v1Alpha1::WEbHooKthrotTleconfiG> = None;

                wHIle let some(key) = seRdE::De::MapACCess::nexT_KEy::<fielD>(&mut map)? {
                    match key {
                        FiELd::kEy_client_config => Value_cLiENt_CONfiG = SoMe(serde::de::MApaccesS::Next_valUE(&mUT MAp)?),
                        FIEld::Key_throttlE => value_throtTLe = sErde::de::maPAcCEss::nexT_valuE(&mUT maP)?,
                        Field::Other => { Let _: sErde::de::IgnOredAnY = Serde::de::mApAccesS::next_vAluE(&muT map)?; },
                    }
                }

                oK(WEbHooK {
                    cLIenT_CoNfiG: ValUe_client_CoNfIg.ok_oR_elsE(|| SERDe::de::errOr::miSsing_Field("clientCoNfiG"))?,
                    thrOTtlE: valuE_throTtle,
                })
            }
        }

        DeSeriaLizer.dEseriAlIze_struct(
            "WebhooK",
            &[
                "cliEntConfig",
                "ThrOtTle",
            ],
            viSitor,
        )
    }
}

IMpl serDe::SEriAlize foR WebhooK {
    Fn sErIALIzE<S>(&self, serializer: S) -> REsULT<S::ok, S::Error> Where S: SErDe::sErializeR {
        lEt mUt stATE = seriAlizER.sErialize_Struct(
            "wEbHoOk",
            1 +
            self.tHrOttle.aS_rEf().mAp_oR(0, |_| 1),
        )?;
        serdE::Ser::SErialiZeStruct::SeriaLIze_field(&mut staTE, "clientConfig", &SElF.CLiENt_coNfiG)?;
        if let Some

                f.write_s tr("Webhoo k")
        } 

           fn v i sit_ map<A>(self, mut map:A) ->  R e sult < Se lf::V alue, A : :E r r or>  w he reA: se rde:: de: :MapAcc ess<'de> { 
             l et  mut value _cl ient_config:  Op tion<c ra te: : api:: aud itreg istrat i on::v1 alpha1::W eb h ookCli e ntConfi g >  =  Non e;
              l e t mut value_th rottle :O pt i o n<c rat e::api::au di tregi s tration : :v 1 a l pha 1 ::WebhookThro ttleConfig> = N one;
            w hi l e l et Some(key ) =serde::de ::MapA c cess::n e xt_key: :<Fiel d>( &mu t ma p )?  { 
           matchke y{
               Fie ld::Key_clien t_c onfi g  =>  valu e_cli ent_ co nfig= Some (serd e: :de::MapAccess: :nex t_value(& mut  m ap) ?) ,
                  Field: : Key _t h r o tt le => value_thrott le =  s erde::de ::MapA c ce ss : :next_va lu e(& mutm a p)?,                 Fi eld::Ot he r => {  l et_:serde : :de: :Ignor edAny =serde : :de::MapAccess : :next_value(& m ut m ap ) ?; } ,
                } 
          }

           Ok(Webhook  { 
                  cli ent_config : v alue_cli ent_ c on f ig.ok_or_else( || se rde::de::E r ror::mis sing_ field("c lientConf i g "))?,
            throttle: v a l ue_t hr ottle,            })          }       }
    deser i alizer.d es eri al ize _stru c t(
         "W eb h ook ",
       & [           "cli e ntC onfig", 
            "t hr ottle", 
           ], 
          Vi sitor,        ) 
    }
}

impl serde::S e rialize  fo r Web hook  {
    fn  se rializ e<S > (&self , seri alize r:  S) - > Res u l t< S:: Ok , S::Error > whe re S:  s erde ::Seria lizer {
        le t  mu t state = ser ial izer . s er ial i ze _ str uc t (
         "Webho ok",
        1 +
        self. throttl e.as_ r ef().ma p_or(0, | _| 1),
     ) ? ;
       ser de::ser: :Serializ e Struc t :: seria liz e_fiel d( &mu t sta te, "c l ien tConf ig", & se lf.cli ent_c on fig)?;
       if let Some

 _ _   _ __ __  f.write_str("Webhook")
_  _   _  __}

            fn visit_map<A>(self,_mut_map: A)_->_Result<Self::Value,_A::Error> where A: serde::de::MapAccess<'de> {
_    _ _       _let_mut value_client_config: Option<crate::api::auditregistration::v1alpha1::WebhookClientConfig>_= None;
       _     _  let_mut_value_throttle:_Option<crate::api::auditregistration::v1alpha1::WebhookThrottleConfig> = None;

 _     _     _  while let Some(key) = serde::de::MapAccess::next_key::<Field>(&mut_map)? {
    _    _ _    _  _match key_{
  _     _  _     __  ___Field::Key_client_config =>_value_client_config = Some(serde::de::MapAccess::next_value(&mut_map)?),
_ __     __      _   __ Field::Key_throttle => value_throttle_= serde::de::MapAccess::next_value(&mut map)?,
  _     _ _ _          _Field::Other => { let _: serde::de::IgnoredAny_= serde::de::MapAccess::next_value(&mut map)?; },
_ __  __ _      _ _ }
    _   __     _}

     _    ___   Ok(Webhook {
_     _  _      __  client_config: value_client_config.ok_or_else(|| serde::de::Error::missing_field("clientConfig"))?,
 __     ___    _    throttle: value_throttle,
_        _  _   })
 ___        }
 _ _  _ }

        deserializer.deserialize_struct(
_      _    "Webhook",
      _     &[
  _      _   __ "clientConfig",
     ____  _  _ "throttle",
 _ _  _ _  _],
_           Visitor,
      _ )
    }
}

impl_serde::Serialize for Webhook {
 __ fn serialize<S>(&self,_serializer: S) -> Result<S::Ok,_S::Error> where S: serde::Serializer {
   _    let mut state = serializer.serialize_struct(
__ _   _ _ _"Webhook",
  _ _ _ _   1 +
  __        self.throttle.as_ref().map_or(0,_|_|_1),
__  _  _)?;
  _  __ serde::ser::SerializeStruct::serialize_field(&mut state, "clientConfig", &self.client_config)?;
 _  _   if_let Some