pub mod serialization {
    pub use serialization::dynamic_event_serde::DynamicEventSerde;
    pub use serialization::dynamic_events::DynamicEvents;
    pub use serialization::dynamic_event_mapper_serde::DynamicEventMapperSerde;
    mod dynamic_event_serde {
        use error::*;
        use serde_json;
        use serde::Serialize;
        use std::fmt::Debug;
        #[allow(non_upper_case_globals,
                unused_attributes,
                unused_qualifications)]
        const _IMPL_SERIALIZE_FOR_DynamicEventSerde: () =
            {
                extern crate serde as _serde;
                #[automatically_derived]
                impl <'a, TArgs> _serde::ser::Serialize for
                 DynamicEventSerde<'a, TArgs> where TArgs: Clone + Debug +
                 Serialize + Eq + PartialEq + 'a,
                 TArgs: _serde::ser::Serialize {
                    fn serialize<__S>(&self, _serializer: &mut __S)
                     -> ::std::result::Result<(), __S::Error> where
                     __S: _serde::ser::Serializer {
                        let mut state =
                            try!(_serializer . serialize_struct (
                                 "DynamicEventSerde" , 0 + 1 + 1 ));
                        try!(_serializer . serialize_struct_elt (
                             & mut state , "dynamic_event_id" ,
                             &self.dynamic_event_id ));
                        try!(_serializer . serialize_struct_elt (
                             & mut state , "args" , &self.args ));
                        _serializer.serialize_struct_end(state)
                    }
                }
            };
        #[derive(PartialEq, Eq, Debug, Clone)]
        pub struct DynamicEventSerde<'a, TArgs> where TArgs: Clone + Debug +
                   Serialize + Eq + PartialEq + 'a {
            dynamic_event_id: usize,
            args: &'a TArgs,
        }
        impl <'a, TArgs> DynamicEventSerde<'a, TArgs> where TArgs: Clone +
         Debug + Serialize + Eq + PartialEq + 'a {
            pub fn new(dynamic_event_id: usize, args: &'a TArgs) -> Self {
                DynamicEventSerde{dynamic_event_id: dynamic_event_id,
                                  args: args,}
            }
            pub fn to_json(&self) -> Result<String> {
                serde_json::to_string(&self).map_err(|err| err.into())
            }
        }
    }
    mod dynamic_event_mapper_serde {
        use std::collections::HashMap;
        #[allow(non_upper_case_globals,
                unused_attributes,
                unused_qualifications)]
        const _IMPL_SERIALIZE_FOR_DynamicEventMapperSerde: () =
            {
                extern crate serde as _serde;
                #[automatically_derived]
                impl <'a> _serde::ser::Serialize for
                 DynamicEventMapperSerde<'a> {
                    fn serialize<__S>(&self, _serializer: &mut __S)
                     -> ::std::result::Result<(), __S::Error> where
                     __S: _serde::ser::Serializer {
                        let mut state =
                            try!(_serializer . serialize_struct (
                                 "DynamicEventMapperSerde" , 0 + 1 ));
                        try!(_serializer . serialize_struct_elt (
                             & mut state , "dynamic_event_map" ,
                             &self.dynamic_event_map ));
                        _serializer.serialize_struct_end(state)
                    }
                }
            };
        #[derive(PartialEq, Eq, Debug, Clone)]
        pub struct DynamicEventMapperSerde<'a> {
            dynamic_event_map: &'a Vec<Option<HashMap<String, usize>>>,
        }
        impl <'a> DynamicEventMapperSerde<'a> {
            pub fn new(dynamic_event_map:
                           &'a Vec<Option<HashMap<String, usize>>>) -> Self {
                DynamicEventMapperSerde{dynamic_event_map: dynamic_event_map,}
            }
        }
    }
    mod dynamic_events {
        #[allow(non_upper_case_globals,
                unused_attributes,
                unused_qualifications)]
        const _IMPL_DESERIALIZE_FOR_DynamicEvents: () =
            {
                extern crate serde as _serde;
                #[automatically_derived]
                impl _serde::de::Deserialize for DynamicEvents {
                    fn deserialize<__D>(deserializer: &mut __D)
                     -> ::std::result::Result<DynamicEvents, __D::Error> where
                     __D: _serde::de::Deserializer {
                        #[allow(non_camel_case_types)]
                        enum __Field { __field0, __ignore, }
                        impl _serde::de::Deserialize for __Field {
                            #[inline]
                            fn deserialize<__D>(deserializer: &mut __D)
                             -> ::std::result::Result<__Field, __D::Error>
                             where __D: _serde::de::Deserializer {
                                struct __FieldVisitor;
                                impl _serde::de::Visitor for __FieldVisitor {
                                    type
                                    Value
                                    =
                                    __Field;
                                    fn visit_usize<__E>(&mut self,
                                                        value: usize)
                                     -> ::std::result::Result<__Field, __E>
                                     where __E: _serde::de::Error {
                                        match value {
                                            0usize => {
                                                Ok(__Field::__field0)
                                            }
                                            _ => Ok(__Field::__ignore),
                                        }
                                    }
                                    fn visit_str<__E>(&mut self, value: &str)
                                     -> ::std::result::Result<__Field, __E>
                                     where __E: _serde::de::Error {
                                        match value {
                                            "dynamic_events" => {
                                                Ok(__Field::__field0)
                                            }
                                            _ => Ok(__Field::__ignore),
                                        }
                                    }
                                    fn visit_bytes<__E>(&mut self,
                                                        value: &[u8])
                                     -> ::std::result::Result<__Field, __E>
                                     where __E: _serde::de::Error {
                                        match value {
                                            b"dynamic_events" => {
                                                Ok(__Field::__field0)
                                            }
                                            _ => Ok(__Field::__ignore),
                                        }
                                    }
                                }
                                deserializer.deserialize_struct_field(__FieldVisitor)
                            }
                        }
                        struct __Visitor;
                        impl _serde::de::Visitor for __Visitor {
                            type
                            Value
                            =
                            DynamicEvents;
                            #[inline]
                            fn visit_seq<__V>(&mut self, mut visitor: __V)
                             ->
                                 ::std::result::Result<DynamicEvents,
                                                       __V::Error> where
                             __V: _serde::de::SeqVisitor {
                                let __field0 =
                                    match try!(visitor . visit :: <
                                               Vec<String> > (  )) {
                                        Some(value) => { value }
                                        None => {
                                            try!(visitor . end (  ));
                                            return Err(_serde::de::Error::invalid_length(0usize));
                                        }
                                    };
                                try!(visitor . end (  ));
                                Ok(DynamicEvents{dynamic_events: __field0,})
                            }
                            #[inline]
                            fn visit_map<__V>(&mut self, mut visitor: __V)
                             ->
                                 ::std::result::Result<DynamicEvents,
                                                       __V::Error> where
                             __V: _serde::de::MapVisitor {
                                let mut __field0: Option<Vec<String>> = None;
                                while let Some(key) =
                                          try!(visitor . visit_key :: <
                                               __Field > (  )) {
                                    match key {
                                        __Field::__field0 => {
                                            if __field0.is_some() {
                                                return Err(<__V::Error as
                                                               _serde::de::Error>::duplicate_field("dynamic_events"));
                                            }
                                            __field0 =
                                                Some(try!(visitor .
                                                          visit_value :: <
                                                          Vec<String> > (
                                                          )));
                                        }
                                        _ => {
                                            try!(visitor . visit_value :: <
                                                 _serde :: de :: impls ::
                                                 IgnoredAny > (  ));
                                        }
                                    }
                                }
                                try!(visitor . end (  ));
                                let __field0 =
                                    match __field0 {
                                        Some(__field0) => __field0,
                                        None =>
                                        try!(visitor . missing_field (
                                             "dynamic_events" )),
                                    };
                                Ok(DynamicEvents{dynamic_events: __field0,})
                            }
                        }
                        const FIELDS: &'static [&'static str] =
                            &["dynamic_events"];
                        deserializer.deserialize_struct("DynamicEvents",
                                                        FIELDS, __Visitor)
                    }
                }
            };
        #[derive(PartialEq, Eq, Debug, Clone)]
        pub struct DynamicEvents {
            dynamic_events: Vec<String>,
        }
        impl DynamicEvents {
            pub fn destructure(self) -> Vec<String> { self.dynamic_events }
        }
    }
}