// This file is generated by rust-protobuf 3.2.0. Do not edit
// .proto file is parsed by protoc --rust-out=...
// @generated

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

#![allow(unused_attributes)]
#![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(unused_results)]
#![allow(unused_mut)]

//! Generated file from `grpc_public.proto`

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

///  protolint:disable INDENT
#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:protos.GetServicesRequest)
pub struct GetServicesRequest {
    // special fields
    // @@protoc_insertion_point(special_field:protos.GetServicesRequest.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetServicesRequest>(
            "GetServicesRequest",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for GetServicesRequest {
    const NAME: &'static str = "GetServicesRequest";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static GetServicesRequest {
        static instance: GetServicesRequest = GetServicesRequest {
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for GetServicesRequest {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("GetServicesRequest").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for GetServicesRequest {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:protos.GetServicesResponse)
pub struct GetServicesResponse {
    // special fields
    // @@protoc_insertion_point(special_field:protos.GetServicesResponse.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetServicesResponse>(
            "GetServicesResponse",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for GetServicesResponse {
    const NAME: &'static str = "GetServicesResponse";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static GetServicesResponse {
        static instance: GetServicesResponse = GetServicesResponse {
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for GetServicesResponse {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("GetServicesResponse").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for GetServicesResponse {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:protos.GetPipelinesRequest)
pub struct GetPipelinesRequest {
    // special fields
    // @@protoc_insertion_point(special_field:protos.GetPipelinesRequest.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetPipelinesRequest>(
            "GetPipelinesRequest",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for GetPipelinesRequest {
    const NAME: &'static str = "GetPipelinesRequest";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static GetPipelinesRequest {
        static instance: GetPipelinesRequest = GetPipelinesRequest {
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for GetPipelinesRequest {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("GetPipelinesRequest").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for GetPipelinesRequest {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:protos.GetPipelinesResponse)
pub struct GetPipelinesResponse {
    // special fields
    // @@protoc_insertion_point(special_field:protos.GetPipelinesResponse.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetPipelinesResponse>(
            "GetPipelinesResponse",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for GetPipelinesResponse {
    const NAME: &'static str = "GetPipelinesResponse";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static GetPipelinesResponse {
        static instance: GetPipelinesResponse = GetPipelinesResponse {
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for GetPipelinesResponse {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("GetPipelinesResponse").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for GetPipelinesResponse {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:protos.GetPipelineRequest)
pub struct GetPipelineRequest {
    // special fields
    // @@protoc_insertion_point(special_field:protos.GetPipelineRequest.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetPipelineRequest>(
            "GetPipelineRequest",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for GetPipelineRequest {
    const NAME: &'static str = "GetPipelineRequest";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static GetPipelineRequest {
        static instance: GetPipelineRequest = GetPipelineRequest {
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for GetPipelineRequest {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("GetPipelineRequest").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for GetPipelineRequest {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:protos.GetPipelineResponse)
pub struct GetPipelineResponse {
    // special fields
    // @@protoc_insertion_point(special_field:protos.GetPipelineResponse.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetPipelineResponse>(
            "GetPipelineResponse",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for GetPipelineResponse {
    const NAME: &'static str = "GetPipelineResponse";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static GetPipelineResponse {
        static instance: GetPipelineResponse = GetPipelineResponse {
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for GetPipelineResponse {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("GetPipelineResponse").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for GetPipelineResponse {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:protos.UpdatePipelineRequest)
pub struct UpdatePipelineRequest {
    // special fields
    // @@protoc_insertion_point(special_field:protos.UpdatePipelineRequest.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UpdatePipelineRequest>(
            "UpdatePipelineRequest",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for UpdatePipelineRequest {
    const NAME: &'static str = "UpdatePipelineRequest";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static UpdatePipelineRequest {
        static instance: UpdatePipelineRequest = UpdatePipelineRequest {
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for UpdatePipelineRequest {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("UpdatePipelineRequest").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for UpdatePipelineRequest {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:protos.UpdatePipelineResponse)
pub struct UpdatePipelineResponse {
    // special fields
    // @@protoc_insertion_point(special_field:protos.UpdatePipelineResponse.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UpdatePipelineResponse>(
            "UpdatePipelineResponse",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for UpdatePipelineResponse {
    const NAME: &'static str = "UpdatePipelineResponse";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static UpdatePipelineResponse {
        static instance: UpdatePipelineResponse = UpdatePipelineResponse {
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for UpdatePipelineResponse {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("UpdatePipelineResponse").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for UpdatePipelineResponse {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:protos.DeletePipelineRequest)
pub struct DeletePipelineRequest {
    // special fields
    // @@protoc_insertion_point(special_field:protos.DeletePipelineRequest.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<DeletePipelineRequest>(
            "DeletePipelineRequest",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for DeletePipelineRequest {
    const NAME: &'static str = "DeletePipelineRequest";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static DeletePipelineRequest {
        static instance: DeletePipelineRequest = DeletePipelineRequest {
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for DeletePipelineRequest {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("DeletePipelineRequest").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for DeletePipelineRequest {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:protos.DeletePipelineResponse)
pub struct DeletePipelineResponse {
    // special fields
    // @@protoc_insertion_point(special_field:protos.DeletePipelineResponse.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<DeletePipelineResponse>(
            "DeletePipelineResponse",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for DeletePipelineResponse {
    const NAME: &'static str = "DeletePipelineResponse";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static DeletePipelineResponse {
        static instance: DeletePipelineResponse = DeletePipelineResponse {
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for DeletePipelineResponse {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("DeletePipelineResponse").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for DeletePipelineResponse {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:protos.GetStepsRequest)
pub struct GetStepsRequest {
    // special fields
    // @@protoc_insertion_point(special_field:protos.GetStepsRequest.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetStepsRequest>(
            "GetStepsRequest",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for GetStepsRequest {
    const NAME: &'static str = "GetStepsRequest";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static GetStepsRequest {
        static instance: GetStepsRequest = GetStepsRequest {
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for GetStepsRequest {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("GetStepsRequest").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for GetStepsRequest {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:protos.GetStepsResponse)
pub struct GetStepsResponse {
    // special fields
    // @@protoc_insertion_point(special_field:protos.GetStepsResponse.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetStepsResponse>(
            "GetStepsResponse",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for GetStepsResponse {
    const NAME: &'static str = "GetStepsResponse";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static GetStepsResponse {
        static instance: GetStepsResponse = GetStepsResponse {
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for GetStepsResponse {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("GetStepsResponse").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for GetStepsResponse {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:protos.CreateStepRequest)
pub struct CreateStepRequest {
    // special fields
    // @@protoc_insertion_point(special_field:protos.CreateStepRequest.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<CreateStepRequest>(
            "CreateStepRequest",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for CreateStepRequest {
    const NAME: &'static str = "CreateStepRequest";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CreateStepRequest {
        static instance: CreateStepRequest = CreateStepRequest {
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for CreateStepRequest {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("CreateStepRequest").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for CreateStepRequest {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:protos.CreateStepResponse)
pub struct CreateStepResponse {
    // special fields
    // @@protoc_insertion_point(special_field:protos.CreateStepResponse.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<CreateStepResponse>(
            "CreateStepResponse",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for CreateStepResponse {
    const NAME: &'static str = "CreateStepResponse";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CreateStepResponse {
        static instance: CreateStepResponse = CreateStepResponse {
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for CreateStepResponse {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("CreateStepResponse").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for CreateStepResponse {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:protos.UpdateStepRequest)
pub struct UpdateStepRequest {
    // special fields
    // @@protoc_insertion_point(special_field:protos.UpdateStepRequest.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UpdateStepRequest>(
            "UpdateStepRequest",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for UpdateStepRequest {
    const NAME: &'static str = "UpdateStepRequest";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static UpdateStepRequest {
        static instance: UpdateStepRequest = UpdateStepRequest {
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for UpdateStepRequest {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("UpdateStepRequest").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for UpdateStepRequest {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:protos.UpdateStepResponse)
pub struct UpdateStepResponse {
    // special fields
    // @@protoc_insertion_point(special_field:protos.UpdateStepResponse.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UpdateStepResponse>(
            "UpdateStepResponse",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for UpdateStepResponse {
    const NAME: &'static str = "UpdateStepResponse";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static UpdateStepResponse {
        static instance: UpdateStepResponse = UpdateStepResponse {
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for UpdateStepResponse {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("UpdateStepResponse").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for UpdateStepResponse {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:protos.DeleteStepRequest)
pub struct DeleteStepRequest {
    // special fields
    // @@protoc_insertion_point(special_field:protos.DeleteStepRequest.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<DeleteStepRequest>(
            "DeleteStepRequest",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for DeleteStepRequest {
    const NAME: &'static str = "DeleteStepRequest";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static DeleteStepRequest {
        static instance: DeleteStepRequest = DeleteStepRequest {
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for DeleteStepRequest {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("DeleteStepRequest").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for DeleteStepRequest {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:protos.DeleteStepResponse)
pub struct DeleteStepResponse {
    // special fields
    // @@protoc_insertion_point(special_field:protos.DeleteStepResponse.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<DeleteStepResponse>(
            "DeleteStepResponse",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for DeleteStepResponse {
    const NAME: &'static str = "DeleteStepResponse";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static DeleteStepResponse {
        static instance: DeleteStepResponse = DeleteStepResponse {
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for DeleteStepResponse {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("DeleteStepResponse").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for DeleteStepResponse {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x11grpc_public.proto\x12\x06protos\"\x14\n\x12GetServicesRequest\"\
    \x15\n\x13GetServicesResponse\"\x15\n\x13GetPipelinesRequest\"\x16\n\x14\
    GetPipelinesResponse\"\x14\n\x12GetPipelineRequest\"\x15\n\x13GetPipelin\
    eResponse\"\x17\n\x15UpdatePipelineRequest\"\x18\n\x16UpdatePipelineResp\
    onse\"\x17\n\x15DeletePipelineRequest\"\x18\n\x16DeletePipelineResponse\
    \"\x11\n\x0fGetStepsRequest\"\x12\n\x10GetStepsResponse\"\x13\n\x11Creat\
    eStepRequest\"\x14\n\x12CreateStepResponse\"\x13\n\x11UpdateStepRequest\
    \"\x14\n\x12UpdateStepResponse\"\x13\n\x11DeleteStepRequest\"\x14\n\x12D\
    eleteStepResponse2\x93\x05\n\x06Public\x12F\n\x0bGetServices\x12\x1a.pro\
    tos.GetServicesRequest\x1a\x1b.protos.GetServicesResponse\x12I\n\x0cGetP\
    ipelines\x12\x1b.protos.GetPipelinesRequest\x1a\x1c.protos.GetPipelinesR\
    esponse\x12F\n\x0bGetPipeline\x12\x1a.protos.GetPipelineRequest\x1a\x1b.\
    protos.GetPipelineResponse\x12O\n\x0eUpdatePipeline\x12\x1d.protos.Updat\
    ePipelineRequest\x1a\x1e.protos.UpdatePipelineResponse\x12O\n\x0eDeleteP\
    ipeline\x12\x1d.protos.DeletePipelineRequest\x1a\x1e.protos.DeletePipeli\
    neResponse\x12=\n\x08GetSteps\x12\x17.protos.GetStepsRequest\x1a\x18.pro\
    tos.GetStepsResponse\x12C\n\nCreateStep\x12\x19.protos.CreateStepRequest\
    \x1a\x1a.protos.CreateStepResponse\x12C\n\nUpdateStep\x12\x19.protos.Upd\
    ateStepRequest\x1a\x1a.protos.UpdateStepResponse\x12C\n\nDeleteStep\x12\
    \x19.protos.DeleteStepRequest\x1a\x1a.protos.DeleteStepResponseB4Z2githu\
    b.com/streamdal/snitch-protos/build/go/protosJ\xdd\t\n\x06\x12\x04\0\05\
    \x1d\n\x08\n\x01\x0c\x12\x03\0\0\x12\n\x08\n\x01\x02\x12\x03\x02\0\x0f\n\
    \x08\n\x01\x08\x12\x03\x04\0I\n\t\n\x02\x08\x0b\x12\x03\x04\0I\n\n\n\x02\
    \x06\0\x12\x04\x06\0!\x01\n\n\n\x03\x06\0\x01\x12\x03\x06\x08\x0e\n\"\n\
    \x04\x06\0\x02\0\x12\x03\x08\x02D\x1a\x15\x20Build\x20a\x20service\x20ma\
    p\n\n\x0c\n\x05\x06\0\x02\0\x01\x12\x03\x08\x06\x11\n\x0c\n\x05\x06\0\
    \x02\0\x02\x12\x03\x08\x12$\n\x0c\n\x05\x06\0\x02\0\x03\x12\x03\x08/B\n*\
    \n\x04\x06\0\x02\x01\x12\x03\x0b\x02G\x1a\x1d\x20Get\x20all\x20available\
    \x20pipelines\n\n\x0c\n\x05\x06\0\x02\x01\x01\x12\x03\x0b\x06\x12\n\x0c\
    \n\x05\x06\0\x02\x01\x02\x12\x03\x0b\x13&\n\x0c\n\x05\x06\0\x02\x01\x03\
    \x12\x03\x0b1E\n-\n\x04\x06\0\x02\x02\x12\x03\x0e\x02D\x1a\x20\x20Get\
    \x20a\x20pipeline\x20(and\x20its\x20steps)\n\n\x0c\n\x05\x06\0\x02\x02\
    \x01\x12\x03\x0e\x06\x11\n\x0c\n\x05\x06\0\x02\x02\x02\x12\x03\x0e\x12$\
    \n\x0c\n\x05\x06\0\x02\x02\x03\x12\x03\x0e/B\n.\n\x04\x06\0\x02\x03\x12\
    \x03\x11\x02M\x1a!\x20Associate\x20steps\x20with\x20a\x20pipeline\n\n\
    \x0c\n\x05\x06\0\x02\x03\x01\x12\x03\x11\x06\x14\n\x0c\n\x05\x06\0\x02\
    \x03\x02\x12\x03\x11\x15*\n\x0c\n\x05\x06\0\x02\x03\x03\x12\x03\x115K\n\
    \x20\n\x04\x06\0\x02\x04\x12\x03\x14\x02M\x1a\x13\x20Delete\x20a\x20pipe\
    line\n\n\x0c\n\x05\x06\0\x02\x04\x01\x12\x03\x14\x06\x14\n\x0c\n\x05\x06\
    \0\x02\x04\x02\x12\x03\x14\x15*\n\x0c\n\x05\x06\0\x02\x04\x03\x12\x03\
    \x145K\n3\n\x04\x06\0\x02\x05\x12\x03\x17\x02;\x1a&\x20Get\x20steps\x20a\
    ssociated\x20with\x20a\x20pipeline\n\n\x0c\n\x05\x06\0\x02\x05\x01\x12\
    \x03\x17\x06\x0e\n\x0c\n\x05\x06\0\x02\x05\x02\x12\x03\x17\x0f\x1e\n\x0c\
    \n\x05\x06\0\x02\x05\x03\x12\x03\x17)9\n\x1c\n\x04\x06\0\x02\x06\x12\x03\
    \x1a\x02A\x1a\x0f\x20Create\x20a\x20step\n\n\x0c\n\x05\x06\0\x02\x06\x01\
    \x12\x03\x1a\x06\x10\n\x0c\n\x05\x06\0\x02\x06\x02\x12\x03\x1a\x11\"\n\
    \x0c\n\x05\x06\0\x02\x06\x03\x12\x03\x1a-?\n\x1c\n\x04\x06\0\x02\x07\x12\
    \x03\x1d\x02A\x1a\x0f\x20Update\x20a\x20step\n\n\x0c\n\x05\x06\0\x02\x07\
    \x01\x12\x03\x1d\x06\x10\n\x0c\n\x05\x06\0\x02\x07\x02\x12\x03\x1d\x11\"\
    \n\x0c\n\x05\x06\0\x02\x07\x03\x12\x03\x1d-?\n\x1c\n\x04\x06\0\x02\x08\
    \x12\x03\x20\x02A\x1a\x0f\x20Delete\x20a\x20step\n\n\x0c\n\x05\x06\0\x02\
    \x08\x01\x12\x03\x20\x06\x10\n\x0c\n\x05\x06\0\x02\x08\x02\x12\x03\x20\
    \x11\"\n\x0c\n\x05\x06\0\x02\x08\x03\x12\x03\x20-?\n%\n\x02\x04\0\x12\
    \x03$\0\x1d\x1a\x1a\x20protolint:disable\x20INDENT\n\n\n\n\x03\x04\0\x01\
    \x12\x03$\x08\x1a\n\t\n\x02\x04\x01\x12\x03%\0\x1e\n\n\n\x03\x04\x01\x01\
    \x12\x03%\x08\x1b\n\t\n\x02\x04\x02\x12\x03&\0\x1e\n\n\n\x03\x04\x02\x01\
    \x12\x03&\x08\x1b\n\t\n\x02\x04\x03\x12\x03'\0\x1f\n\n\n\x03\x04\x03\x01\
    \x12\x03'\x08\x1c\n\t\n\x02\x04\x04\x12\x03(\0\x1d\n\n\n\x03\x04\x04\x01\
    \x12\x03(\x08\x1a\n\t\n\x02\x04\x05\x12\x03)\0\x1e\n\n\n\x03\x04\x05\x01\
    \x12\x03)\x08\x1b\n\t\n\x02\x04\x06\x12\x03*\0\x20\n\n\n\x03\x04\x06\x01\
    \x12\x03*\x08\x1d\n\t\n\x02\x04\x07\x12\x03+\0!\n\n\n\x03\x04\x07\x01\
    \x12\x03+\x08\x1e\n\t\n\x02\x04\x08\x12\x03,\0\x20\n\n\n\x03\x04\x08\x01\
    \x12\x03,\x08\x1d\n\t\n\x02\x04\t\x12\x03-\0!\n\n\n\x03\x04\t\x01\x12\
    \x03-\x08\x1e\n\t\n\x02\x04\n\x12\x03.\0\x1a\n\n\n\x03\x04\n\x01\x12\x03\
    .\x08\x17\n\t\n\x02\x04\x0b\x12\x03/\0\x1b\n\n\n\x03\x04\x0b\x01\x12\x03\
    /\x08\x18\n\t\n\x02\x04\x0c\x12\x030\0\x1c\n\n\n\x03\x04\x0c\x01\x12\x03\
    0\x08\x19\n\t\n\x02\x04\r\x12\x031\0\x1c\n\n\n\x03\x04\r\x01\x12\x031\
    \x08\x1a\n\t\n\x02\x04\x0e\x12\x032\0\x1c\n\n\n\x03\x04\x0e\x01\x12\x032\
    \x08\x19\n\t\n\x02\x04\x0f\x12\x033\0\x1d\n\n\n\x03\x04\x0f\x01\x12\x033\
    \x08\x1a\n\t\n\x02\x04\x10\x12\x034\0\x1c\n\n\n\x03\x04\x10\x01\x12\x034\
    \x08\x19\n\t\n\x02\x04\x11\x12\x035\0\x1d\n\n\n\x03\x04\x11\x01\x12\x035\
    \x08\x1ab\x06proto3\
";

/// `FileDescriptorProto` object which was a source for this generated file
fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
    file_descriptor_proto_lazy.get(|| {
        ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
    })
}

/// `FileDescriptor` object which allows dynamic access to files
pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
    static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
    static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
    file_descriptor.get(|| {
        let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
            let mut deps = ::std::vec::Vec::with_capacity(0);
            let mut messages = ::std::vec::Vec::with_capacity(18);
            messages.push(GetServicesRequest::generated_message_descriptor_data());
            messages.push(GetServicesResponse::generated_message_descriptor_data());
            messages.push(GetPipelinesRequest::generated_message_descriptor_data());
            messages.push(GetPipelinesResponse::generated_message_descriptor_data());
            messages.push(GetPipelineRequest::generated_message_descriptor_data());
            messages.push(GetPipelineResponse::generated_message_descriptor_data());
            messages.push(UpdatePipelineRequest::generated_message_descriptor_data());
            messages.push(UpdatePipelineResponse::generated_message_descriptor_data());
            messages.push(DeletePipelineRequest::generated_message_descriptor_data());
            messages.push(DeletePipelineResponse::generated_message_descriptor_data());
            messages.push(GetStepsRequest::generated_message_descriptor_data());
            messages.push(GetStepsResponse::generated_message_descriptor_data());
            messages.push(CreateStepRequest::generated_message_descriptor_data());
            messages.push(CreateStepResponse::generated_message_descriptor_data());
            messages.push(UpdateStepRequest::generated_message_descriptor_data());
            messages.push(UpdateStepResponse::generated_message_descriptor_data());
            messages.push(DeleteStepRequest::generated_message_descriptor_data());
            messages.push(DeleteStepResponse::generated_message_descriptor_data());
            let mut enums = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
                file_descriptor_proto(),
                deps,
                messages,
                enums,
            )
        });
        ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
    })
}