zeebest 0.20.0

// This file is generated by rust-protobuf 2.8.1. Do not edit
// @generated

// https://github.com/Manishearth/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]

#![cfg_attr(rustfmt, rustfmt_skip)]

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unsafe_code)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `proto/gateway.proto`

use protobuf::Message as Message_imported_for_functions;
use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;

/// Generated files are compatible only with the same version
/// of protobuf runtime.
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_8_1;

#[derive(PartialEq,Clone,Default)]
pub struct ActivateJobsRequest {
    // message fields
    pub field_type: ::std::string::String,
    pub worker: ::std::string::String,
    pub timeout: i64,
    pub maxJobsToActivate: i32,
    pub fetchVariable: ::protobuf::RepeatedField<::std::string::String>,
    pub requestTimeout: i64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ActivateJobsRequest {
    fn default() -> &'a ActivateJobsRequest {
        <ActivateJobsRequest as ::protobuf::Message>::default_instance()
    }
}

impl ActivateJobsRequest {
    pub fn new() -> ActivateJobsRequest {
        ::std::default::Default::default()
    }

    // string type = 1;


    pub fn get_field_type(&self) -> &str {
        &self.field_type
    }
    pub fn clear_field_type(&mut self) {
        self.field_type.clear();
    }

    // Param is passed by value, moved
    pub fn set_field_type(&mut self, v: ::std::string::String) {
        self.field_type = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_field_type(&mut self) -> &mut ::std::string::String {
        &mut self.field_type
    }

    // Take field
    pub fn take_field_type(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.field_type, ::std::string::String::new())
    }

    // string worker = 2;


    pub fn get_worker(&self) -> &str {
        &self.worker
    }
    pub fn clear_worker(&mut self) {
        self.worker.clear();
    }

    // Param is passed by value, moved
    pub fn set_worker(&mut self, v: ::std::string::String) {
        self.worker = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_worker(&mut self) -> &mut ::std::string::String {
        &mut self.worker
    }

    // Take field
    pub fn take_worker(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.worker, ::std::string::String::new())
    }

    // int64 timeout = 3;


    pub fn get_timeout(&self) -> i64 {
        self.timeout
    }
    pub fn clear_timeout(&mut self) {
        self.timeout = 0;
    }

    // Param is passed by value, moved
    pub fn set_timeout(&mut self, v: i64) {
        self.timeout = v;
    }

    // int32 maxJobsToActivate = 4;


    pub fn get_maxJobsToActivate(&self) -> i32 {
        self.maxJobsToActivate
    }
    pub fn clear_maxJobsToActivate(&mut self) {
        self.maxJobsToActivate = 0;
    }

    // Param is passed by value, moved
    pub fn set_maxJobsToActivate(&mut self, v: i32) {
        self.maxJobsToActivate = v;
    }

    // repeated string fetchVariable = 5;


    pub fn get_fetchVariable(&self) -> &[::std::string::String] {
        &self.fetchVariable
    }
    pub fn clear_fetchVariable(&mut self) {
        self.fetchVariable.clear();
    }

    // Param is passed by value, moved
    pub fn set_fetchVariable(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
        self.fetchVariable = v;
    }

    // Mutable pointer to the field.
    pub fn mut_fetchVariable(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
        &mut self.fetchVariable
    }

    // Take field
    pub fn take_fetchVariable(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
        ::std::mem::replace(&mut self.fetchVariable, ::protobuf::RepeatedField::new())
    }

    // int64 requestTimeout = 6;


    pub fn get_requestTimeout(&self) -> i64 {
        self.requestTimeout
    }
    pub fn clear_requestTimeout(&mut self) {
        self.requestTimeout = 0;
    }

    // Param is passed by value, moved
    pub fn set_requestTimeout(&mut self, v: i64) {
        self.requestTimeout = v;
    }
}

impl ::protobuf::Message for ActivateJobsRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.field_type)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.worker)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.timeout = tmp;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.maxJobsToActivate = tmp;
                },
                5 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.fetchVariable)?;
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.requestTimeout = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.field_type.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.field_type);
        }
        if !self.worker.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.worker);
        }
        if self.timeout != 0 {
            my_size += ::protobuf::rt::value_size(3, self.timeout, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.maxJobsToActivate != 0 {
            my_size += ::protobuf::rt::value_size(4, self.maxJobsToActivate, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.fetchVariable {
            my_size += ::protobuf::rt::string_size(5, &value);
        };
        if self.requestTimeout != 0 {
            my_size += ::protobuf::rt::value_size(6, self.requestTimeout, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.field_type.is_empty() {
            os.write_string(1, &self.field_type)?;
        }
        if !self.worker.is_empty() {
            os.write_string(2, &self.worker)?;
        }
        if self.timeout != 0 {
            os.write_int64(3, self.timeout)?;
        }
        if self.maxJobsToActivate != 0 {
            os.write_int32(4, self.maxJobsToActivate)?;
        }
        for v in &self.fetchVariable {
            os.write_string(5, &v)?;
        };
        if self.requestTimeout != 0 {
            os.write_int64(6, self.requestTimeout)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ActivateJobsRequest {
        ActivateJobsRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "type",
                    |m: &ActivateJobsRequest| { &m.field_type },
                    |m: &mut ActivateJobsRequest| { &mut m.field_type },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "worker",
                    |m: &ActivateJobsRequest| { &m.worker },
                    |m: &mut ActivateJobsRequest| { &mut m.worker },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "timeout",
                    |m: &ActivateJobsRequest| { &m.timeout },
                    |m: &mut ActivateJobsRequest| { &mut m.timeout },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                    "maxJobsToActivate",
                    |m: &ActivateJobsRequest| { &m.maxJobsToActivate },
                    |m: &mut ActivateJobsRequest| { &mut m.maxJobsToActivate },
                ));
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "fetchVariable",
                    |m: &ActivateJobsRequest| { &m.fetchVariable },
                    |m: &mut ActivateJobsRequest| { &mut m.fetchVariable },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "requestTimeout",
                    |m: &ActivateJobsRequest| { &m.requestTimeout },
                    |m: &mut ActivateJobsRequest| { &mut m.requestTimeout },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ActivateJobsRequest>(
                    "ActivateJobsRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static ActivateJobsRequest {
        static mut instance: ::protobuf::lazy::Lazy<ActivateJobsRequest> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ActivateJobsRequest,
        };
        unsafe {
            instance.get(ActivateJobsRequest::new)
        }
    }
}

impl ::protobuf::Clear for ActivateJobsRequest {
    fn clear(&mut self) {
        self.field_type.clear();
        self.worker.clear();
        self.timeout = 0;
        self.maxJobsToActivate = 0;
        self.fetchVariable.clear();
        self.requestTimeout = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ActivateJobsRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ActivateJobsRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ActivateJobsResponse {
    // message fields
    pub jobs: ::protobuf::RepeatedField<ActivatedJob>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ActivateJobsResponse {
    fn default() -> &'a ActivateJobsResponse {
        <ActivateJobsResponse as ::protobuf::Message>::default_instance()
    }
}

impl ActivateJobsResponse {
    pub fn new() -> ActivateJobsResponse {
        ::std::default::Default::default()
    }

    // repeated .gateway_protocol.ActivatedJob jobs = 1;


    pub fn get_jobs(&self) -> &[ActivatedJob] {
        &self.jobs
    }
    pub fn clear_jobs(&mut self) {
        self.jobs.clear();
    }

    // Param is passed by value, moved
    pub fn set_jobs(&mut self, v: ::protobuf::RepeatedField<ActivatedJob>) {
        self.jobs = v;
    }

    // Mutable pointer to the field.
    pub fn mut_jobs(&mut self) -> &mut ::protobuf::RepeatedField<ActivatedJob> {
        &mut self.jobs
    }

    // Take field
    pub fn take_jobs(&mut self) -> ::protobuf::RepeatedField<ActivatedJob> {
        ::std::mem::replace(&mut self.jobs, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for ActivateJobsResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.jobs {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.jobs)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.jobs {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.jobs {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ActivateJobsResponse {
        ActivateJobsResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ActivatedJob>>(
                    "jobs",
                    |m: &ActivateJobsResponse| { &m.jobs },
                    |m: &mut ActivateJobsResponse| { &mut m.jobs },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ActivateJobsResponse>(
                    "ActivateJobsResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static ActivateJobsResponse {
        static mut instance: ::protobuf::lazy::Lazy<ActivateJobsResponse> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ActivateJobsResponse,
        };
        unsafe {
            instance.get(ActivateJobsResponse::new)
        }
    }
}

impl ::protobuf::Clear for ActivateJobsResponse {
    fn clear(&mut self) {
        self.jobs.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ActivateJobsResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ActivateJobsResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ActivatedJob {
    // message fields
    pub key: i64,
    pub field_type: ::std::string::String,
    pub workflowInstanceKey: i64,
    pub bpmnProcessId: ::std::string::String,
    pub workflowDefinitionVersion: i32,
    pub workflowKey: i64,
    pub elementId: ::std::string::String,
    pub elementInstanceKey: i64,
    pub customHeaders: ::std::string::String,
    pub worker: ::std::string::String,
    pub retries: i32,
    pub deadline: i64,
    pub variables: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ActivatedJob {
    fn default() -> &'a ActivatedJob {
        <ActivatedJob as ::protobuf::Message>::default_instance()
    }
}

impl ActivatedJob {
    pub fn new() -> ActivatedJob {
        ::std::default::Default::default()
    }

    // int64 key = 1;


    pub fn get_key(&self) -> i64 {
        self.key
    }
    pub fn clear_key(&mut self) {
        self.key = 0;
    }

    // Param is passed by value, moved
    pub fn set_key(&mut self, v: i64) {
        self.key = v;
    }

    // string type = 2;


    pub fn get_field_type(&self) -> &str {
        &self.field_type
    }
    pub fn clear_field_type(&mut self) {
        self.field_type.clear();
    }

    // Param is passed by value, moved
    pub fn set_field_type(&mut self, v: ::std::string::String) {
        self.field_type = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_field_type(&mut self) -> &mut ::std::string::String {
        &mut self.field_type
    }

    // Take field
    pub fn take_field_type(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.field_type, ::std::string::String::new())
    }

    // int64 workflowInstanceKey = 3;


    pub fn get_workflowInstanceKey(&self) -> i64 {
        self.workflowInstanceKey
    }
    pub fn clear_workflowInstanceKey(&mut self) {
        self.workflowInstanceKey = 0;
    }

    // Param is passed by value, moved
    pub fn set_workflowInstanceKey(&mut self, v: i64) {
        self.workflowInstanceKey = v;
    }

    // string bpmnProcessId = 4;


    pub fn get_bpmnProcessId(&self) -> &str {
        &self.bpmnProcessId
    }
    pub fn clear_bpmnProcessId(&mut self) {
        self.bpmnProcessId.clear();
    }

    // Param is passed by value, moved
    pub fn set_bpmnProcessId(&mut self, v: ::std::string::String) {
        self.bpmnProcessId = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_bpmnProcessId(&mut self) -> &mut ::std::string::String {
        &mut self.bpmnProcessId
    }

    // Take field
    pub fn take_bpmnProcessId(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.bpmnProcessId, ::std::string::String::new())
    }

    // int32 workflowDefinitionVersion = 5;


    pub fn get_workflowDefinitionVersion(&self) -> i32 {
        self.workflowDefinitionVersion
    }
    pub fn clear_workflowDefinitionVersion(&mut self) {
        self.workflowDefinitionVersion = 0;
    }

    // Param is passed by value, moved
    pub fn set_workflowDefinitionVersion(&mut self, v: i32) {
        self.workflowDefinitionVersion = v;
    }

    // int64 workflowKey = 6;


    pub fn get_workflowKey(&self) -> i64 {
        self.workflowKey
    }
    pub fn clear_workflowKey(&mut self) {
        self.workflowKey = 0;
    }

    // Param is passed by value, moved
    pub fn set_workflowKey(&mut self, v: i64) {
        self.workflowKey = v;
    }

    // string elementId = 7;


    pub fn get_elementId(&self) -> &str {
        &self.elementId
    }
    pub fn clear_elementId(&mut self) {
        self.elementId.clear();
    }

    // Param is passed by value, moved
    pub fn set_elementId(&mut self, v: ::std::string::String) {
        self.elementId = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_elementId(&mut self) -> &mut ::std::string::String {
        &mut self.elementId
    }

    // Take field
    pub fn take_elementId(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.elementId, ::std::string::String::new())
    }

    // int64 elementInstanceKey = 8;


    pub fn get_elementInstanceKey(&self) -> i64 {
        self.elementInstanceKey
    }
    pub fn clear_elementInstanceKey(&mut self) {
        self.elementInstanceKey = 0;
    }

    // Param is passed by value, moved
    pub fn set_elementInstanceKey(&mut self, v: i64) {
        self.elementInstanceKey = v;
    }

    // string customHeaders = 9;


    pub fn get_customHeaders(&self) -> &str {
        &self.customHeaders
    }
    pub fn clear_customHeaders(&mut self) {
        self.customHeaders.clear();
    }

    // Param is passed by value, moved
    pub fn set_customHeaders(&mut self, v: ::std::string::String) {
        self.customHeaders = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_customHeaders(&mut self) -> &mut ::std::string::String {
        &mut self.customHeaders
    }

    // Take field
    pub fn take_customHeaders(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.customHeaders, ::std::string::String::new())
    }

    // string worker = 10;


    pub fn get_worker(&self) -> &str {
        &self.worker
    }
    pub fn clear_worker(&mut self) {
        self.worker.clear();
    }

    // Param is passed by value, moved
    pub fn set_worker(&mut self, v: ::std::string::String) {
        self.worker = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_worker(&mut self) -> &mut ::std::string::String {
        &mut self.worker
    }

    // Take field
    pub fn take_worker(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.worker, ::std::string::String::new())
    }

    // int32 retries = 11;


    pub fn get_retries(&self) -> i32 {
        self.retries
    }
    pub fn clear_retries(&mut self) {
        self.retries = 0;
    }

    // Param is passed by value, moved
    pub fn set_retries(&mut self, v: i32) {
        self.retries = v;
    }

    // int64 deadline = 12;


    pub fn get_deadline(&self) -> i64 {
        self.deadline
    }
    pub fn clear_deadline(&mut self) {
        self.deadline = 0;
    }

    // Param is passed by value, moved
    pub fn set_deadline(&mut self, v: i64) {
        self.deadline = v;
    }

    // string variables = 13;


    pub fn get_variables(&self) -> &str {
        &self.variables
    }
    pub fn clear_variables(&mut self) {
        self.variables.clear();
    }

    // Param is passed by value, moved
    pub fn set_variables(&mut self, v: ::std::string::String) {
        self.variables = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_variables(&mut self) -> &mut ::std::string::String {
        &mut self.variables
    }

    // Take field
    pub fn take_variables(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.variables, ::std::string::String::new())
    }
}

impl ::protobuf::Message for ActivatedJob {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.key = tmp;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.field_type)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.workflowInstanceKey = tmp;
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.bpmnProcessId)?;
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.workflowDefinitionVersion = tmp;
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.workflowKey = tmp;
                },
                7 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.elementId)?;
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.elementInstanceKey = tmp;
                },
                9 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.customHeaders)?;
                },
                10 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.worker)?;
                },
                11 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.retries = tmp;
                },
                12 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.deadline = tmp;
                },
                13 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.variables)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.key != 0 {
            my_size += ::protobuf::rt::value_size(1, self.key, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.field_type.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.field_type);
        }
        if self.workflowInstanceKey != 0 {
            my_size += ::protobuf::rt::value_size(3, self.workflowInstanceKey, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.bpmnProcessId.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.bpmnProcessId);
        }
        if self.workflowDefinitionVersion != 0 {
            my_size += ::protobuf::rt::value_size(5, self.workflowDefinitionVersion, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.workflowKey != 0 {
            my_size += ::protobuf::rt::value_size(6, self.workflowKey, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.elementId.is_empty() {
            my_size += ::protobuf::rt::string_size(7, &self.elementId);
        }
        if self.elementInstanceKey != 0 {
            my_size += ::protobuf::rt::value_size(8, self.elementInstanceKey, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.customHeaders.is_empty() {
            my_size += ::protobuf::rt::string_size(9, &self.customHeaders);
        }
        if !self.worker.is_empty() {
            my_size += ::protobuf::rt::string_size(10, &self.worker);
        }
        if self.retries != 0 {
            my_size += ::protobuf::rt::value_size(11, self.retries, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.deadline != 0 {
            my_size += ::protobuf::rt::value_size(12, self.deadline, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.variables.is_empty() {
            my_size += ::protobuf::rt::string_size(13, &self.variables);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.key != 0 {
            os.write_int64(1, self.key)?;
        }
        if !self.field_type.is_empty() {
            os.write_string(2, &self.field_type)?;
        }
        if self.workflowInstanceKey != 0 {
            os.write_int64(3, self.workflowInstanceKey)?;
        }
        if !self.bpmnProcessId.is_empty() {
            os.write_string(4, &self.bpmnProcessId)?;
        }
        if self.workflowDefinitionVersion != 0 {
            os.write_int32(5, self.workflowDefinitionVersion)?;
        }
        if self.workflowKey != 0 {
            os.write_int64(6, self.workflowKey)?;
        }
        if !self.elementId.is_empty() {
            os.write_string(7, &self.elementId)?;
        }
        if self.elementInstanceKey != 0 {
            os.write_int64(8, self.elementInstanceKey)?;
        }
        if !self.customHeaders.is_empty() {
            os.write_string(9, &self.customHeaders)?;
        }
        if !self.worker.is_empty() {
            os.write_string(10, &self.worker)?;
        }
        if self.retries != 0 {
            os.write_int32(11, self.retries)?;
        }
        if self.deadline != 0 {
            os.write_int64(12, self.deadline)?;
        }
        if !self.variables.is_empty() {
            os.write_string(13, &self.variables)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ActivatedJob {
        ActivatedJob::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "key",
                    |m: &ActivatedJob| { &m.key },
                    |m: &mut ActivatedJob| { &mut m.key },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "type",
                    |m: &ActivatedJob| { &m.field_type },
                    |m: &mut ActivatedJob| { &mut m.field_type },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "workflowInstanceKey",
                    |m: &ActivatedJob| { &m.workflowInstanceKey },
                    |m: &mut ActivatedJob| { &mut m.workflowInstanceKey },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "bpmnProcessId",
                    |m: &ActivatedJob| { &m.bpmnProcessId },
                    |m: &mut ActivatedJob| { &mut m.bpmnProcessId },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                    "workflowDefinitionVersion",
                    |m: &ActivatedJob| { &m.workflowDefinitionVersion },
                    |m: &mut ActivatedJob| { &mut m.workflowDefinitionVersion },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "workflowKey",
                    |m: &ActivatedJob| { &m.workflowKey },
                    |m: &mut ActivatedJob| { &mut m.workflowKey },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "elementId",
                    |m: &ActivatedJob| { &m.elementId },
                    |m: &mut ActivatedJob| { &mut m.elementId },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "elementInstanceKey",
                    |m: &ActivatedJob| { &m.elementInstanceKey },
                    |m: &mut ActivatedJob| { &mut m.elementInstanceKey },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "customHeaders",
                    |m: &ActivatedJob| { &m.customHeaders },
                    |m: &mut ActivatedJob| { &mut m.customHeaders },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "worker",
                    |m: &ActivatedJob| { &m.worker },
                    |m: &mut ActivatedJob| { &mut m.worker },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                    "retries",
                    |m: &ActivatedJob| { &m.retries },
                    |m: &mut ActivatedJob| { &mut m.retries },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "deadline",
                    |m: &ActivatedJob| { &m.deadline },
                    |m: &mut ActivatedJob| { &mut m.deadline },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "variables",
                    |m: &ActivatedJob| { &m.variables },
                    |m: &mut ActivatedJob| { &mut m.variables },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ActivatedJob>(
                    "ActivatedJob",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static ActivatedJob {
        static mut instance: ::protobuf::lazy::Lazy<ActivatedJob> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ActivatedJob,
        };
        unsafe {
            instance.get(ActivatedJob::new)
        }
    }
}

impl ::protobuf::Clear for ActivatedJob {
    fn clear(&mut self) {
        self.key = 0;
        self.field_type.clear();
        self.workflowInstanceKey = 0;
        self.bpmnProcessId.clear();
        self.workflowDefinitionVersion = 0;
        self.workflowKey = 0;
        self.elementId.clear();
        self.elementInstanceKey = 0;
        self.customHeaders.clear();
        self.worker.clear();
        self.retries = 0;
        self.deadline = 0;
        self.variables.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ActivatedJob {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ActivatedJob {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CancelWorkflowInstanceRequest {
    // message fields
    pub workflowInstanceKey: i64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CancelWorkflowInstanceRequest {
    fn default() -> &'a CancelWorkflowInstanceRequest {
        <CancelWorkflowInstanceRequest as ::protobuf::Message>::default_instance()
    }
}

impl CancelWorkflowInstanceRequest {
    pub fn new() -> CancelWorkflowInstanceRequest {
        ::std::default::Default::default()
    }

    // int64 workflowInstanceKey = 1;


    pub fn get_workflowInstanceKey(&self) -> i64 {
        self.workflowInstanceKey
    }
    pub fn clear_workflowInstanceKey(&mut self) {
        self.workflowInstanceKey = 0;
    }

    // Param is passed by value, moved
    pub fn set_workflowInstanceKey(&mut self, v: i64) {
        self.workflowInstanceKey = v;
    }
}

impl ::protobuf::Message for CancelWorkflowInstanceRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.workflowInstanceKey = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.workflowInstanceKey != 0 {
            my_size += ::protobuf::rt::value_size(1, self.workflowInstanceKey, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.workflowInstanceKey != 0 {
            os.write_int64(1, self.workflowInstanceKey)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CancelWorkflowInstanceRequest {
        CancelWorkflowInstanceRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "workflowInstanceKey",
                    |m: &CancelWorkflowInstanceRequest| { &m.workflowInstanceKey },
                    |m: &mut CancelWorkflowInstanceRequest| { &mut m.workflowInstanceKey },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<CancelWorkflowInstanceRequest>(
                    "CancelWorkflowInstanceRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static CancelWorkflowInstanceRequest {
        static mut instance: ::protobuf::lazy::Lazy<CancelWorkflowInstanceRequest> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const CancelWorkflowInstanceRequest,
        };
        unsafe {
            instance.get(CancelWorkflowInstanceRequest::new)
        }
    }
}

impl ::protobuf::Clear for CancelWorkflowInstanceRequest {
    fn clear(&mut self) {
        self.workflowInstanceKey = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CancelWorkflowInstanceRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CancelWorkflowInstanceRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CancelWorkflowInstanceResponse {
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CancelWorkflowInstanceResponse {
    fn default() -> &'a CancelWorkflowInstanceResponse {
        <CancelWorkflowInstanceResponse as ::protobuf::Message>::default_instance()
    }
}

impl CancelWorkflowInstanceResponse {
    pub fn new() -> CancelWorkflowInstanceResponse {
        ::std::default::Default::default()
    }
}

impl ::protobuf::Message for CancelWorkflowInstanceResponse {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CancelWorkflowInstanceResponse {
        CancelWorkflowInstanceResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let fields = ::std::vec::Vec::new();
                ::protobuf::reflect::MessageDescriptor::new::<CancelWorkflowInstanceResponse>(
                    "CancelWorkflowInstanceResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static CancelWorkflowInstanceResponse {
        static mut instance: ::protobuf::lazy::Lazy<CancelWorkflowInstanceResponse> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const CancelWorkflowInstanceResponse,
        };
        unsafe {
            instance.get(CancelWorkflowInstanceResponse::new)
        }
    }
}

impl ::protobuf::Clear for CancelWorkflowInstanceResponse {
    fn clear(&mut self) {
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CancelWorkflowInstanceResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CancelWorkflowInstanceResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CompleteJobRequest {
    // message fields
    pub jobKey: i64,
    pub variables: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CompleteJobRequest {
    fn default() -> &'a CompleteJobRequest {
        <CompleteJobRequest as ::protobuf::Message>::default_instance()
    }
}

impl CompleteJobRequest {
    pub fn new() -> CompleteJobRequest {
        ::std::default::Default::default()
    }

    // int64 jobKey = 1;


    pub fn get_jobKey(&self) -> i64 {
        self.jobKey
    }
    pub fn clear_jobKey(&mut self) {
        self.jobKey = 0;
    }

    // Param is passed by value, moved
    pub fn set_jobKey(&mut self, v: i64) {
        self.jobKey = v;
    }

    // string variables = 2;


    pub fn get_variables(&self) -> &str {
        &self.variables
    }
    pub fn clear_variables(&mut self) {
        self.variables.clear();
    }

    // Param is passed by value, moved
    pub fn set_variables(&mut self, v: ::std::string::String) {
        self.variables = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_variables(&mut self) -> &mut ::std::string::String {
        &mut self.variables
    }

    // Take field
    pub fn take_variables(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.variables, ::std::string::String::new())
    }
}

impl ::protobuf::Message for CompleteJobRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.jobKey = tmp;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.variables)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.jobKey != 0 {
            my_size += ::protobuf::rt::value_size(1, self.jobKey, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.variables.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.variables);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.jobKey != 0 {
            os.write_int64(1, self.jobKey)?;
        }
        if !self.variables.is_empty() {
            os.write_string(2, &self.variables)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CompleteJobRequest {
        CompleteJobRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "jobKey",
                    |m: &CompleteJobRequest| { &m.jobKey },
                    |m: &mut CompleteJobRequest| { &mut m.jobKey },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "variables",
                    |m: &CompleteJobRequest| { &m.variables },
                    |m: &mut CompleteJobRequest| { &mut m.variables },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<CompleteJobRequest>(
                    "CompleteJobRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static CompleteJobRequest {
        static mut instance: ::protobuf::lazy::Lazy<CompleteJobRequest> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const CompleteJobRequest,
        };
        unsafe {
            instance.get(CompleteJobRequest::new)
        }
    }
}

impl ::protobuf::Clear for CompleteJobRequest {
    fn clear(&mut self) {
        self.jobKey = 0;
        self.variables.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CompleteJobRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CompleteJobRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CompleteJobResponse {
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CompleteJobResponse {
    fn default() -> &'a CompleteJobResponse {
        <CompleteJobResponse as ::protobuf::Message>::default_instance()
    }
}

impl CompleteJobResponse {
    pub fn new() -> CompleteJobResponse {
        ::std::default::Default::default()
    }
}

impl ::protobuf::Message for CompleteJobResponse {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CompleteJobResponse {
        CompleteJobResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let fields = ::std::vec::Vec::new();
                ::protobuf::reflect::MessageDescriptor::new::<CompleteJobResponse>(
                    "CompleteJobResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static CompleteJobResponse {
        static mut instance: ::protobuf::lazy::Lazy<CompleteJobResponse> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const CompleteJobResponse,
        };
        unsafe {
            instance.get(CompleteJobResponse::new)
        }
    }
}

impl ::protobuf::Clear for CompleteJobResponse {
    fn clear(&mut self) {
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CompleteJobResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CompleteJobResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CreateWorkflowInstanceRequest {
    // message fields
    pub workflowKey: i64,
    pub bpmnProcessId: ::std::string::String,
    pub version: i32,
    pub variables: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CreateWorkflowInstanceRequest {
    fn default() -> &'a CreateWorkflowInstanceRequest {
        <CreateWorkflowInstanceRequest as ::protobuf::Message>::default_instance()
    }
}

impl CreateWorkflowInstanceRequest {
    pub fn new() -> CreateWorkflowInstanceRequest {
        ::std::default::Default::default()
    }

    // int64 workflowKey = 1;


    pub fn get_workflowKey(&self) -> i64 {
        self.workflowKey
    }
    pub fn clear_workflowKey(&mut self) {
        self.workflowKey = 0;
    }

    // Param is passed by value, moved
    pub fn set_workflowKey(&mut self, v: i64) {
        self.workflowKey = v;
    }

    // string bpmnProcessId = 2;


    pub fn get_bpmnProcessId(&self) -> &str {
        &self.bpmnProcessId
    }
    pub fn clear_bpmnProcessId(&mut self) {
        self.bpmnProcessId.clear();
    }

    // Param is passed by value, moved
    pub fn set_bpmnProcessId(&mut self, v: ::std::string::String) {
        self.bpmnProcessId = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_bpmnProcessId(&mut self) -> &mut ::std::string::String {
        &mut self.bpmnProcessId
    }

    // Take field
    pub fn take_bpmnProcessId(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.bpmnProcessId, ::std::string::String::new())
    }

    // int32 version = 3;


    pub fn get_version(&self) -> i32 {
        self.version
    }
    pub fn clear_version(&mut self) {
        self.version = 0;
    }

    // Param is passed by value, moved
    pub fn set_version(&mut self, v: i32) {
        self.version = v;
    }

    // string variables = 4;


    pub fn get_variables(&self) -> &str {
        &self.variables
    }
    pub fn clear_variables(&mut self) {
        self.variables.clear();
    }

    // Param is passed by value, moved
    pub fn set_variables(&mut self, v: ::std::string::String) {
        self.variables = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_variables(&mut self) -> &mut ::std::string::String {
        &mut self.variables
    }

    // Take field
    pub fn take_variables(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.variables, ::std::string::String::new())
    }
}

impl ::protobuf::Message for CreateWorkflowInstanceRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.workflowKey = tmp;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.bpmnProcessId)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.version = tmp;
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.variables)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.workflowKey != 0 {
            my_size += ::protobuf::rt::value_size(1, self.workflowKey, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.bpmnProcessId.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.bpmnProcessId);
        }
        if self.version != 0 {
            my_size += ::protobuf::rt::value_size(3, self.version, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.variables.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.variables);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.workflowKey != 0 {
            os.write_int64(1, self.workflowKey)?;
        }
        if !self.bpmnProcessId.is_empty() {
            os.write_string(2, &self.bpmnProcessId)?;
        }
        if self.version != 0 {
            os.write_int32(3, self.version)?;
        }
        if !self.variables.is_empty() {
            os.write_string(4, &self.variables)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CreateWorkflowInstanceRequest {
        CreateWorkflowInstanceRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "workflowKey",
                    |m: &CreateWorkflowInstanceRequest| { &m.workflowKey },
                    |m: &mut CreateWorkflowInstanceRequest| { &mut m.workflowKey },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "bpmnProcessId",
                    |m: &CreateWorkflowInstanceRequest| { &m.bpmnProcessId },
                    |m: &mut CreateWorkflowInstanceRequest| { &mut m.bpmnProcessId },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                    "version",
                    |m: &CreateWorkflowInstanceRequest| { &m.version },
                    |m: &mut CreateWorkflowInstanceRequest| { &mut m.version },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "variables",
                    |m: &CreateWorkflowInstanceRequest| { &m.variables },
                    |m: &mut CreateWorkflowInstanceRequest| { &mut m.variables },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<CreateWorkflowInstanceRequest>(
                    "CreateWorkflowInstanceRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static CreateWorkflowInstanceRequest {
        static mut instance: ::protobuf::lazy::Lazy<CreateWorkflowInstanceRequest> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const CreateWorkflowInstanceRequest,
        };
        unsafe {
            instance.get(CreateWorkflowInstanceRequest::new)
        }
    }
}

impl ::protobuf::Clear for CreateWorkflowInstanceRequest {
    fn clear(&mut self) {
        self.workflowKey = 0;
        self.bpmnProcessId.clear();
        self.version = 0;
        self.variables.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CreateWorkflowInstanceRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CreateWorkflowInstanceRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CreateWorkflowInstanceResponse {
    // message fields
    pub workflowKey: i64,
    pub bpmnProcessId: ::std::string::String,
    pub version: i32,
    pub workflowInstanceKey: i64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CreateWorkflowInstanceResponse {
    fn default() -> &'a CreateWorkflowInstanceResponse {
        <CreateWorkflowInstanceResponse as ::protobuf::Message>::default_instance()
    }
}

impl CreateWorkflowInstanceResponse {
    pub fn new() -> CreateWorkflowInstanceResponse {
        ::std::default::Default::default()
    }

    // int64 workflowKey = 1;


    pub fn get_workflowKey(&self) -> i64 {
        self.workflowKey
    }
    pub fn clear_workflowKey(&mut self) {
        self.workflowKey = 0;
    }

    // Param is passed by value, moved
    pub fn set_workflowKey(&mut self, v: i64) {
        self.workflowKey = v;
    }

    // string bpmnProcessId = 2;


    pub fn get_bpmnProcessId(&self) -> &str {
        &self.bpmnProcessId
    }
    pub fn clear_bpmnProcessId(&mut self) {
        self.bpmnProcessId.clear();
    }

    // Param is passed by value, moved
    pub fn set_bpmnProcessId(&mut self, v: ::std::string::String) {
        self.bpmnProcessId = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_bpmnProcessId(&mut self) -> &mut ::std::string::String {
        &mut self.bpmnProcessId
    }

    // Take field
    pub fn take_bpmnProcessId(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.bpmnProcessId, ::std::string::String::new())
    }

    // int32 version = 3;


    pub fn get_version(&self) -> i32 {
        self.version
    }
    pub fn clear_version(&mut self) {
        self.version = 0;
    }

    // Param is passed by value, moved
    pub fn set_version(&mut self, v: i32) {
        self.version = v;
    }

    // int64 workflowInstanceKey = 4;


    pub fn get_workflowInstanceKey(&self) -> i64 {
        self.workflowInstanceKey
    }
    pub fn clear_workflowInstanceKey(&mut self) {
        self.workflowInstanceKey = 0;
    }

    // Param is passed by value, moved
    pub fn set_workflowInstanceKey(&mut self, v: i64) {
        self.workflowInstanceKey = v;
    }
}

impl ::protobuf::Message for CreateWorkflowInstanceResponse {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.workflowKey = tmp;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.bpmnProcessId)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.version = tmp;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.workflowInstanceKey = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.workflowKey != 0 {
            my_size += ::protobuf::rt::value_size(1, self.workflowKey, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.bpmnProcessId.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.bpmnProcessId);
        }
        if self.version != 0 {
            my_size += ::protobuf::rt::value_size(3, self.version, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.workflowInstanceKey != 0 {
            my_size += ::protobuf::rt::value_size(4, self.workflowInstanceKey, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.workflowKey != 0 {
            os.write_int64(1, self.workflowKey)?;
        }
        if !self.bpmnProcessId.is_empty() {
            os.write_string(2, &self.bpmnProcessId)?;
        }
        if self.version != 0 {
            os.write_int32(3, self.version)?;
        }
        if self.workflowInstanceKey != 0 {
            os.write_int64(4, self.workflowInstanceKey)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CreateWorkflowInstanceResponse {
        CreateWorkflowInstanceResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "workflowKey",
                    |m: &CreateWorkflowInstanceResponse| { &m.workflowKey },
                    |m: &mut CreateWorkflowInstanceResponse| { &mut m.workflowKey },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "bpmnProcessId",
                    |m: &CreateWorkflowInstanceResponse| { &m.bpmnProcessId },
                    |m: &mut CreateWorkflowInstanceResponse| { &mut m.bpmnProcessId },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                    "version",
                    |m: &CreateWorkflowInstanceResponse| { &m.version },
                    |m: &mut CreateWorkflowInstanceResponse| { &mut m.version },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "workflowInstanceKey",
                    |m: &CreateWorkflowInstanceResponse| { &m.workflowInstanceKey },
                    |m: &mut CreateWorkflowInstanceResponse| { &mut m.workflowInstanceKey },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<CreateWorkflowInstanceResponse>(
                    "CreateWorkflowInstanceResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static CreateWorkflowInstanceResponse {
        static mut instance: ::protobuf::lazy::Lazy<CreateWorkflowInstanceResponse> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const CreateWorkflowInstanceResponse,
        };
        unsafe {
            instance.get(CreateWorkflowInstanceResponse::new)
        }
    }
}

impl ::protobuf::Clear for CreateWorkflowInstanceResponse {
    fn clear(&mut self) {
        self.workflowKey = 0;
        self.bpmnProcessId.clear();
        self.version = 0;
        self.workflowInstanceKey = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CreateWorkflowInstanceResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CreateWorkflowInstanceResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct DeployWorkflowRequest {
    // message fields
    pub workflows: ::protobuf::RepeatedField<WorkflowRequestObject>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a DeployWorkflowRequest {
    fn default() -> &'a DeployWorkflowRequest {
        <DeployWorkflowRequest as ::protobuf::Message>::default_instance()
    }
}

impl DeployWorkflowRequest {
    pub fn new() -> DeployWorkflowRequest {
        ::std::default::Default::default()
    }

    // repeated .gateway_protocol.WorkflowRequestObject workflows = 1;


    pub fn get_workflows(&self) -> &[WorkflowRequestObject] {
        &self.workflows
    }
    pub fn clear_workflows(&mut self) {
        self.workflows.clear();
    }

    // Param is passed by value, moved
    pub fn set_workflows(&mut self, v: ::protobuf::RepeatedField<WorkflowRequestObject>) {
        self.workflows = v;
    }

    // Mutable pointer to the field.
    pub fn mut_workflows(&mut self) -> &mut ::protobuf::RepeatedField<WorkflowRequestObject> {
        &mut self.workflows
    }

    // Take field
    pub fn take_workflows(&mut self) -> ::protobuf::RepeatedField<WorkflowRequestObject> {
        ::std::mem::replace(&mut self.workflows, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for DeployWorkflowRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.workflows {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.workflows)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.workflows {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.workflows {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> DeployWorkflowRequest {
        DeployWorkflowRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<WorkflowRequestObject>>(
                    "workflows",
                    |m: &DeployWorkflowRequest| { &m.workflows },
                    |m: &mut DeployWorkflowRequest| { &mut m.workflows },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<DeployWorkflowRequest>(
                    "DeployWorkflowRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static DeployWorkflowRequest {
        static mut instance: ::protobuf::lazy::Lazy<DeployWorkflowRequest> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const DeployWorkflowRequest,
        };
        unsafe {
            instance.get(DeployWorkflowRequest::new)
        }
    }
}

impl ::protobuf::Clear for DeployWorkflowRequest {
    fn clear(&mut self) {
        self.workflows.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for DeployWorkflowRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for DeployWorkflowRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct WorkflowRequestObject {
    // message fields
    pub name: ::std::string::String,
    pub field_type: WorkflowRequestObject_ResourceType,
    pub definition: ::std::vec::Vec<u8>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a WorkflowRequestObject {
    fn default() -> &'a WorkflowRequestObject {
        <WorkflowRequestObject as ::protobuf::Message>::default_instance()
    }
}

impl WorkflowRequestObject {
    pub fn new() -> WorkflowRequestObject {
        ::std::default::Default::default()
    }

    // string name = 1;


    pub fn get_name(&self) -> &str {
        &self.name
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.name = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_name(&mut self) -> &mut ::std::string::String {
        &mut self.name
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.name, ::std::string::String::new())
    }

    // .gateway_protocol.WorkflowRequestObject.ResourceType type = 2;


    pub fn get_field_type(&self) -> WorkflowRequestObject_ResourceType {
        self.field_type
    }
    pub fn clear_field_type(&mut self) {
        self.field_type = WorkflowRequestObject_ResourceType::FILE;
    }

    // Param is passed by value, moved
    pub fn set_field_type(&mut self, v: WorkflowRequestObject_ResourceType) {
        self.field_type = v;
    }

    // bytes definition = 3;


    pub fn get_definition(&self) -> &[u8] {
        &self.definition
    }
    pub fn clear_definition(&mut self) {
        self.definition.clear();
    }

    // Param is passed by value, moved
    pub fn set_definition(&mut self, v: ::std::vec::Vec<u8>) {
        self.definition = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_definition(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.definition
    }

    // Take field
    pub fn take_definition(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.definition, ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for WorkflowRequestObject {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                },
                2 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.field_type, 2, &mut self.unknown_fields)?
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.definition)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if self.field_type != WorkflowRequestObject_ResourceType::FILE {
            my_size += ::protobuf::rt::enum_size(2, self.field_type);
        }
        if !self.definition.is_empty() {
            my_size += ::protobuf::rt::bytes_size(3, &self.definition);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if self.field_type != WorkflowRequestObject_ResourceType::FILE {
            os.write_enum(2, self.field_type.value())?;
        }
        if !self.definition.is_empty() {
            os.write_bytes(3, &self.definition)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> WorkflowRequestObject {
        WorkflowRequestObject::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "name",
                    |m: &WorkflowRequestObject| { &m.name },
                    |m: &mut WorkflowRequestObject| { &mut m.name },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<WorkflowRequestObject_ResourceType>>(
                    "type",
                    |m: &WorkflowRequestObject| { &m.field_type },
                    |m: &mut WorkflowRequestObject| { &mut m.field_type },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                    "definition",
                    |m: &WorkflowRequestObject| { &m.definition },
                    |m: &mut WorkflowRequestObject| { &mut m.definition },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<WorkflowRequestObject>(
                    "WorkflowRequestObject",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static WorkflowRequestObject {
        static mut instance: ::protobuf::lazy::Lazy<WorkflowRequestObject> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const WorkflowRequestObject,
        };
        unsafe {
            instance.get(WorkflowRequestObject::new)
        }
    }
}

impl ::protobuf::Clear for WorkflowRequestObject {
    fn clear(&mut self) {
        self.name.clear();
        self.field_type = WorkflowRequestObject_ResourceType::FILE;
        self.definition.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for WorkflowRequestObject {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for WorkflowRequestObject {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum WorkflowRequestObject_ResourceType {
    FILE = 0,
    BPMN = 1,
    YAML = 2,
}

impl ::protobuf::ProtobufEnum for WorkflowRequestObject_ResourceType {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<WorkflowRequestObject_ResourceType> {
        match value {
            0 => ::std::option::Option::Some(WorkflowRequestObject_ResourceType::FILE),
            1 => ::std::option::Option::Some(WorkflowRequestObject_ResourceType::BPMN),
            2 => ::std::option::Option::Some(WorkflowRequestObject_ResourceType::YAML),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [WorkflowRequestObject_ResourceType] = &[
            WorkflowRequestObject_ResourceType::FILE,
            WorkflowRequestObject_ResourceType::BPMN,
            WorkflowRequestObject_ResourceType::YAML,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::EnumDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                ::protobuf::reflect::EnumDescriptor::new("WorkflowRequestObject_ResourceType", file_descriptor_proto())
            })
        }
    }
}

impl ::std::marker::Copy for WorkflowRequestObject_ResourceType {
}

impl ::std::default::Default for WorkflowRequestObject_ResourceType {
    fn default() -> Self {
        WorkflowRequestObject_ResourceType::FILE
    }
}

impl ::protobuf::reflect::ProtobufValue for WorkflowRequestObject_ResourceType {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct DeployWorkflowResponse {
    // message fields
    pub key: i64,
    pub workflows: ::protobuf::RepeatedField<WorkflowMetadata>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a DeployWorkflowResponse {
    fn default() -> &'a DeployWorkflowResponse {
        <DeployWorkflowResponse as ::protobuf::Message>::default_instance()
    }
}

impl DeployWorkflowResponse {
    pub fn new() -> DeployWorkflowResponse {
        ::std::default::Default::default()
    }

    // int64 key = 1;


    pub fn get_key(&self) -> i64 {
        self.key
    }
    pub fn clear_key(&mut self) {
        self.key = 0;
    }

    // Param is passed by value, moved
    pub fn set_key(&mut self, v: i64) {
        self.key = v;
    }

    // repeated .gateway_protocol.WorkflowMetadata workflows = 2;


    pub fn get_workflows(&self) -> &[WorkflowMetadata] {
        &self.workflows
    }
    pub fn clear_workflows(&mut self) {
        self.workflows.clear();
    }

    // Param is passed by value, moved
    pub fn set_workflows(&mut self, v: ::protobuf::RepeatedField<WorkflowMetadata>) {
        self.workflows = v;
    }

    // Mutable pointer to the field.
    pub fn mut_workflows(&mut self) -> &mut ::protobuf::RepeatedField<WorkflowMetadata> {
        &mut self.workflows
    }

    // Take field
    pub fn take_workflows(&mut self) -> ::protobuf::RepeatedField<WorkflowMetadata> {
        ::std::mem::replace(&mut self.workflows, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for DeployWorkflowResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.workflows {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.key = tmp;
                },
                2 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.workflows)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.key != 0 {
            my_size += ::protobuf::rt::value_size(1, self.key, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.workflows {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.key != 0 {
            os.write_int64(1, self.key)?;
        }
        for v in &self.workflows {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> DeployWorkflowResponse {
        DeployWorkflowResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "key",
                    |m: &DeployWorkflowResponse| { &m.key },
                    |m: &mut DeployWorkflowResponse| { &mut m.key },
                ));
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<WorkflowMetadata>>(
                    "workflows",
                    |m: &DeployWorkflowResponse| { &m.workflows },
                    |m: &mut DeployWorkflowResponse| { &mut m.workflows },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<DeployWorkflowResponse>(
                    "DeployWorkflowResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static DeployWorkflowResponse {
        static mut instance: ::protobuf::lazy::Lazy<DeployWorkflowResponse> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const DeployWorkflowResponse,
        };
        unsafe {
            instance.get(DeployWorkflowResponse::new)
        }
    }
}

impl ::protobuf::Clear for DeployWorkflowResponse {
    fn clear(&mut self) {
        self.key = 0;
        self.workflows.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for DeployWorkflowResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for DeployWorkflowResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct WorkflowMetadata {
    // message fields
    pub bpmnProcessId: ::std::string::String,
    pub version: i32,
    pub workflowKey: i64,
    pub resourceName: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a WorkflowMetadata {
    fn default() -> &'a WorkflowMetadata {
        <WorkflowMetadata as ::protobuf::Message>::default_instance()
    }
}

impl WorkflowMetadata {
    pub fn new() -> WorkflowMetadata {
        ::std::default::Default::default()
    }

    // string bpmnProcessId = 1;


    pub fn get_bpmnProcessId(&self) -> &str {
        &self.bpmnProcessId
    }
    pub fn clear_bpmnProcessId(&mut self) {
        self.bpmnProcessId.clear();
    }

    // Param is passed by value, moved
    pub fn set_bpmnProcessId(&mut self, v: ::std::string::String) {
        self.bpmnProcessId = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_bpmnProcessId(&mut self) -> &mut ::std::string::String {
        &mut self.bpmnProcessId
    }

    // Take field
    pub fn take_bpmnProcessId(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.bpmnProcessId, ::std::string::String::new())
    }

    // int32 version = 2;


    pub fn get_version(&self) -> i32 {
        self.version
    }
    pub fn clear_version(&mut self) {
        self.version = 0;
    }

    // Param is passed by value, moved
    pub fn set_version(&mut self, v: i32) {
        self.version = v;
    }

    // int64 workflowKey = 3;


    pub fn get_workflowKey(&self) -> i64 {
        self.workflowKey
    }
    pub fn clear_workflowKey(&mut self) {
        self.workflowKey = 0;
    }

    // Param is passed by value, moved
    pub fn set_workflowKey(&mut self, v: i64) {
        self.workflowKey = v;
    }

    // string resourceName = 4;


    pub fn get_resourceName(&self) -> &str {
        &self.resourceName
    }
    pub fn clear_resourceName(&mut self) {
        self.resourceName.clear();
    }

    // Param is passed by value, moved
    pub fn set_resourceName(&mut self, v: ::std::string::String) {
        self.resourceName = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_resourceName(&mut self) -> &mut ::std::string::String {
        &mut self.resourceName
    }

    // Take field
    pub fn take_resourceName(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.resourceName, ::std::string::String::new())
    }
}

impl ::protobuf::Message for WorkflowMetadata {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.bpmnProcessId)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.version = tmp;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.workflowKey = tmp;
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.resourceName)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.bpmnProcessId.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.bpmnProcessId);
        }
        if self.version != 0 {
            my_size += ::protobuf::rt::value_size(2, self.version, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.workflowKey != 0 {
            my_size += ::protobuf::rt::value_size(3, self.workflowKey, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.resourceName.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.resourceName);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.bpmnProcessId.is_empty() {
            os.write_string(1, &self.bpmnProcessId)?;
        }
        if self.version != 0 {
            os.write_int32(2, self.version)?;
        }
        if self.workflowKey != 0 {
            os.write_int64(3, self.workflowKey)?;
        }
        if !self.resourceName.is_empty() {
            os.write_string(4, &self.resourceName)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> WorkflowMetadata {
        WorkflowMetadata::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "bpmnProcessId",
                    |m: &WorkflowMetadata| { &m.bpmnProcessId },
                    |m: &mut WorkflowMetadata| { &mut m.bpmnProcessId },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                    "version",
                    |m: &WorkflowMetadata| { &m.version },
                    |m: &mut WorkflowMetadata| { &mut m.version },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "workflowKey",
                    |m: &WorkflowMetadata| { &m.workflowKey },
                    |m: &mut WorkflowMetadata| { &mut m.workflowKey },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "resourceName",
                    |m: &WorkflowMetadata| { &m.resourceName },
                    |m: &mut WorkflowMetadata| { &mut m.resourceName },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<WorkflowMetadata>(
                    "WorkflowMetadata",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static WorkflowMetadata {
        static mut instance: ::protobuf::lazy::Lazy<WorkflowMetadata> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const WorkflowMetadata,
        };
        unsafe {
            instance.get(WorkflowMetadata::new)
        }
    }
}

impl ::protobuf::Clear for WorkflowMetadata {
    fn clear(&mut self) {
        self.bpmnProcessId.clear();
        self.version = 0;
        self.workflowKey = 0;
        self.resourceName.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for WorkflowMetadata {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for WorkflowMetadata {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct FailJobRequest {
    // message fields
    pub jobKey: i64,
    pub retries: i32,
    pub errorMessage: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a FailJobRequest {
    fn default() -> &'a FailJobRequest {
        <FailJobRequest as ::protobuf::Message>::default_instance()
    }
}

impl FailJobRequest {
    pub fn new() -> FailJobRequest {
        ::std::default::Default::default()
    }

    // int64 jobKey = 1;


    pub fn get_jobKey(&self) -> i64 {
        self.jobKey
    }
    pub fn clear_jobKey(&mut self) {
        self.jobKey = 0;
    }

    // Param is passed by value, moved
    pub fn set_jobKey(&mut self, v: i64) {
        self.jobKey = v;
    }

    // int32 retries = 2;


    pub fn get_retries(&self) -> i32 {
        self.retries
    }
    pub fn clear_retries(&mut self) {
        self.retries = 0;
    }

    // Param is passed by value, moved
    pub fn set_retries(&mut self, v: i32) {
        self.retries = v;
    }

    // string errorMessage = 3;


    pub fn get_errorMessage(&self) -> &str {
        &self.errorMessage
    }
    pub fn clear_errorMessage(&mut self) {
        self.errorMessage.clear();
    }

    // Param is passed by value, moved
    pub fn set_errorMessage(&mut self, v: ::std::string::String) {
        self.errorMessage = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_errorMessage(&mut self) -> &mut ::std::string::String {
        &mut self.errorMessage
    }

    // Take field
    pub fn take_errorMessage(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.errorMessage, ::std::string::String::new())
    }
}

impl ::protobuf::Message for FailJobRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.jobKey = tmp;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.retries = tmp;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.errorMessage)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.jobKey != 0 {
            my_size += ::protobuf::rt::value_size(1, self.jobKey, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.retries != 0 {
            my_size += ::protobuf::rt::value_size(2, self.retries, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.errorMessage.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.errorMessage);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.jobKey != 0 {
            os.write_int64(1, self.jobKey)?;
        }
        if self.retries != 0 {
            os.write_int32(2, self.retries)?;
        }
        if !self.errorMessage.is_empty() {
            os.write_string(3, &self.errorMessage)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> FailJobRequest {
        FailJobRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "jobKey",
                    |m: &FailJobRequest| { &m.jobKey },
                    |m: &mut FailJobRequest| { &mut m.jobKey },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                    "retries",
                    |m: &FailJobRequest| { &m.retries },
                    |m: &mut FailJobRequest| { &mut m.retries },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "errorMessage",
                    |m: &FailJobRequest| { &m.errorMessage },
                    |m: &mut FailJobRequest| { &mut m.errorMessage },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<FailJobRequest>(
                    "FailJobRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static FailJobRequest {
        static mut instance: ::protobuf::lazy::Lazy<FailJobRequest> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const FailJobRequest,
        };
        unsafe {
            instance.get(FailJobRequest::new)
        }
    }
}

impl ::protobuf::Clear for FailJobRequest {
    fn clear(&mut self) {
        self.jobKey = 0;
        self.retries = 0;
        self.errorMessage.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for FailJobRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for FailJobRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct FailJobResponse {
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a FailJobResponse {
    fn default() -> &'a FailJobResponse {
        <FailJobResponse as ::protobuf::Message>::default_instance()
    }
}

impl FailJobResponse {
    pub fn new() -> FailJobResponse {
        ::std::default::Default::default()
    }
}

impl ::protobuf::Message for FailJobResponse {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> FailJobResponse {
        FailJobResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let fields = ::std::vec::Vec::new();
                ::protobuf::reflect::MessageDescriptor::new::<FailJobResponse>(
                    "FailJobResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static FailJobResponse {
        static mut instance: ::protobuf::lazy::Lazy<FailJobResponse> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const FailJobResponse,
        };
        unsafe {
            instance.get(FailJobResponse::new)
        }
    }
}

impl ::protobuf::Clear for FailJobResponse {
    fn clear(&mut self) {
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for FailJobResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for FailJobResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct PublishMessageRequest {
    // message fields
    pub name: ::std::string::String,
    pub correlationKey: ::std::string::String,
    pub timeToLive: i64,
    pub messageId: ::std::string::String,
    pub variables: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a PublishMessageRequest {
    fn default() -> &'a PublishMessageRequest {
        <PublishMessageRequest as ::protobuf::Message>::default_instance()
    }
}

impl PublishMessageRequest {
    pub fn new() -> PublishMessageRequest {
        ::std::default::Default::default()
    }

    // string name = 1;


    pub fn get_name(&self) -> &str {
        &self.name
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.name = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_name(&mut self) -> &mut ::std::string::String {
        &mut self.name
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.name, ::std::string::String::new())
    }

    // string correlationKey = 2;


    pub fn get_correlationKey(&self) -> &str {
        &self.correlationKey
    }
    pub fn clear_correlationKey(&mut self) {
        self.correlationKey.clear();
    }

    // Param is passed by value, moved
    pub fn set_correlationKey(&mut self, v: ::std::string::String) {
        self.correlationKey = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_correlationKey(&mut self) -> &mut ::std::string::String {
        &mut self.correlationKey
    }

    // Take field
    pub fn take_correlationKey(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.correlationKey, ::std::string::String::new())
    }

    // int64 timeToLive = 3;


    pub fn get_timeToLive(&self) -> i64 {
        self.timeToLive
    }
    pub fn clear_timeToLive(&mut self) {
        self.timeToLive = 0;
    }

    // Param is passed by value, moved
    pub fn set_timeToLive(&mut self, v: i64) {
        self.timeToLive = v;
    }

    // string messageId = 4;


    pub fn get_messageId(&self) -> &str {
        &self.messageId
    }
    pub fn clear_messageId(&mut self) {
        self.messageId.clear();
    }

    // Param is passed by value, moved
    pub fn set_messageId(&mut self, v: ::std::string::String) {
        self.messageId = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_messageId(&mut self) -> &mut ::std::string::String {
        &mut self.messageId
    }

    // Take field
    pub fn take_messageId(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.messageId, ::std::string::String::new())
    }

    // string variables = 5;


    pub fn get_variables(&self) -> &str {
        &self.variables
    }
    pub fn clear_variables(&mut self) {
        self.variables.clear();
    }

    // Param is passed by value, moved
    pub fn set_variables(&mut self, v: ::std::string::String) {
        self.variables = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_variables(&mut self) -> &mut ::std::string::String {
        &mut self.variables
    }

    // Take field
    pub fn take_variables(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.variables, ::std::string::String::new())
    }
}

impl ::protobuf::Message for PublishMessageRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.correlationKey)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.timeToLive = tmp;
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.messageId)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.variables)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if !self.correlationKey.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.correlationKey);
        }
        if self.timeToLive != 0 {
            my_size += ::protobuf::rt::value_size(3, self.timeToLive, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.messageId.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.messageId);
        }
        if !self.variables.is_empty() {
            my_size += ::protobuf::rt::string_size(5, &self.variables);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if !self.correlationKey.is_empty() {
            os.write_string(2, &self.correlationKey)?;
        }
        if self.timeToLive != 0 {
            os.write_int64(3, self.timeToLive)?;
        }
        if !self.messageId.is_empty() {
            os.write_string(4, &self.messageId)?;
        }
        if !self.variables.is_empty() {
            os.write_string(5, &self.variables)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> PublishMessageRequest {
        PublishMessageRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "name",
                    |m: &PublishMessageRequest| { &m.name },
                    |m: &mut PublishMessageRequest| { &mut m.name },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "correlationKey",
                    |m: &PublishMessageRequest| { &m.correlationKey },
                    |m: &mut PublishMessageRequest| { &mut m.correlationKey },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "timeToLive",
                    |m: &PublishMessageRequest| { &m.timeToLive },
                    |m: &mut PublishMessageRequest| { &mut m.timeToLive },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "messageId",
                    |m: &PublishMessageRequest| { &m.messageId },
                    |m: &mut PublishMessageRequest| { &mut m.messageId },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "variables",
                    |m: &PublishMessageRequest| { &m.variables },
                    |m: &mut PublishMessageRequest| { &mut m.variables },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<PublishMessageRequest>(
                    "PublishMessageRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static PublishMessageRequest {
        static mut instance: ::protobuf::lazy::Lazy<PublishMessageRequest> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const PublishMessageRequest,
        };
        unsafe {
            instance.get(PublishMessageRequest::new)
        }
    }
}

impl ::protobuf::Clear for PublishMessageRequest {
    fn clear(&mut self) {
        self.name.clear();
        self.correlationKey.clear();
        self.timeToLive = 0;
        self.messageId.clear();
        self.variables.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for PublishMessageRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for PublishMessageRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct PublishMessageResponse {
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a PublishMessageResponse {
    fn default() -> &'a PublishMessageResponse {
        <PublishMessageResponse as ::protobuf::Message>::default_instance()
    }
}

impl PublishMessageResponse {
    pub fn new() -> PublishMessageResponse {
        ::std::default::Default::default()
    }
}

impl ::protobuf::Message for PublishMessageResponse {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> PublishMessageResponse {
        PublishMessageResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let fields = ::std::vec::Vec::new();
                ::protobuf::reflect::MessageDescriptor::new::<PublishMessageResponse>(
                    "PublishMessageResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static PublishMessageResponse {
        static mut instance: ::protobuf::lazy::Lazy<PublishMessageResponse> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const PublishMessageResponse,
        };
        unsafe {
            instance.get(PublishMessageResponse::new)
        }
    }
}

impl ::protobuf::Clear for PublishMessageResponse {
    fn clear(&mut self) {
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for PublishMessageResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for PublishMessageResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ResolveIncidentRequest {
    // message fields
    pub incidentKey: i64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ResolveIncidentRequest {
    fn default() -> &'a ResolveIncidentRequest {
        <ResolveIncidentRequest as ::protobuf::Message>::default_instance()
    }
}

impl ResolveIncidentRequest {
    pub fn new() -> ResolveIncidentRequest {
        ::std::default::Default::default()
    }

    // int64 incidentKey = 1;


    pub fn get_incidentKey(&self) -> i64 {
        self.incidentKey
    }
    pub fn clear_incidentKey(&mut self) {
        self.incidentKey = 0;
    }

    // Param is passed by value, moved
    pub fn set_incidentKey(&mut self, v: i64) {
        self.incidentKey = v;
    }
}

impl ::protobuf::Message for ResolveIncidentRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.incidentKey = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.incidentKey != 0 {
            my_size += ::protobuf::rt::value_size(1, self.incidentKey, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.incidentKey != 0 {
            os.write_int64(1, self.incidentKey)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ResolveIncidentRequest {
        ResolveIncidentRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "incidentKey",
                    |m: &ResolveIncidentRequest| { &m.incidentKey },
                    |m: &mut ResolveIncidentRequest| { &mut m.incidentKey },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ResolveIncidentRequest>(
                    "ResolveIncidentRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static ResolveIncidentRequest {
        static mut instance: ::protobuf::lazy::Lazy<ResolveIncidentRequest> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ResolveIncidentRequest,
        };
        unsafe {
            instance.get(ResolveIncidentRequest::new)
        }
    }
}

impl ::protobuf::Clear for ResolveIncidentRequest {
    fn clear(&mut self) {
        self.incidentKey = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ResolveIncidentRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ResolveIncidentRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ResolveIncidentResponse {
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ResolveIncidentResponse {
    fn default() -> &'a ResolveIncidentResponse {
        <ResolveIncidentResponse as ::protobuf::Message>::default_instance()
    }
}

impl ResolveIncidentResponse {
    pub fn new() -> ResolveIncidentResponse {
        ::std::default::Default::default()
    }
}

impl ::protobuf::Message for ResolveIncidentResponse {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ResolveIncidentResponse {
        ResolveIncidentResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let fields = ::std::vec::Vec::new();
                ::protobuf::reflect::MessageDescriptor::new::<ResolveIncidentResponse>(
                    "ResolveIncidentResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static ResolveIncidentResponse {
        static mut instance: ::protobuf::lazy::Lazy<ResolveIncidentResponse> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ResolveIncidentResponse,
        };
        unsafe {
            instance.get(ResolveIncidentResponse::new)
        }
    }
}

impl ::protobuf::Clear for ResolveIncidentResponse {
    fn clear(&mut self) {
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ResolveIncidentResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ResolveIncidentResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TopologyRequest {
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a TopologyRequest {
    fn default() -> &'a TopologyRequest {
        <TopologyRequest as ::protobuf::Message>::default_instance()
    }
}

impl TopologyRequest {
    pub fn new() -> TopologyRequest {
        ::std::default::Default::default()
    }
}

impl ::protobuf::Message for TopologyRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> TopologyRequest {
        TopologyRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let fields = ::std::vec::Vec::new();
                ::protobuf::reflect::MessageDescriptor::new::<TopologyRequest>(
                    "TopologyRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TopologyRequest {
        static mut instance: ::protobuf::lazy::Lazy<TopologyRequest> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TopologyRequest,
        };
        unsafe {
            instance.get(TopologyRequest::new)
        }
    }
}

impl ::protobuf::Clear for TopologyRequest {
    fn clear(&mut self) {
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for TopologyRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for TopologyRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TopologyResponse {
    // message fields
    pub brokers: ::protobuf::RepeatedField<BrokerInfo>,
    pub clusterSize: i32,
    pub partitionsCount: i32,
    pub replicationFactor: i32,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a TopologyResponse {
    fn default() -> &'a TopologyResponse {
        <TopologyResponse as ::protobuf::Message>::default_instance()
    }
}

impl TopologyResponse {
    pub fn new() -> TopologyResponse {
        ::std::default::Default::default()
    }

    // repeated .gateway_protocol.BrokerInfo brokers = 1;


    pub fn get_brokers(&self) -> &[BrokerInfo] {
        &self.brokers
    }
    pub fn clear_brokers(&mut self) {
        self.brokers.clear();
    }

    // Param is passed by value, moved
    pub fn set_brokers(&mut self, v: ::protobuf::RepeatedField<BrokerInfo>) {
        self.brokers = v;
    }

    // Mutable pointer to the field.
    pub fn mut_brokers(&mut self) -> &mut ::protobuf::RepeatedField<BrokerInfo> {
        &mut self.brokers
    }

    // Take field
    pub fn take_brokers(&mut self) -> ::protobuf::RepeatedField<BrokerInfo> {
        ::std::mem::replace(&mut self.brokers, ::protobuf::RepeatedField::new())
    }

    // int32 clusterSize = 2;


    pub fn get_clusterSize(&self) -> i32 {
        self.clusterSize
    }
    pub fn clear_clusterSize(&mut self) {
        self.clusterSize = 0;
    }

    // Param is passed by value, moved
    pub fn set_clusterSize(&mut self, v: i32) {
        self.clusterSize = v;
    }

    // int32 partitionsCount = 3;


    pub fn get_partitionsCount(&self) -> i32 {
        self.partitionsCount
    }
    pub fn clear_partitionsCount(&mut self) {
        self.partitionsCount = 0;
    }

    // Param is passed by value, moved
    pub fn set_partitionsCount(&mut self, v: i32) {
        self.partitionsCount = v;
    }

    // int32 replicationFactor = 4;


    pub fn get_replicationFactor(&self) -> i32 {
        self.replicationFactor
    }
    pub fn clear_replicationFactor(&mut self) {
        self.replicationFactor = 0;
    }

    // Param is passed by value, moved
    pub fn set_replicationFactor(&mut self, v: i32) {
        self.replicationFactor = v;
    }
}

impl ::protobuf::Message for TopologyResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.brokers {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.brokers)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.clusterSize = tmp;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.partitionsCount = tmp;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.replicationFactor = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.brokers {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if self.clusterSize != 0 {
            my_size += ::protobuf::rt::value_size(2, self.clusterSize, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.partitionsCount != 0 {
            my_size += ::protobuf::rt::value_size(3, self.partitionsCount, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.replicationFactor != 0 {
            my_size += ::protobuf::rt::value_size(4, self.replicationFactor, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.brokers {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if self.clusterSize != 0 {
            os.write_int32(2, self.clusterSize)?;
        }
        if self.partitionsCount != 0 {
            os.write_int32(3, self.partitionsCount)?;
        }
        if self.replicationFactor != 0 {
            os.write_int32(4, self.replicationFactor)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> TopologyResponse {
        TopologyResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<BrokerInfo>>(
                    "brokers",
                    |m: &TopologyResponse| { &m.brokers },
                    |m: &mut TopologyResponse| { &mut m.brokers },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                    "clusterSize",
                    |m: &TopologyResponse| { &m.clusterSize },
                    |m: &mut TopologyResponse| { &mut m.clusterSize },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                    "partitionsCount",
                    |m: &TopologyResponse| { &m.partitionsCount },
                    |m: &mut TopologyResponse| { &mut m.partitionsCount },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                    "replicationFactor",
                    |m: &TopologyResponse| { &m.replicationFactor },
                    |m: &mut TopologyResponse| { &mut m.replicationFactor },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<TopologyResponse>(
                    "TopologyResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TopologyResponse {
        static mut instance: ::protobuf::lazy::Lazy<TopologyResponse> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TopologyResponse,
        };
        unsafe {
            instance.get(TopologyResponse::new)
        }
    }
}

impl ::protobuf::Clear for TopologyResponse {
    fn clear(&mut self) {
        self.brokers.clear();
        self.clusterSize = 0;
        self.partitionsCount = 0;
        self.replicationFactor = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for TopologyResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for TopologyResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct BrokerInfo {
    // message fields
    pub nodeId: i32,
    pub host: ::std::string::String,
    pub port: i32,
    pub partitions: ::protobuf::RepeatedField<Partition>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a BrokerInfo {
    fn default() -> &'a BrokerInfo {
        <BrokerInfo as ::protobuf::Message>::default_instance()
    }
}

impl BrokerInfo {
    pub fn new() -> BrokerInfo {
        ::std::default::Default::default()
    }

    // int32 nodeId = 1;


    pub fn get_nodeId(&self) -> i32 {
        self.nodeId
    }
    pub fn clear_nodeId(&mut self) {
        self.nodeId = 0;
    }

    // Param is passed by value, moved
    pub fn set_nodeId(&mut self, v: i32) {
        self.nodeId = v;
    }

    // string host = 2;


    pub fn get_host(&self) -> &str {
        &self.host
    }
    pub fn clear_host(&mut self) {
        self.host.clear();
    }

    // Param is passed by value, moved
    pub fn set_host(&mut self, v: ::std::string::String) {
        self.host = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_host(&mut self) -> &mut ::std::string::String {
        &mut self.host
    }

    // Take field
    pub fn take_host(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.host, ::std::string::String::new())
    }

    // int32 port = 3;


    pub fn get_port(&self) -> i32 {
        self.port
    }
    pub fn clear_port(&mut self) {
        self.port = 0;
    }

    // Param is passed by value, moved
    pub fn set_port(&mut self, v: i32) {
        self.port = v;
    }

    // repeated .gateway_protocol.Partition partitions = 4;


    pub fn get_partitions(&self) -> &[Partition] {
        &self.partitions
    }
    pub fn clear_partitions(&mut self) {
        self.partitions.clear();
    }

    // Param is passed by value, moved
    pub fn set_partitions(&mut self, v: ::protobuf::RepeatedField<Partition>) {
        self.partitions = v;
    }

    // Mutable pointer to the field.
    pub fn mut_partitions(&mut self) -> &mut ::protobuf::RepeatedField<Partition> {
        &mut self.partitions
    }

    // Take field
    pub fn take_partitions(&mut self) -> ::protobuf::RepeatedField<Partition> {
        ::std::mem::replace(&mut self.partitions, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for BrokerInfo {
    fn is_initialized(&self) -> bool {
        for v in &self.partitions {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.nodeId = tmp;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.host)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.port = tmp;
                },
                4 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.partitions)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.nodeId != 0 {
            my_size += ::protobuf::rt::value_size(1, self.nodeId, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.host.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.host);
        }
        if self.port != 0 {
            my_size += ::protobuf::rt::value_size(3, self.port, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.partitions {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.nodeId != 0 {
            os.write_int32(1, self.nodeId)?;
        }
        if !self.host.is_empty() {
            os.write_string(2, &self.host)?;
        }
        if self.port != 0 {
            os.write_int32(3, self.port)?;
        }
        for v in &self.partitions {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> BrokerInfo {
        BrokerInfo::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                    "nodeId",
                    |m: &BrokerInfo| { &m.nodeId },
                    |m: &mut BrokerInfo| { &mut m.nodeId },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "host",
                    |m: &BrokerInfo| { &m.host },
                    |m: &mut BrokerInfo| { &mut m.host },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                    "port",
                    |m: &BrokerInfo| { &m.port },
                    |m: &mut BrokerInfo| { &mut m.port },
                ));
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Partition>>(
                    "partitions",
                    |m: &BrokerInfo| { &m.partitions },
                    |m: &mut BrokerInfo| { &mut m.partitions },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<BrokerInfo>(
                    "BrokerInfo",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static BrokerInfo {
        static mut instance: ::protobuf::lazy::Lazy<BrokerInfo> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const BrokerInfo,
        };
        unsafe {
            instance.get(BrokerInfo::new)
        }
    }
}

impl ::protobuf::Clear for BrokerInfo {
    fn clear(&mut self) {
        self.nodeId = 0;
        self.host.clear();
        self.port = 0;
        self.partitions.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for BrokerInfo {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for BrokerInfo {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct Partition {
    // message fields
    pub partitionId: i32,
    pub role: Partition_PartitionBrokerRole,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a Partition {
    fn default() -> &'a Partition {
        <Partition as ::protobuf::Message>::default_instance()
    }
}

impl Partition {
    pub fn new() -> Partition {
        ::std::default::Default::default()
    }

    // int32 partitionId = 1;


    pub fn get_partitionId(&self) -> i32 {
        self.partitionId
    }
    pub fn clear_partitionId(&mut self) {
        self.partitionId = 0;
    }

    // Param is passed by value, moved
    pub fn set_partitionId(&mut self, v: i32) {
        self.partitionId = v;
    }

    // .gateway_protocol.Partition.PartitionBrokerRole role = 2;


    pub fn get_role(&self) -> Partition_PartitionBrokerRole {
        self.role
    }
    pub fn clear_role(&mut self) {
        self.role = Partition_PartitionBrokerRole::LEADER;
    }

    // Param is passed by value, moved
    pub fn set_role(&mut self, v: Partition_PartitionBrokerRole) {
        self.role = v;
    }
}

impl ::protobuf::Message for Partition {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.partitionId = tmp;
                },
                2 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.role, 2, &mut self.unknown_fields)?
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.partitionId != 0 {
            my_size += ::protobuf::rt::value_size(1, self.partitionId, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.role != Partition_PartitionBrokerRole::LEADER {
            my_size += ::protobuf::rt::enum_size(2, self.role);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.partitionId != 0 {
            os.write_int32(1, self.partitionId)?;
        }
        if self.role != Partition_PartitionBrokerRole::LEADER {
            os.write_enum(2, self.role.value())?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> Partition {
        Partition::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                    "partitionId",
                    |m: &Partition| { &m.partitionId },
                    |m: &mut Partition| { &mut m.partitionId },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Partition_PartitionBrokerRole>>(
                    "role",
                    |m: &Partition| { &m.role },
                    |m: &mut Partition| { &mut m.role },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<Partition>(
                    "Partition",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static Partition {
        static mut instance: ::protobuf::lazy::Lazy<Partition> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const Partition,
        };
        unsafe {
            instance.get(Partition::new)
        }
    }
}

impl ::protobuf::Clear for Partition {
    fn clear(&mut self) {
        self.partitionId = 0;
        self.role = Partition_PartitionBrokerRole::LEADER;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for Partition {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Partition {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum Partition_PartitionBrokerRole {
    LEADER = 0,
    FOLLOWER = 1,
}

impl ::protobuf::ProtobufEnum for Partition_PartitionBrokerRole {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<Partition_PartitionBrokerRole> {
        match value {
            0 => ::std::option::Option::Some(Partition_PartitionBrokerRole::LEADER),
            1 => ::std::option::Option::Some(Partition_PartitionBrokerRole::FOLLOWER),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [Partition_PartitionBrokerRole] = &[
            Partition_PartitionBrokerRole::LEADER,
            Partition_PartitionBrokerRole::FOLLOWER,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::EnumDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                ::protobuf::reflect::EnumDescriptor::new("Partition_PartitionBrokerRole", file_descriptor_proto())
            })
        }
    }
}

impl ::std::marker::Copy for Partition_PartitionBrokerRole {
}

impl ::std::default::Default for Partition_PartitionBrokerRole {
    fn default() -> Self {
        Partition_PartitionBrokerRole::LEADER
    }
}

impl ::protobuf::reflect::ProtobufValue for Partition_PartitionBrokerRole {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct UpdateJobRetriesRequest {
    // message fields
    pub jobKey: i64,
    pub retries: i32,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a UpdateJobRetriesRequest {
    fn default() -> &'a UpdateJobRetriesRequest {
        <UpdateJobRetriesRequest as ::protobuf::Message>::default_instance()
    }
}

impl UpdateJobRetriesRequest {
    pub fn new() -> UpdateJobRetriesRequest {
        ::std::default::Default::default()
    }

    // int64 jobKey = 1;


    pub fn get_jobKey(&self) -> i64 {
        self.jobKey
    }
    pub fn clear_jobKey(&mut self) {
        self.jobKey = 0;
    }

    // Param is passed by value, moved
    pub fn set_jobKey(&mut self, v: i64) {
        self.jobKey = v;
    }

    // int32 retries = 2;


    pub fn get_retries(&self) -> i32 {
        self.retries
    }
    pub fn clear_retries(&mut self) {
        self.retries = 0;
    }

    // Param is passed by value, moved
    pub fn set_retries(&mut self, v: i32) {
        self.retries = v;
    }
}

impl ::protobuf::Message for UpdateJobRetriesRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.jobKey = tmp;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.retries = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.jobKey != 0 {
            my_size += ::protobuf::rt::value_size(1, self.jobKey, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.retries != 0 {
            my_size += ::protobuf::rt::value_size(2, self.retries, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.jobKey != 0 {
            os.write_int64(1, self.jobKey)?;
        }
        if self.retries != 0 {
            os.write_int32(2, self.retries)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> UpdateJobRetriesRequest {
        UpdateJobRetriesRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "jobKey",
                    |m: &UpdateJobRetriesRequest| { &m.jobKey },
                    |m: &mut UpdateJobRetriesRequest| { &mut m.jobKey },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                    "retries",
                    |m: &UpdateJobRetriesRequest| { &m.retries },
                    |m: &mut UpdateJobRetriesRequest| { &mut m.retries },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<UpdateJobRetriesRequest>(
                    "UpdateJobRetriesRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static UpdateJobRetriesRequest {
        static mut instance: ::protobuf::lazy::Lazy<UpdateJobRetriesRequest> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const UpdateJobRetriesRequest,
        };
        unsafe {
            instance.get(UpdateJobRetriesRequest::new)
        }
    }
}

impl ::protobuf::Clear for UpdateJobRetriesRequest {
    fn clear(&mut self) {
        self.jobKey = 0;
        self.retries = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for UpdateJobRetriesRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for UpdateJobRetriesRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct UpdateJobRetriesResponse {
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a UpdateJobRetriesResponse {
    fn default() -> &'a UpdateJobRetriesResponse {
        <UpdateJobRetriesResponse as ::protobuf::Message>::default_instance()
    }
}

impl UpdateJobRetriesResponse {
    pub fn new() -> UpdateJobRetriesResponse {
        ::std::default::Default::default()
    }
}

impl ::protobuf::Message for UpdateJobRetriesResponse {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> UpdateJobRetriesResponse {
        UpdateJobRetriesResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let fields = ::std::vec::Vec::new();
                ::protobuf::reflect::MessageDescriptor::new::<UpdateJobRetriesResponse>(
                    "UpdateJobRetriesResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static UpdateJobRetriesResponse {
        static mut instance: ::protobuf::lazy::Lazy<UpdateJobRetriesResponse> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const UpdateJobRetriesResponse,
        };
        unsafe {
            instance.get(UpdateJobRetriesResponse::new)
        }
    }
}

impl ::protobuf::Clear for UpdateJobRetriesResponse {
    fn clear(&mut self) {
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for UpdateJobRetriesResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for UpdateJobRetriesResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct SetVariablesRequest {
    // message fields
    pub elementInstanceKey: i64,
    pub variables: ::std::string::String,
    pub local: bool,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a SetVariablesRequest {
    fn default() -> &'a SetVariablesRequest {
        <SetVariablesRequest as ::protobuf::Message>::default_instance()
    }
}

impl SetVariablesRequest {
    pub fn new() -> SetVariablesRequest {
        ::std::default::Default::default()
    }

    // int64 elementInstanceKey = 1;


    pub fn get_elementInstanceKey(&self) -> i64 {
        self.elementInstanceKey
    }
    pub fn clear_elementInstanceKey(&mut self) {
        self.elementInstanceKey = 0;
    }

    // Param is passed by value, moved
    pub fn set_elementInstanceKey(&mut self, v: i64) {
        self.elementInstanceKey = v;
    }

    // string variables = 2;


    pub fn get_variables(&self) -> &str {
        &self.variables
    }
    pub fn clear_variables(&mut self) {
        self.variables.clear();
    }

    // Param is passed by value, moved
    pub fn set_variables(&mut self, v: ::std::string::String) {
        self.variables = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_variables(&mut self) -> &mut ::std::string::String {
        &mut self.variables
    }

    // Take field
    pub fn take_variables(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.variables, ::std::string::String::new())
    }

    // bool local = 3;


    pub fn get_local(&self) -> bool {
        self.local
    }
    pub fn clear_local(&mut self) {
        self.local = false;
    }

    // Param is passed by value, moved
    pub fn set_local(&mut self, v: bool) {
        self.local = v;
    }
}

impl ::protobuf::Message for SetVariablesRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.elementInstanceKey = tmp;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.variables)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.local = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.elementInstanceKey != 0 {
            my_size += ::protobuf::rt::value_size(1, self.elementInstanceKey, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.variables.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.variables);
        }
        if self.local != false {
            my_size += 2;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.elementInstanceKey != 0 {
            os.write_int64(1, self.elementInstanceKey)?;
        }
        if !self.variables.is_empty() {
            os.write_string(2, &self.variables)?;
        }
        if self.local != false {
            os.write_bool(3, self.local)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> SetVariablesRequest {
        SetVariablesRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "elementInstanceKey",
                    |m: &SetVariablesRequest| { &m.elementInstanceKey },
                    |m: &mut SetVariablesRequest| { &mut m.elementInstanceKey },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "variables",
                    |m: &SetVariablesRequest| { &m.variables },
                    |m: &mut SetVariablesRequest| { &mut m.variables },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "local",
                    |m: &SetVariablesRequest| { &m.local },
                    |m: &mut SetVariablesRequest| { &mut m.local },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<SetVariablesRequest>(
                    "SetVariablesRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static SetVariablesRequest {
        static mut instance: ::protobuf::lazy::Lazy<SetVariablesRequest> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const SetVariablesRequest,
        };
        unsafe {
            instance.get(SetVariablesRequest::new)
        }
    }
}

impl ::protobuf::Clear for SetVariablesRequest {
    fn clear(&mut self) {
        self.elementInstanceKey = 0;
        self.variables.clear();
        self.local = false;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for SetVariablesRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for SetVariablesRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct SetVariablesResponse {
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a SetVariablesResponse {
    fn default() -> &'a SetVariablesResponse {
        <SetVariablesResponse as ::protobuf::Message>::default_instance()
    }
}

impl SetVariablesResponse {
    pub fn new() -> SetVariablesResponse {
        ::std::default::Default::default()
    }
}

impl ::protobuf::Message for SetVariablesResponse {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> SetVariablesResponse {
        SetVariablesResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let fields = ::std::vec::Vec::new();
                ::protobuf::reflect::MessageDescriptor::new::<SetVariablesResponse>(
                    "SetVariablesResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static SetVariablesResponse {
        static mut instance: ::protobuf::lazy::Lazy<SetVariablesResponse> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const SetVariablesResponse,
        };
        unsafe {
            instance.get(SetVariablesResponse::new)
        }
    }
}

impl ::protobuf::Clear for SetVariablesResponse {
    fn clear(&mut self) {
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for SetVariablesResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for SetVariablesResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x13proto/gateway.proto\x12\x10gateway_protocol\"\xd7\x01\n\x13Activat\
    eJobsRequest\x12\x12\n\x04type\x18\x01\x20\x01(\tR\x04type\x12\x16\n\x06\
    worker\x18\x02\x20\x01(\tR\x06worker\x12\x18\n\x07timeout\x18\x03\x20\
    \x01(\x03R\x07timeout\x12,\n\x11maxJobsToActivate\x18\x04\x20\x01(\x05R\
    \x11maxJobsToActivate\x12$\n\rfetchVariable\x18\x05\x20\x03(\tR\rfetchVa\
    riable\x12&\n\x0erequestTimeout\x18\x06\x20\x01(\x03R\x0erequestTimeout\
    \"J\n\x14ActivateJobsResponse\x122\n\x04jobs\x18\x01\x20\x03(\x0b2\x1e.g\
    ateway_protocol.ActivatedJobR\x04jobs\"\xcc\x03\n\x0cActivatedJob\x12\
    \x10\n\x03key\x18\x01\x20\x01(\x03R\x03key\x12\x12\n\x04type\x18\x02\x20\
    \x01(\tR\x04type\x120\n\x13workflowInstanceKey\x18\x03\x20\x01(\x03R\x13\
    workflowInstanceKey\x12$\n\rbpmnProcessId\x18\x04\x20\x01(\tR\rbpmnProce\
    ssId\x12<\n\x19workflowDefinitionVersion\x18\x05\x20\x01(\x05R\x19workfl\
    owDefinitionVersion\x12\x20\n\x0bworkflowKey\x18\x06\x20\x01(\x03R\x0bwo\
    rkflowKey\x12\x1c\n\telementId\x18\x07\x20\x01(\tR\telementId\x12.\n\x12\
    elementInstanceKey\x18\x08\x20\x01(\x03R\x12elementInstanceKey\x12$\n\rc\
    ustomHeaders\x18\t\x20\x01(\tR\rcustomHeaders\x12\x16\n\x06worker\x18\n\
    \x20\x01(\tR\x06worker\x12\x18\n\x07retries\x18\x0b\x20\x01(\x05R\x07ret\
    ries\x12\x1a\n\x08deadline\x18\x0c\x20\x01(\x03R\x08deadline\x12\x1c\n\t\
    variables\x18\r\x20\x01(\tR\tvariables\"Q\n\x1dCancelWorkflowInstanceReq\
    uest\x120\n\x13workflowInstanceKey\x18\x01\x20\x01(\x03R\x13workflowInst\
    anceKey\"\x20\n\x1eCancelWorkflowInstanceResponse\"J\n\x12CompleteJobReq\
    uest\x12\x16\n\x06jobKey\x18\x01\x20\x01(\x03R\x06jobKey\x12\x1c\n\tvari\
    ables\x18\x02\x20\x01(\tR\tvariables\"\x15\n\x13CompleteJobResponse\"\
    \x9f\x01\n\x1dCreateWorkflowInstanceRequest\x12\x20\n\x0bworkflowKey\x18\
    \x01\x20\x01(\x03R\x0bworkflowKey\x12$\n\rbpmnProcessId\x18\x02\x20\x01(\
    \tR\rbpmnProcessId\x12\x18\n\x07version\x18\x03\x20\x01(\x05R\x07version\
    \x12\x1c\n\tvariables\x18\x04\x20\x01(\tR\tvariables\"\xb4\x01\n\x1eCrea\
    teWorkflowInstanceResponse\x12\x20\n\x0bworkflowKey\x18\x01\x20\x01(\x03\
    R\x0bworkflowKey\x12$\n\rbpmnProcessId\x18\x02\x20\x01(\tR\rbpmnProcessI\
    d\x12\x18\n\x07version\x18\x03\x20\x01(\x05R\x07version\x120\n\x13workfl\
    owInstanceKey\x18\x04\x20\x01(\x03R\x13workflowInstanceKey\"^\n\x15Deplo\
    yWorkflowRequest\x12E\n\tworkflows\x18\x01\x20\x03(\x0b2'.gateway_protoc\
    ol.WorkflowRequestObjectR\tworkflows\"\xc3\x01\n\x15WorkflowRequestObjec\
    t\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12H\n\x04type\x18\x02\
    \x20\x01(\x0e24.gateway_protocol.WorkflowRequestObject.ResourceTypeR\x04\
    type\x12\x1e\n\ndefinition\x18\x03\x20\x01(\x0cR\ndefinition\",\n\x0cRes\
    ourceType\x12\x08\n\x04FILE\x10\0\x12\x08\n\x04BPMN\x10\x01\x12\x08\n\
    \x04YAML\x10\x02\"l\n\x16DeployWorkflowResponse\x12\x10\n\x03key\x18\x01\
    \x20\x01(\x03R\x03key\x12@\n\tworkflows\x18\x02\x20\x03(\x0b2\".gateway_\
    protocol.WorkflowMetadataR\tworkflows\"\x98\x01\n\x10WorkflowMetadata\
    \x12$\n\rbpmnProcessId\x18\x01\x20\x01(\tR\rbpmnProcessId\x12\x18\n\x07v\
    ersion\x18\x02\x20\x01(\x05R\x07version\x12\x20\n\x0bworkflowKey\x18\x03\
    \x20\x01(\x03R\x0bworkflowKey\x12\"\n\x0cresourceName\x18\x04\x20\x01(\t\
    R\x0cresourceName\"f\n\x0eFailJobRequest\x12\x16\n\x06jobKey\x18\x01\x20\
    \x01(\x03R\x06jobKey\x12\x18\n\x07retries\x18\x02\x20\x01(\x05R\x07retri\
    es\x12\"\n\x0cerrorMessage\x18\x03\x20\x01(\tR\x0cerrorMessage\"\x11\n\
    \x0fFailJobResponse\"\xaf\x01\n\x15PublishMessageRequest\x12\x12\n\x04na\
    me\x18\x01\x20\x01(\tR\x04name\x12&\n\x0ecorrelationKey\x18\x02\x20\x01(\
    \tR\x0ecorrelationKey\x12\x1e\n\ntimeToLive\x18\x03\x20\x01(\x03R\ntimeT\
    oLive\x12\x1c\n\tmessageId\x18\x04\x20\x01(\tR\tmessageId\x12\x1c\n\tvar\
    iables\x18\x05\x20\x01(\tR\tvariables\"\x18\n\x16PublishMessageResponse\
    \":\n\x16ResolveIncidentRequest\x12\x20\n\x0bincidentKey\x18\x01\x20\x01\
    (\x03R\x0bincidentKey\"\x19\n\x17ResolveIncidentResponse\"\x11\n\x0fTopo\
    logyRequest\"\xc4\x01\n\x10TopologyResponse\x126\n\x07brokers\x18\x01\
    \x20\x03(\x0b2\x1c.gateway_protocol.BrokerInfoR\x07brokers\x12\x20\n\x0b\
    clusterSize\x18\x02\x20\x01(\x05R\x0bclusterSize\x12(\n\x0fpartitionsCou\
    nt\x18\x03\x20\x01(\x05R\x0fpartitionsCount\x12,\n\x11replicationFactor\
    \x18\x04\x20\x01(\x05R\x11replicationFactor\"\x89\x01\n\nBrokerInfo\x12\
    \x16\n\x06nodeId\x18\x01\x20\x01(\x05R\x06nodeId\x12\x12\n\x04host\x18\
    \x02\x20\x01(\tR\x04host\x12\x12\n\x04port\x18\x03\x20\x01(\x05R\x04port\
    \x12;\n\npartitions\x18\x04\x20\x03(\x0b2\x1b.gateway_protocol.Partition\
    R\npartitions\"\xa3\x01\n\tPartition\x12\x20\n\x0bpartitionId\x18\x01\
    \x20\x01(\x05R\x0bpartitionId\x12C\n\x04role\x18\x02\x20\x01(\x0e2/.gate\
    way_protocol.Partition.PartitionBrokerRoleR\x04role\"/\n\x13PartitionBro\
    kerRole\x12\n\n\x06LEADER\x10\0\x12\x0c\n\x08FOLLOWER\x10\x01\"K\n\x17Up\
    dateJobRetriesRequest\x12\x16\n\x06jobKey\x18\x01\x20\x01(\x03R\x06jobKe\
    y\x12\x18\n\x07retries\x18\x02\x20\x01(\x05R\x07retries\"\x1a\n\x18Updat\
    eJobRetriesResponse\"y\n\x13SetVariablesRequest\x12.\n\x12elementInstanc\
    eKey\x18\x01\x20\x01(\x03R\x12elementInstanceKey\x12\x1c\n\tvariables\
    \x18\x02\x20\x01(\tR\tvariables\x12\x14\n\x05local\x18\x03\x20\x01(\x08R\
    \x05local\"\x16\n\x14SetVariablesResponse2\xf5\x08\n\x07Gateway\x12a\n\
    \x0cActivateJobs\x12%.gateway_protocol.ActivateJobsRequest\x1a&.gateway_\
    protocol.ActivateJobsResponse\"\00\x01\x12}\n\x16CancelWorkflowInstance\
    \x12/.gateway_protocol.CancelWorkflowInstanceRequest\x1a0.gateway_protoc\
    ol.CancelWorkflowInstanceResponse\"\0\x12\\\n\x0bCompleteJob\x12$.gatewa\
    y_protocol.CompleteJobRequest\x1a%.gateway_protocol.CompleteJobResponse\
    \"\0\x12}\n\x16CreateWorkflowInstance\x12/.gateway_protocol.CreateWorkfl\
    owInstanceRequest\x1a0.gateway_protocol.CreateWorkflowInstanceResponse\"\
    \0\x12e\n\x0eDeployWorkflow\x12'.gateway_protocol.DeployWorkflowRequest\
    \x1a(.gateway_protocol.DeployWorkflowResponse\"\0\x12P\n\x07FailJob\x12\
    \x20.gateway_protocol.FailJobRequest\x1a!.gateway_protocol.FailJobRespon\
    se\"\0\x12e\n\x0ePublishMessage\x12'.gateway_protocol.PublishMessageRequ\
    est\x1a(.gateway_protocol.PublishMessageResponse\"\0\x12h\n\x0fResolveIn\
    cident\x12(.gateway_protocol.ResolveIncidentRequest\x1a).gateway_protoco\
    l.ResolveIncidentResponse\"\0\x12_\n\x0cSetVariables\x12%.gateway_protoc\
    ol.SetVariablesRequest\x1a&.gateway_protocol.SetVariablesResponse\"\0\
    \x12S\n\x08Topology\x12!.gateway_protocol.TopologyRequest\x1a\".gateway_\
    protocol.TopologyResponse\"\0\x12k\n\x10UpdateJobRetries\x12).gateway_pr\
    otocol.UpdateJobRetriesRequest\x1a*.gateway_protocol.UpdateJobRetriesRes\
    ponse\"\0B!\n\x19io.zeebe.gateway.protocolP\0Z\x02pbb\x06proto3\
";

static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
    lock: ::protobuf::lazy::ONCE_INIT,
    ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto,
};

fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
    ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
}

pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    unsafe {
        file_descriptor_proto_lazy.get(|| {
            parse_descriptor_proto()
        })
    }
}