impl serde::Serialize for ActionLogon {
    #[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_identifier.is_empty() {
            len += 1;
        }
        if !self.version.is_empty() {
            len += 1;
        }
        if !self.action_configurations.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("aquila.ActionLogon", len)?;
        if !self.action_identifier.is_empty() {
            struct_ser.serialize_field("actionIdentifier", &self.action_identifier)?;
        }
        if !self.version.is_empty() {
            struct_ser.serialize_field("version", &self.version)?;
        }
        if !self.action_configurations.is_empty() {
            struct_ser.serialize_field("actionConfigurations", &self.action_configurations)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ActionLogon {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "action_identifier",
            "actionIdentifier",
            "version",
            "action_configurations",
            "actionConfigurations",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            ActionIdentifier,
            Version,
            ActionConfigurations,
        }
        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 serde::de::Visitor<'_> 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 {
                            "actionIdentifier" | "action_identifier" => Ok(GeneratedField::ActionIdentifier),
                            "version" => Ok(GeneratedField::Version),
                            "actionConfigurations" | "action_configurations" => Ok(GeneratedField::ActionConfigurations),
                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ActionLogon;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct aquila.ActionLogon")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActionLogon, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut action_identifier__ = None;
                let mut version__ = None;
                let mut action_configurations__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::ActionIdentifier => {
                            if action_identifier__.is_some() {
                                return Err(serde::de::Error::duplicate_field("actionIdentifier"));
                            }
                            action_identifier__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Version => {
                            if version__.is_some() {
                                return Err(serde::de::Error::duplicate_field("version"));
                            }
                            version__ = Some(map_.next_value()?);
                        }
                        GeneratedField::ActionConfigurations => {
                            if action_configurations__.is_some() {
                                return Err(serde::de::Error::duplicate_field("actionConfigurations"));
                            }
                            action_configurations__ = Some(map_.next_value()?);
                        }
                    }
                }
                Ok(ActionLogon {
                    action_identifier: action_identifier__.unwrap_or_default(),
                    version: version__.unwrap_or_default(),
                    action_configurations: action_configurations__.unwrap_or_default(),
                })
            }
        }
        deserializer.deserialize_struct("aquila.ActionLogon", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for ActionRuntimeError {
    #[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.code.is_empty() {
            len += 1;
        }
        if self.description.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("aquila.ActionRuntimeError", len)?;
        if !self.code.is_empty() {
            struct_ser.serialize_field("code", &self.code)?;
        }
        if let Some(v) = self.description.as_ref() {
            struct_ser.serialize_field("description", v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ActionRuntimeError {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "code",
            "description",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Code,
            Description,
        }
        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 serde::de::Visitor<'_> 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 {
                            "code" => Ok(GeneratedField::Code),
                            "description" => Ok(GeneratedField::Description),
                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ActionRuntimeError;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct aquila.ActionRuntimeError")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActionRuntimeError, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut code__ = None;
                let mut description__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Code => {
                            if code__.is_some() {
                                return Err(serde::de::Error::duplicate_field("code"));
                            }
                            code__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Description => {
                            if description__.is_some() {
                                return Err(serde::de::Error::duplicate_field("description"));
                            }
                            description__ = map_.next_value()?;
                        }
                    }
                }
                Ok(ActionRuntimeError {
                    code: code__.unwrap_or_default(),
                    description: description__,
                })
            }
        }
        deserializer.deserialize_struct("aquila.ActionRuntimeError", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for DataTypeUpdateRequest {
    #[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.data_types.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("aquila.DataTypeUpdateRequest", len)?;
        if !self.data_types.is_empty() {
            struct_ser.serialize_field("dataTypes", &self.data_types)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for DataTypeUpdateRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "data_types",
            "dataTypes",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            DataTypes,
        }
        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 serde::de::Visitor<'_> 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 {
                            "dataTypes" | "data_types" => Ok(GeneratedField::DataTypes),
                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = DataTypeUpdateRequest;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct aquila.DataTypeUpdateRequest")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DataTypeUpdateRequest, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut data_types__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::DataTypes => {
                            if data_types__.is_some() {
                                return Err(serde::de::Error::duplicate_field("dataTypes"));
                            }
                            data_types__ = Some(map_.next_value()?);
                        }
                    }
                }
                Ok(DataTypeUpdateRequest {
                    data_types: data_types__.unwrap_or_default(),
                })
            }
        }
        deserializer.deserialize_struct("aquila.DataTypeUpdateRequest", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for DataTypeUpdateResponse {
    #[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.success {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("aquila.DataTypeUpdateResponse", len)?;
        if self.success {
            struct_ser.serialize_field("success", &self.success)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for DataTypeUpdateResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "success",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Success,
        }
        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 serde::de::Visitor<'_> 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 {
                            "success" => Ok(GeneratedField::Success),
                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = DataTypeUpdateResponse;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct aquila.DataTypeUpdateResponse")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DataTypeUpdateResponse, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut success__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Success => {
                            if success__.is_some() {
                                return Err(serde::de::Error::duplicate_field("success"));
                            }
                            success__ = Some(map_.next_value()?);
                        }
                    }
                }
                Ok(DataTypeUpdateResponse {
                    success: success__.unwrap_or_default(),
                })
            }
        }
        deserializer.deserialize_struct("aquila.DataTypeUpdateResponse", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for Event {
    #[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.event_type.is_empty() {
            len += 1;
        }
        if self.project_id != 0 {
            len += 1;
        }
        if self.payload.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("aquila.Event", len)?;
        if !self.event_type.is_empty() {
            struct_ser.serialize_field("eventType", &self.event_type)?;
        }
        if self.project_id != 0 {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser.serialize_field("projectId", ToString::to_string(&self.project_id).as_str())?;
        }
        if let Some(v) = self.payload.as_ref() {
            struct_ser.serialize_field("payload", v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for Event {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "event_type",
            "eventType",
            "project_id",
            "projectId",
            "payload",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            EventType,
            ProjectId,
            Payload,
        }
        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 serde::de::Visitor<'_> 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 {
                            "eventType" | "event_type" => Ok(GeneratedField::EventType),
                            "projectId" | "project_id" => Ok(GeneratedField::ProjectId),
                            "payload" => Ok(GeneratedField::Payload),
                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = Event;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct aquila.Event")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Event, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut event_type__ = None;
                let mut project_id__ = None;
                let mut payload__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::EventType => {
                            if event_type__.is_some() {
                                return Err(serde::de::Error::duplicate_field("eventType"));
                            }
                            event_type__ = Some(map_.next_value()?);
                        }
                        GeneratedField::ProjectId => {
                            if project_id__.is_some() {
                                return Err(serde::de::Error::duplicate_field("projectId"));
                            }
                            project_id__ = 
                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                            ;
                        }
                        GeneratedField::Payload => {
                            if payload__.is_some() {
                                return Err(serde::de::Error::duplicate_field("payload"));
                            }
                            payload__ = map_.next_value()?;
                        }
                    }
                }
                Ok(Event {
                    event_type: event_type__.unwrap_or_default(),
                    project_id: project_id__.unwrap_or_default(),
                    payload: payload__,
                })
            }
        }
        deserializer.deserialize_struct("aquila.Event", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for ExecutionRequest {
    #[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.execution_identifier.is_empty() {
            len += 1;
        }
        if !self.function_identifier.is_empty() {
            len += 1;
        }
        if self.parameters.is_some() {
            len += 1;
        }
        if self.project_id != 0 {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("aquila.ExecutionRequest", len)?;
        if !self.execution_identifier.is_empty() {
            struct_ser.serialize_field("executionIdentifier", &self.execution_identifier)?;
        }
        if !self.function_identifier.is_empty() {
            struct_ser.serialize_field("functionIdentifier", &self.function_identifier)?;
        }
        if let Some(v) = self.parameters.as_ref() {
            struct_ser.serialize_field("parameters", v)?;
        }
        if self.project_id != 0 {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser.serialize_field("projectId", ToString::to_string(&self.project_id).as_str())?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ExecutionRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "execution_identifier",
            "executionIdentifier",
            "function_identifier",
            "functionIdentifier",
            "parameters",
            "project_id",
            "projectId",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            ExecutionIdentifier,
            FunctionIdentifier,
            Parameters,
            ProjectId,
        }
        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 serde::de::Visitor<'_> 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 {
                            "executionIdentifier" | "execution_identifier" => Ok(GeneratedField::ExecutionIdentifier),
                            "functionIdentifier" | "function_identifier" => Ok(GeneratedField::FunctionIdentifier),
                            "parameters" => Ok(GeneratedField::Parameters),
                            "projectId" | "project_id" => Ok(GeneratedField::ProjectId),
                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ExecutionRequest;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct aquila.ExecutionRequest")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExecutionRequest, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut execution_identifier__ = None;
                let mut function_identifier__ = None;
                let mut parameters__ = None;
                let mut project_id__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::ExecutionIdentifier => {
                            if execution_identifier__.is_some() {
                                return Err(serde::de::Error::duplicate_field("executionIdentifier"));
                            }
                            execution_identifier__ = Some(map_.next_value()?);
                        }
                        GeneratedField::FunctionIdentifier => {
                            if function_identifier__.is_some() {
                                return Err(serde::de::Error::duplicate_field("functionIdentifier"));
                            }
                            function_identifier__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Parameters => {
                            if parameters__.is_some() {
                                return Err(serde::de::Error::duplicate_field("parameters"));
                            }
                            parameters__ = map_.next_value()?;
                        }
                        GeneratedField::ProjectId => {
                            if project_id__.is_some() {
                                return Err(serde::de::Error::duplicate_field("projectId"));
                            }
                            project_id__ = 
                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                            ;
                        }
                    }
                }
                Ok(ExecutionRequest {
                    execution_identifier: execution_identifier__.unwrap_or_default(),
                    function_identifier: function_identifier__.unwrap_or_default(),
                    parameters: parameters__,
                    project_id: project_id__.unwrap_or_default(),
                })
            }
        }
        deserializer.deserialize_struct("aquila.ExecutionRequest", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for ExecutionResult {
    #[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.execution_identifier.is_empty() {
            len += 1;
        }
        if self.result.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("aquila.ExecutionResult", len)?;
        if !self.execution_identifier.is_empty() {
            struct_ser.serialize_field("executionIdentifier", &self.execution_identifier)?;
        }
        if let Some(v) = self.result.as_ref() {
            match v {
                execution_result::Result::Success(v) => {
                    struct_ser.serialize_field("success", v)?;
                }
                execution_result::Result::Error(v) => {
                    struct_ser.serialize_field("error", v)?;
                }
            }
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ExecutionResult {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "execution_identifier",
            "executionIdentifier",
            "success",
            "error",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            ExecutionIdentifier,
            Success,
            Error,
        }
        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 serde::de::Visitor<'_> 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 {
                            "executionIdentifier" | "execution_identifier" => Ok(GeneratedField::ExecutionIdentifier),
                            "success" => Ok(GeneratedField::Success),
                            "error" => Ok(GeneratedField::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 = ExecutionResult;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct aquila.ExecutionResult")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExecutionResult, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut execution_identifier__ = None;
                let mut result__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::ExecutionIdentifier => {
                            if execution_identifier__.is_some() {
                                return Err(serde::de::Error::duplicate_field("executionIdentifier"));
                            }
                            execution_identifier__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Success => {
                            if result__.is_some() {
                                return Err(serde::de::Error::duplicate_field("success"));
                            }
                            result__ = map_.next_value::<::std::option::Option<_>>()?.map(execution_result::Result::Success)
;
                        }
                        GeneratedField::Error => {
                            if result__.is_some() {
                                return Err(serde::de::Error::duplicate_field("error"));
                            }
                            result__ = map_.next_value::<::std::option::Option<_>>()?.map(execution_result::Result::Error)
;
                        }
                    }
                }
                Ok(ExecutionResult {
                    execution_identifier: execution_identifier__.unwrap_or_default(),
                    result: result__,
                })
            }
        }
        deserializer.deserialize_struct("aquila.ExecutionResult", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for FlowTypeUpdateRequest {
    #[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.flow_types.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("aquila.FlowTypeUpdateRequest", len)?;
        if !self.flow_types.is_empty() {
            struct_ser.serialize_field("flowTypes", &self.flow_types)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for FlowTypeUpdateRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "flow_types",
            "flowTypes",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            FlowTypes,
        }
        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 serde::de::Visitor<'_> 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 {
                            "flowTypes" | "flow_types" => Ok(GeneratedField::FlowTypes),
                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = FlowTypeUpdateRequest;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct aquila.FlowTypeUpdateRequest")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlowTypeUpdateRequest, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut flow_types__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::FlowTypes => {
                            if flow_types__.is_some() {
                                return Err(serde::de::Error::duplicate_field("flowTypes"));
                            }
                            flow_types__ = Some(map_.next_value()?);
                        }
                    }
                }
                Ok(FlowTypeUpdateRequest {
                    flow_types: flow_types__.unwrap_or_default(),
                })
            }
        }
        deserializer.deserialize_struct("aquila.FlowTypeUpdateRequest", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for FlowTypeUpdateResponse {
    #[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.success {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("aquila.FlowTypeUpdateResponse", len)?;
        if self.success {
            struct_ser.serialize_field("success", &self.success)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for FlowTypeUpdateResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "success",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Success,
        }
        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 serde::de::Visitor<'_> 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 {
                            "success" => Ok(GeneratedField::Success),
                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = FlowTypeUpdateResponse;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct aquila.FlowTypeUpdateResponse")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlowTypeUpdateResponse, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut success__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Success => {
                            if success__.is_some() {
                                return Err(serde::de::Error::duplicate_field("success"));
                            }
                            success__ = Some(map_.next_value()?);
                        }
                    }
                }
                Ok(FlowTypeUpdateResponse {
                    success: success__.unwrap_or_default(),
                })
            }
        }
        deserializer.deserialize_struct("aquila.FlowTypeUpdateResponse", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for RuntimeFunctionDefinitionUpdateRequest {
    #[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.runtime_functions.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("aquila.RuntimeFunctionDefinitionUpdateRequest", len)?;
        if !self.runtime_functions.is_empty() {
            struct_ser.serialize_field("runtimeFunctions", &self.runtime_functions)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for RuntimeFunctionDefinitionUpdateRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "runtime_functions",
            "runtimeFunctions",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            RuntimeFunctions,
        }
        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 serde::de::Visitor<'_> 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 {
                            "runtimeFunctions" | "runtime_functions" => Ok(GeneratedField::RuntimeFunctions),
                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = RuntimeFunctionDefinitionUpdateRequest;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct aquila.RuntimeFunctionDefinitionUpdateRequest")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RuntimeFunctionDefinitionUpdateRequest, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut runtime_functions__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::RuntimeFunctions => {
                            if runtime_functions__.is_some() {
                                return Err(serde::de::Error::duplicate_field("runtimeFunctions"));
                            }
                            runtime_functions__ = Some(map_.next_value()?);
                        }
                    }
                }
                Ok(RuntimeFunctionDefinitionUpdateRequest {
                    runtime_functions: runtime_functions__.unwrap_or_default(),
                })
            }
        }
        deserializer.deserialize_struct("aquila.RuntimeFunctionDefinitionUpdateRequest", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for RuntimeFunctionDefinitionUpdateResponse {
    #[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.success {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("aquila.RuntimeFunctionDefinitionUpdateResponse", len)?;
        if self.success {
            struct_ser.serialize_field("success", &self.success)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for RuntimeFunctionDefinitionUpdateResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "success",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Success,
        }
        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 serde::de::Visitor<'_> 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 {
                            "success" => Ok(GeneratedField::Success),
                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = RuntimeFunctionDefinitionUpdateResponse;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct aquila.RuntimeFunctionDefinitionUpdateResponse")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RuntimeFunctionDefinitionUpdateResponse, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut success__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Success => {
                            if success__.is_some() {
                                return Err(serde::de::Error::duplicate_field("success"));
                            }
                            success__ = Some(map_.next_value()?);
                        }
                    }
                }
                Ok(RuntimeFunctionDefinitionUpdateResponse {
                    success: success__.unwrap_or_default(),
                })
            }
        }
        deserializer.deserialize_struct("aquila.RuntimeFunctionDefinitionUpdateResponse", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for RuntimeStatusUpdateRequest {
    #[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.status.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("aquila.RuntimeStatusUpdateRequest", len)?;
        if let Some(v) = self.status.as_ref() {
            match v {
                runtime_status_update_request::Status::AdapterRuntimeStatus(v) => {
                    struct_ser.serialize_field("adapterRuntimeStatus", v)?;
                }
                runtime_status_update_request::Status::ExecutionRuntimeStatus(v) => {
                    struct_ser.serialize_field("executionRuntimeStatus", v)?;
                }
            }
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for RuntimeStatusUpdateRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "adapter_runtime_status",
            "adapterRuntimeStatus",
            "execution_runtime_status",
            "executionRuntimeStatus",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            AdapterRuntimeStatus,
            ExecutionRuntimeStatus,
        }
        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 serde::de::Visitor<'_> 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 {
                            "adapterRuntimeStatus" | "adapter_runtime_status" => Ok(GeneratedField::AdapterRuntimeStatus),
                            "executionRuntimeStatus" | "execution_runtime_status" => Ok(GeneratedField::ExecutionRuntimeStatus),
                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = RuntimeStatusUpdateRequest;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct aquila.RuntimeStatusUpdateRequest")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RuntimeStatusUpdateRequest, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut status__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::AdapterRuntimeStatus => {
                            if status__.is_some() {
                                return Err(serde::de::Error::duplicate_field("adapterRuntimeStatus"));
                            }
                            status__ = map_.next_value::<::std::option::Option<_>>()?.map(runtime_status_update_request::Status::AdapterRuntimeStatus)
;
                        }
                        GeneratedField::ExecutionRuntimeStatus => {
                            if status__.is_some() {
                                return Err(serde::de::Error::duplicate_field("executionRuntimeStatus"));
                            }
                            status__ = map_.next_value::<::std::option::Option<_>>()?.map(runtime_status_update_request::Status::ExecutionRuntimeStatus)
;
                        }
                    }
                }
                Ok(RuntimeStatusUpdateRequest {
                    status: status__,
                })
            }
        }
        deserializer.deserialize_struct("aquila.RuntimeStatusUpdateRequest", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for RuntimeStatusUpdateResponse {
    #[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.success {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("aquila.RuntimeStatusUpdateResponse", len)?;
        if self.success {
            struct_ser.serialize_field("success", &self.success)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for RuntimeStatusUpdateResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "success",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Success,
        }
        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 serde::de::Visitor<'_> 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 {
                            "success" => Ok(GeneratedField::Success),
                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = RuntimeStatusUpdateResponse;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct aquila.RuntimeStatusUpdateResponse")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RuntimeStatusUpdateResponse, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut success__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Success => {
                            if success__.is_some() {
                                return Err(serde::de::Error::duplicate_field("success"));
                            }
                            success__ = Some(map_.next_value()?);
                        }
                    }
                }
                Ok(RuntimeStatusUpdateResponse {
                    success: success__.unwrap_or_default(),
                })
            }
        }
        deserializer.deserialize_struct("aquila.RuntimeStatusUpdateResponse", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for RuntimeUsageRequest {
    #[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.runtime_usage.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("aquila.RuntimeUsageRequest", len)?;
        if !self.runtime_usage.is_empty() {
            struct_ser.serialize_field("runtimeUsage", &self.runtime_usage)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for RuntimeUsageRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "runtime_usage",
            "runtimeUsage",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            RuntimeUsage,
        }
        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 serde::de::Visitor<'_> 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 {
                            "runtimeUsage" | "runtime_usage" => Ok(GeneratedField::RuntimeUsage),
                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = RuntimeUsageRequest;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct aquila.RuntimeUsageRequest")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RuntimeUsageRequest, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut runtime_usage__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::RuntimeUsage => {
                            if runtime_usage__.is_some() {
                                return Err(serde::de::Error::duplicate_field("runtimeUsage"));
                            }
                            runtime_usage__ = Some(map_.next_value()?);
                        }
                    }
                }
                Ok(RuntimeUsageRequest {
                    runtime_usage: runtime_usage__.unwrap_or_default(),
                })
            }
        }
        deserializer.deserialize_struct("aquila.RuntimeUsageRequest", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for RuntimeUsageResponse {
    #[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.success {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("aquila.RuntimeUsageResponse", len)?;
        if self.success {
            struct_ser.serialize_field("success", &self.success)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for RuntimeUsageResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "success",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Success,
        }
        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 serde::de::Visitor<'_> 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 {
                            "success" => Ok(GeneratedField::Success),
                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = RuntimeUsageResponse;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct aquila.RuntimeUsageResponse")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RuntimeUsageResponse, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut success__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Success => {
                            if success__.is_some() {
                                return Err(serde::de::Error::duplicate_field("success"));
                            }
                            success__ = Some(map_.next_value()?);
                        }
                    }
                }
                Ok(RuntimeUsageResponse {
                    success: success__.unwrap_or_default(),
                })
            }
        }
        deserializer.deserialize_struct("aquila.RuntimeUsageResponse", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for TransferRequest {
    #[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.data.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("aquila.TransferRequest", len)?;
        if let Some(v) = self.data.as_ref() {
            match v {
                transfer_request::Data::Logon(v) => {
                    struct_ser.serialize_field("logon", v)?;
                }
                transfer_request::Data::Event(v) => {
                    struct_ser.serialize_field("event", v)?;
                }
                transfer_request::Data::Result(v) => {
                    struct_ser.serialize_field("result", v)?;
                }
            }
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for TransferRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "logon",
            "event",
            "result",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Logon,
            Event,
            Result,
        }
        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 serde::de::Visitor<'_> 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 {
                            "logon" => Ok(GeneratedField::Logon),
                            "event" => Ok(GeneratedField::Event),
                            "result" => Ok(GeneratedField::Result),
                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = TransferRequest;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct aquila.TransferRequest")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TransferRequest, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut data__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Logon => {
                            if data__.is_some() {
                                return Err(serde::de::Error::duplicate_field("logon"));
                            }
                            data__ = map_.next_value::<::std::option::Option<_>>()?.map(transfer_request::Data::Logon)
;
                        }
                        GeneratedField::Event => {
                            if data__.is_some() {
                                return Err(serde::de::Error::duplicate_field("event"));
                            }
                            data__ = map_.next_value::<::std::option::Option<_>>()?.map(transfer_request::Data::Event)
;
                        }
                        GeneratedField::Result => {
                            if data__.is_some() {
                                return Err(serde::de::Error::duplicate_field("result"));
                            }
                            data__ = map_.next_value::<::std::option::Option<_>>()?.map(transfer_request::Data::Result)
;
                        }
                    }
                }
                Ok(TransferRequest {
                    data: data__,
                })
            }
        }
        deserializer.deserialize_struct("aquila.TransferRequest", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for TransferResponse {
    #[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.data.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("aquila.TransferResponse", len)?;
        if let Some(v) = self.data.as_ref() {
            match v {
                transfer_response::Data::Execution(v) => {
                    struct_ser.serialize_field("execution", v)?;
                }
                transfer_response::Data::ActionConfigurations(v) => {
                    struct_ser.serialize_field("actionConfigurations", v)?;
                }
            }
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for TransferResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "execution",
            "action_configurations",
            "actionConfigurations",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Execution,
            ActionConfigurations,
        }
        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 serde::de::Visitor<'_> 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 {
                            "execution" => Ok(GeneratedField::Execution),
                            "actionConfigurations" | "action_configurations" => Ok(GeneratedField::ActionConfigurations),
                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = TransferResponse;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct aquila.TransferResponse")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TransferResponse, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut data__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Execution => {
                            if data__.is_some() {
                                return Err(serde::de::Error::duplicate_field("execution"));
                            }
                            data__ = map_.next_value::<::std::option::Option<_>>()?.map(transfer_response::Data::Execution)
;
                        }
                        GeneratedField::ActionConfigurations => {
                            if data__.is_some() {
                                return Err(serde::de::Error::duplicate_field("actionConfigurations"));
                            }
                            data__ = map_.next_value::<::std::option::Option<_>>()?.map(transfer_response::Data::ActionConfigurations)
;
                        }
                    }
                }
                Ok(TransferResponse {
                    data: data__,
                })
            }
        }
        deserializer.deserialize_struct("aquila.TransferResponse", FIELDS, GeneratedVisitor)
    }
}
