helm-api 0.1.0

// This file is generated by rust-protobuf 2.7.0. 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 `hapi/services/tiller.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_7_0;

#[derive(PartialEq,Clone,Default)]
pub struct ListReleasesRequest {
    // message fields
    pub limit: i64,
    pub offset: ::std::string::String,
    pub sort_by: ListSort_SortBy,
    pub filter: ::std::string::String,
    pub sort_order: ListSort_SortOrder,
    pub status_codes: ::std::vec::Vec<super::status::Status_Code>,
    pub namespace: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // int64 limit = 1;


    pub fn get_limit(&self) -> i64 {
        self.limit
    }
    pub fn clear_limit(&mut self) {
        self.limit = 0;
    }

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

    // string offset = 2;


    pub fn get_offset(&self) -> &str {
        &self.offset
    }
    pub fn clear_offset(&mut self) {
        self.offset.clear();
    }

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

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

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

    // .hapi.services.tiller.ListSort.SortBy sort_by = 3;


    pub fn get_sort_by(&self) -> ListSort_SortBy {
        self.sort_by
    }
    pub fn clear_sort_by(&mut self) {
        self.sort_by = ListSort_SortBy::UNKNOWN;
    }

    // Param is passed by value, moved
    pub fn set_sort_by(&mut self, v: ListSort_SortBy) {
        self.sort_by = v;
    }

    // string filter = 4;


    pub fn get_filter(&self) -> &str {
        &self.filter
    }
    pub fn clear_filter(&mut self) {
        self.filter.clear();
    }

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

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

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

    // .hapi.services.tiller.ListSort.SortOrder sort_order = 5;


    pub fn get_sort_order(&self) -> ListSort_SortOrder {
        self.sort_order
    }
    pub fn clear_sort_order(&mut self) {
        self.sort_order = ListSort_SortOrder::ASC;
    }

    // Param is passed by value, moved
    pub fn set_sort_order(&mut self, v: ListSort_SortOrder) {
        self.sort_order = v;
    }

    // repeated .hapi.release.Status.Code status_codes = 6;


    pub fn get_status_codes(&self) -> &[super::status::Status_Code] {
        &self.status_codes
    }
    pub fn clear_status_codes(&mut self) {
        self.status_codes.clear();
    }

    // Param is passed by value, moved
    pub fn set_status_codes(&mut self, v: ::std::vec::Vec<super::status::Status_Code>) {
        self.status_codes = v;
    }

    // Mutable pointer to the field.
    pub fn mut_status_codes(&mut self) -> &mut ::std::vec::Vec<super::status::Status_Code> {
        &mut self.status_codes
    }

    // Take field
    pub fn take_status_codes(&mut self) -> ::std::vec::Vec<super::status::Status_Code> {
        ::std::mem::replace(&mut self.status_codes, ::std::vec::Vec::new())
    }

    // string namespace = 7;


    pub fn get_namespace(&self) -> &str {
        &self.namespace
    }
    pub fn clear_namespace(&mut self) {
        self.namespace.clear();
    }

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

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

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

impl ::protobuf::Message for ListReleasesRequest {
    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.limit = tmp;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.offset)?;
                },
                3 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.sort_by, 3, &mut self.unknown_fields)?
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.filter)?;
                },
                5 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.sort_order, 5, &mut self.unknown_fields)?
                },
                6 => {
                    ::protobuf::rt::read_repeated_enum_with_unknown_fields_into(wire_type, is, &mut self.status_codes, 6, &mut self.unknown_fields)?
                },
                7 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.namespace)?;
                },
                _ => {
                    ::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.limit != 0 {
            my_size += ::protobuf::rt::value_size(1, self.limit, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.offset.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.offset);
        }
        if self.sort_by != ListSort_SortBy::UNKNOWN {
            my_size += ::protobuf::rt::enum_size(3, self.sort_by);
        }
        if !self.filter.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.filter);
        }
        if self.sort_order != ListSort_SortOrder::ASC {
            my_size += ::protobuf::rt::enum_size(5, self.sort_order);
        }
        for value in &self.status_codes {
            my_size += ::protobuf::rt::enum_size(6, *value);
        };
        if !self.namespace.is_empty() {
            my_size += ::protobuf::rt::string_size(7, &self.namespace);
        }
        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.limit != 0 {
            os.write_int64(1, self.limit)?;
        }
        if !self.offset.is_empty() {
            os.write_string(2, &self.offset)?;
        }
        if self.sort_by != ListSort_SortBy::UNKNOWN {
            os.write_enum(3, self.sort_by.value())?;
        }
        if !self.filter.is_empty() {
            os.write_string(4, &self.filter)?;
        }
        if self.sort_order != ListSort_SortOrder::ASC {
            os.write_enum(5, self.sort_order.value())?;
        }
        for v in &self.status_codes {
            os.write_enum(6, v.value())?;
        };
        if !self.namespace.is_empty() {
            os.write_string(7, &self.namespace)?;
        }
        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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> ListReleasesRequest {
        ListReleasesRequest::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>(
                    "limit",
                    |m: &ListReleasesRequest| { &m.limit },
                    |m: &mut ListReleasesRequest| { &mut m.limit },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "offset",
                    |m: &ListReleasesRequest| { &m.offset },
                    |m: &mut ListReleasesRequest| { &mut m.offset },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<ListSort_SortBy>>(
                    "sort_by",
                    |m: &ListReleasesRequest| { &m.sort_by },
                    |m: &mut ListReleasesRequest| { &mut m.sort_by },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "filter",
                    |m: &ListReleasesRequest| { &m.filter },
                    |m: &mut ListReleasesRequest| { &mut m.filter },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<ListSort_SortOrder>>(
                    "sort_order",
                    |m: &ListReleasesRequest| { &m.sort_order },
                    |m: &mut ListReleasesRequest| { &mut m.sort_order },
                ));
                fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::status::Status_Code>>(
                    "status_codes",
                    |m: &ListReleasesRequest| { &m.status_codes },
                    |m: &mut ListReleasesRequest| { &mut m.status_codes },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "namespace",
                    |m: &ListReleasesRequest| { &m.namespace },
                    |m: &mut ListReleasesRequest| { &mut m.namespace },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ListReleasesRequest>(
                    "ListReleasesRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for ListReleasesRequest {
    fn clear(&mut self) {
        self.limit = 0;
        self.offset.clear();
        self.sort_by = ListSort_SortBy::UNKNOWN;
        self.filter.clear();
        self.sort_order = ListSort_SortOrder::ASC;
        self.status_codes.clear();
        self.namespace.clear();
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

impl ::protobuf::Message for ListSort {
    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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> ListSort {
        ListSort::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::<ListSort>(
                    "ListSort",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum ListSort_SortBy {
    UNKNOWN = 0,
    NAME = 1,
    LAST_RELEASED = 2,
    CHART_NAME = 3,
}

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

    fn from_i32(value: i32) -> ::std::option::Option<ListSort_SortBy> {
        match value {
            0 => ::std::option::Option::Some(ListSort_SortBy::UNKNOWN),
            1 => ::std::option::Option::Some(ListSort_SortBy::NAME),
            2 => ::std::option::Option::Some(ListSort_SortBy::LAST_RELEASED),
            3 => ::std::option::Option::Some(ListSort_SortBy::CHART_NAME),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [ListSort_SortBy] = &[
            ListSort_SortBy::UNKNOWN,
            ListSort_SortBy::NAME,
            ListSort_SortBy::LAST_RELEASED,
            ListSort_SortBy::CHART_NAME,
        ];
        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("ListSort_SortBy", file_descriptor_proto())
            })
        }
    }
}

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

impl ::std::default::Default for ListSort_SortBy {
    fn default() -> Self {
        ListSort_SortBy::UNKNOWN
    }
}

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum ListSort_SortOrder {
    ASC = 0,
    DESC = 1,
}

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

    fn from_i32(value: i32) -> ::std::option::Option<ListSort_SortOrder> {
        match value {
            0 => ::std::option::Option::Some(ListSort_SortOrder::ASC),
            1 => ::std::option::Option::Some(ListSort_SortOrder::DESC),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [ListSort_SortOrder] = &[
            ListSort_SortOrder::ASC,
            ListSort_SortOrder::DESC,
        ];
        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("ListSort_SortOrder", file_descriptor_proto())
            })
        }
    }
}

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

impl ::std::default::Default for ListSort_SortOrder {
    fn default() -> Self {
        ListSort_SortOrder::ASC
    }
}

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

#[derive(PartialEq,Clone,Default)]
pub struct ListReleasesResponse {
    // message fields
    pub count: i64,
    pub next: ::std::string::String,
    pub total: i64,
    pub releases: ::protobuf::RepeatedField<super::release::Release>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // int64 count = 1;


    pub fn get_count(&self) -> i64 {
        self.count
    }
    pub fn clear_count(&mut self) {
        self.count = 0;
    }

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

    // string next = 2;


    pub fn get_next(&self) -> &str {
        &self.next
    }
    pub fn clear_next(&mut self) {
        self.next.clear();
    }

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

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

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

    // int64 total = 3;


    pub fn get_total(&self) -> i64 {
        self.total
    }
    pub fn clear_total(&mut self) {
        self.total = 0;
    }

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

    // repeated .hapi.release.Release releases = 4;


    pub fn get_releases(&self) -> &[super::release::Release] {
        &self.releases
    }
    pub fn clear_releases(&mut self) {
        self.releases.clear();
    }

    // Param is passed by value, moved
    pub fn set_releases(&mut self, v: ::protobuf::RepeatedField<super::release::Release>) {
        self.releases = v;
    }

    // Mutable pointer to the field.
    pub fn mut_releases(&mut self) -> &mut ::protobuf::RepeatedField<super::release::Release> {
        &mut self.releases
    }

    // Take field
    pub fn take_releases(&mut self) -> ::protobuf::RepeatedField<super::release::Release> {
        ::std::mem::replace(&mut self.releases, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for ListReleasesResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.releases {
            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.count = tmp;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next)?;
                },
                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.total = tmp;
                },
                4 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.releases)?;
                },
                _ => {
                    ::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.count != 0 {
            my_size += ::protobuf::rt::value_size(1, self.count, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.next.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.next);
        }
        if self.total != 0 {
            my_size += ::protobuf::rt::value_size(3, self.total, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.releases {
            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.count != 0 {
            os.write_int64(1, self.count)?;
        }
        if !self.next.is_empty() {
            os.write_string(2, &self.next)?;
        }
        if self.total != 0 {
            os.write_int64(3, self.total)?;
        }
        for v in &self.releases {
            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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> ListReleasesResponse {
        ListReleasesResponse::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>(
                    "count",
                    |m: &ListReleasesResponse| { &m.count },
                    |m: &mut ListReleasesResponse| { &mut m.count },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "next",
                    |m: &ListReleasesResponse| { &m.next },
                    |m: &mut ListReleasesResponse| { &mut m.next },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "total",
                    |m: &ListReleasesResponse| { &m.total },
                    |m: &mut ListReleasesResponse| { &mut m.total },
                ));
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::release::Release>>(
                    "releases",
                    |m: &ListReleasesResponse| { &m.releases },
                    |m: &mut ListReleasesResponse| { &mut m.releases },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ListReleasesResponse>(
                    "ListReleasesResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for ListReleasesResponse {
    fn clear(&mut self) {
        self.count = 0;
        self.next.clear();
        self.total = 0;
        self.releases.clear();
        self.unknown_fields.clear();
    }
}

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

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

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

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

impl GetReleaseStatusRequest {
    pub fn new() -> GetReleaseStatusRequest {
        ::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())
    }

    // 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;
    }
}

impl ::protobuf::Message for GetReleaseStatusRequest {
    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 => {
                    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;
                },
                _ => {
                    ::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.version != 0 {
            my_size += ::protobuf::rt::value_size(2, self.version, ::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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if self.version != 0 {
            os.write_int32(2, self.version)?;
        }
        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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> GetReleaseStatusRequest {
        GetReleaseStatusRequest::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: &GetReleaseStatusRequest| { &m.name },
                    |m: &mut GetReleaseStatusRequest| { &mut m.name },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                    "version",
                    |m: &GetReleaseStatusRequest| { &m.version },
                    |m: &mut GetReleaseStatusRequest| { &mut m.version },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<GetReleaseStatusRequest>(
                    "GetReleaseStatusRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for GetReleaseStatusRequest {
    fn clear(&mut self) {
        self.name.clear();
        self.version = 0;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct GetReleaseStatusResponse {
    // message fields
    pub name: ::std::string::String,
    pub info: ::protobuf::SingularPtrField<super::info::Info>,
    pub namespace: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

impl GetReleaseStatusResponse {
    pub fn new() -> GetReleaseStatusResponse {
        ::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())
    }

    // .hapi.release.Info info = 2;


    pub fn get_info(&self) -> &super::info::Info {
        self.info.as_ref().unwrap_or_else(|| super::info::Info::default_instance())
    }
    pub fn clear_info(&mut self) {
        self.info.clear();
    }

    pub fn has_info(&self) -> bool {
        self.info.is_some()
    }

    // Param is passed by value, moved
    pub fn set_info(&mut self, v: super::info::Info) {
        self.info = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_info(&mut self) -> &mut super::info::Info {
        if self.info.is_none() {
            self.info.set_default();
        }
        self.info.as_mut().unwrap()
    }

    // Take field
    pub fn take_info(&mut self) -> super::info::Info {
        self.info.take().unwrap_or_else(|| super::info::Info::new())
    }

    // string namespace = 3;


    pub fn get_namespace(&self) -> &str {
        &self.namespace
    }
    pub fn clear_namespace(&mut self) {
        self.namespace.clear();
    }

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

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

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

impl ::protobuf::Message for GetReleaseStatusResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.info {
            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_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.info)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.namespace)?;
                },
                _ => {
                    ::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 let Some(ref v) = self.info.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if !self.namespace.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.namespace);
        }
        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 let Some(ref v) = self.info.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if !self.namespace.is_empty() {
            os.write_string(3, &self.namespace)?;
        }
        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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> GetReleaseStatusResponse {
        GetReleaseStatusResponse::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: &GetReleaseStatusResponse| { &m.name },
                    |m: &mut GetReleaseStatusResponse| { &mut m.name },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::info::Info>>(
                    "info",
                    |m: &GetReleaseStatusResponse| { &m.info },
                    |m: &mut GetReleaseStatusResponse| { &mut m.info },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "namespace",
                    |m: &GetReleaseStatusResponse| { &m.namespace },
                    |m: &mut GetReleaseStatusResponse| { &mut m.namespace },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<GetReleaseStatusResponse>(
                    "GetReleaseStatusResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for GetReleaseStatusResponse {
    fn clear(&mut self) {
        self.name.clear();
        self.info.clear();
        self.namespace.clear();
        self.unknown_fields.clear();
    }
}

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

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

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

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

impl GetReleaseContentRequest {
    pub fn new() -> GetReleaseContentRequest {
        ::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())
    }

    // 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;
    }
}

impl ::protobuf::Message for GetReleaseContentRequest {
    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 => {
                    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;
                },
                _ => {
                    ::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.version != 0 {
            my_size += ::protobuf::rt::value_size(2, self.version, ::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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if self.version != 0 {
            os.write_int32(2, self.version)?;
        }
        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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> GetReleaseContentRequest {
        GetReleaseContentRequest::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: &GetReleaseContentRequest| { &m.name },
                    |m: &mut GetReleaseContentRequest| { &mut m.name },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                    "version",
                    |m: &GetReleaseContentRequest| { &m.version },
                    |m: &mut GetReleaseContentRequest| { &mut m.version },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<GetReleaseContentRequest>(
                    "GetReleaseContentRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for GetReleaseContentRequest {
    fn clear(&mut self) {
        self.name.clear();
        self.version = 0;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct GetReleaseContentResponse {
    // message fields
    pub release: ::protobuf::SingularPtrField<super::release::Release>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .hapi.release.Release release = 1;


    pub fn get_release(&self) -> &super::release::Release {
        self.release.as_ref().unwrap_or_else(|| super::release::Release::default_instance())
    }
    pub fn clear_release(&mut self) {
        self.release.clear();
    }

    pub fn has_release(&self) -> bool {
        self.release.is_some()
    }

    // Param is passed by value, moved
    pub fn set_release(&mut self, v: super::release::Release) {
        self.release = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_release(&mut self) -> &mut super::release::Release {
        if self.release.is_none() {
            self.release.set_default();
        }
        self.release.as_mut().unwrap()
    }

    // Take field
    pub fn take_release(&mut self) -> super::release::Release {
        self.release.take().unwrap_or_else(|| super::release::Release::new())
    }
}

impl ::protobuf::Message for GetReleaseContentResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.release {
            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_singular_message_into(wire_type, is, &mut self.release)?;
                },
                _ => {
                    ::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 let Some(ref v) = self.release.as_ref() {
            let len = v.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 let Some(ref v) = self.release.as_ref() {
            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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> GetReleaseContentResponse {
        GetReleaseContentResponse::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_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::release::Release>>(
                    "release",
                    |m: &GetReleaseContentResponse| { &m.release },
                    |m: &mut GetReleaseContentResponse| { &mut m.release },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<GetReleaseContentResponse>(
                    "GetReleaseContentResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct UpdateReleaseRequest {
    // message fields
    pub name: ::std::string::String,
    pub chart: ::protobuf::SingularPtrField<super::chart::Chart>,
    pub values: ::protobuf::SingularPtrField<super::config::Config>,
    pub dry_run: bool,
    pub disable_hooks: bool,
    pub recreate: bool,
    pub timeout: i64,
    pub reset_values: bool,
    pub wait: bool,
    pub reuse_values: bool,
    pub force: bool,
    pub description: ::std::string::String,
    pub subNotes: bool,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

impl UpdateReleaseRequest {
    pub fn new() -> UpdateReleaseRequest {
        ::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())
    }

    // .hapi.chart.Chart chart = 2;


    pub fn get_chart(&self) -> &super::chart::Chart {
        self.chart.as_ref().unwrap_or_else(|| super::chart::Chart::default_instance())
    }
    pub fn clear_chart(&mut self) {
        self.chart.clear();
    }

    pub fn has_chart(&self) -> bool {
        self.chart.is_some()
    }

    // Param is passed by value, moved
    pub fn set_chart(&mut self, v: super::chart::Chart) {
        self.chart = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_chart(&mut self) -> &mut super::chart::Chart {
        if self.chart.is_none() {
            self.chart.set_default();
        }
        self.chart.as_mut().unwrap()
    }

    // Take field
    pub fn take_chart(&mut self) -> super::chart::Chart {
        self.chart.take().unwrap_or_else(|| super::chart::Chart::new())
    }

    // .hapi.chart.Config values = 3;


    pub fn get_values(&self) -> &super::config::Config {
        self.values.as_ref().unwrap_or_else(|| super::config::Config::default_instance())
    }
    pub fn clear_values(&mut self) {
        self.values.clear();
    }

    pub fn has_values(&self) -> bool {
        self.values.is_some()
    }

    // Param is passed by value, moved
    pub fn set_values(&mut self, v: super::config::Config) {
        self.values = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_values(&mut self) -> &mut super::config::Config {
        if self.values.is_none() {
            self.values.set_default();
        }
        self.values.as_mut().unwrap()
    }

    // Take field
    pub fn take_values(&mut self) -> super::config::Config {
        self.values.take().unwrap_or_else(|| super::config::Config::new())
    }

    // bool dry_run = 4;


    pub fn get_dry_run(&self) -> bool {
        self.dry_run
    }
    pub fn clear_dry_run(&mut self) {
        self.dry_run = false;
    }

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

    // bool disable_hooks = 5;


    pub fn get_disable_hooks(&self) -> bool {
        self.disable_hooks
    }
    pub fn clear_disable_hooks(&mut self) {
        self.disable_hooks = false;
    }

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

    // bool recreate = 6;


    pub fn get_recreate(&self) -> bool {
        self.recreate
    }
    pub fn clear_recreate(&mut self) {
        self.recreate = false;
    }

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

    // int64 timeout = 7;


    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;
    }

    // bool reset_values = 8;


    pub fn get_reset_values(&self) -> bool {
        self.reset_values
    }
    pub fn clear_reset_values(&mut self) {
        self.reset_values = false;
    }

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

    // bool wait = 9;


    pub fn get_wait(&self) -> bool {
        self.wait
    }
    pub fn clear_wait(&mut self) {
        self.wait = false;
    }

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

    // bool reuse_values = 10;


    pub fn get_reuse_values(&self) -> bool {
        self.reuse_values
    }
    pub fn clear_reuse_values(&mut self) {
        self.reuse_values = false;
    }

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

    // bool force = 11;


    pub fn get_force(&self) -> bool {
        self.force
    }
    pub fn clear_force(&mut self) {
        self.force = false;
    }

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

    // string description = 12;


    pub fn get_description(&self) -> &str {
        &self.description
    }
    pub fn clear_description(&mut self) {
        self.description.clear();
    }

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

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

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

    // bool subNotes = 13;


    pub fn get_subNotes(&self) -> bool {
        self.subNotes
    }
    pub fn clear_subNotes(&mut self) {
        self.subNotes = false;
    }

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

impl ::protobuf::Message for UpdateReleaseRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.chart {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.values {
            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_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.chart)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.values)?;
                },
                4 => {
                    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.dry_run = tmp;
                },
                5 => {
                    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.disable_hooks = 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_bool()?;
                    self.recreate = tmp;
                },
                7 => {
                    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;
                },
                8 => {
                    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.reset_values = tmp;
                },
                9 => {
                    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.wait = tmp;
                },
                10 => {
                    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.reuse_values = tmp;
                },
                11 => {
                    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.force = tmp;
                },
                12 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.description)?;
                },
                13 => {
                    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.subNotes = 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.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if let Some(ref v) = self.chart.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.values.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if self.dry_run != false {
            my_size += 2;
        }
        if self.disable_hooks != false {
            my_size += 2;
        }
        if self.recreate != false {
            my_size += 2;
        }
        if self.timeout != 0 {
            my_size += ::protobuf::rt::value_size(7, self.timeout, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.reset_values != false {
            my_size += 2;
        }
        if self.wait != false {
            my_size += 2;
        }
        if self.reuse_values != false {
            my_size += 2;
        }
        if self.force != false {
            my_size += 2;
        }
        if !self.description.is_empty() {
            my_size += ::protobuf::rt::string_size(12, &self.description);
        }
        if self.subNotes != 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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if let Some(ref v) = self.chart.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.values.as_ref() {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if self.dry_run != false {
            os.write_bool(4, self.dry_run)?;
        }
        if self.disable_hooks != false {
            os.write_bool(5, self.disable_hooks)?;
        }
        if self.recreate != false {
            os.write_bool(6, self.recreate)?;
        }
        if self.timeout != 0 {
            os.write_int64(7, self.timeout)?;
        }
        if self.reset_values != false {
            os.write_bool(8, self.reset_values)?;
        }
        if self.wait != false {
            os.write_bool(9, self.wait)?;
        }
        if self.reuse_values != false {
            os.write_bool(10, self.reuse_values)?;
        }
        if self.force != false {
            os.write_bool(11, self.force)?;
        }
        if !self.description.is_empty() {
            os.write_string(12, &self.description)?;
        }
        if self.subNotes != false {
            os.write_bool(13, self.subNotes)?;
        }
        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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> UpdateReleaseRequest {
        UpdateReleaseRequest::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: &UpdateReleaseRequest| { &m.name },
                    |m: &mut UpdateReleaseRequest| { &mut m.name },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::chart::Chart>>(
                    "chart",
                    |m: &UpdateReleaseRequest| { &m.chart },
                    |m: &mut UpdateReleaseRequest| { &mut m.chart },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::config::Config>>(
                    "values",
                    |m: &UpdateReleaseRequest| { &m.values },
                    |m: &mut UpdateReleaseRequest| { &mut m.values },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "dry_run",
                    |m: &UpdateReleaseRequest| { &m.dry_run },
                    |m: &mut UpdateReleaseRequest| { &mut m.dry_run },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "disable_hooks",
                    |m: &UpdateReleaseRequest| { &m.disable_hooks },
                    |m: &mut UpdateReleaseRequest| { &mut m.disable_hooks },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "recreate",
                    |m: &UpdateReleaseRequest| { &m.recreate },
                    |m: &mut UpdateReleaseRequest| { &mut m.recreate },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "timeout",
                    |m: &UpdateReleaseRequest| { &m.timeout },
                    |m: &mut UpdateReleaseRequest| { &mut m.timeout },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "reset_values",
                    |m: &UpdateReleaseRequest| { &m.reset_values },
                    |m: &mut UpdateReleaseRequest| { &mut m.reset_values },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "wait",
                    |m: &UpdateReleaseRequest| { &m.wait },
                    |m: &mut UpdateReleaseRequest| { &mut m.wait },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "reuse_values",
                    |m: &UpdateReleaseRequest| { &m.reuse_values },
                    |m: &mut UpdateReleaseRequest| { &mut m.reuse_values },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "force",
                    |m: &UpdateReleaseRequest| { &m.force },
                    |m: &mut UpdateReleaseRequest| { &mut m.force },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "description",
                    |m: &UpdateReleaseRequest| { &m.description },
                    |m: &mut UpdateReleaseRequest| { &mut m.description },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "subNotes",
                    |m: &UpdateReleaseRequest| { &m.subNotes },
                    |m: &mut UpdateReleaseRequest| { &mut m.subNotes },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<UpdateReleaseRequest>(
                    "UpdateReleaseRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for UpdateReleaseRequest {
    fn clear(&mut self) {
        self.name.clear();
        self.chart.clear();
        self.values.clear();
        self.dry_run = false;
        self.disable_hooks = false;
        self.recreate = false;
        self.timeout = 0;
        self.reset_values = false;
        self.wait = false;
        self.reuse_values = false;
        self.force = false;
        self.description.clear();
        self.subNotes = false;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct UpdateReleaseResponse {
    // message fields
    pub release: ::protobuf::SingularPtrField<super::release::Release>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .hapi.release.Release release = 1;


    pub fn get_release(&self) -> &super::release::Release {
        self.release.as_ref().unwrap_or_else(|| super::release::Release::default_instance())
    }
    pub fn clear_release(&mut self) {
        self.release.clear();
    }

    pub fn has_release(&self) -> bool {
        self.release.is_some()
    }

    // Param is passed by value, moved
    pub fn set_release(&mut self, v: super::release::Release) {
        self.release = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_release(&mut self) -> &mut super::release::Release {
        if self.release.is_none() {
            self.release.set_default();
        }
        self.release.as_mut().unwrap()
    }

    // Take field
    pub fn take_release(&mut self) -> super::release::Release {
        self.release.take().unwrap_or_else(|| super::release::Release::new())
    }
}

impl ::protobuf::Message for UpdateReleaseResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.release {
            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_singular_message_into(wire_type, is, &mut self.release)?;
                },
                _ => {
                    ::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 let Some(ref v) = self.release.as_ref() {
            let len = v.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 let Some(ref v) = self.release.as_ref() {
            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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> UpdateReleaseResponse {
        UpdateReleaseResponse::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_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::release::Release>>(
                    "release",
                    |m: &UpdateReleaseResponse| { &m.release },
                    |m: &mut UpdateReleaseResponse| { &mut m.release },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<UpdateReleaseResponse>(
                    "UpdateReleaseResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct RollbackReleaseRequest {
    // message fields
    pub name: ::std::string::String,
    pub dry_run: bool,
    pub disable_hooks: bool,
    pub version: i32,
    pub recreate: bool,
    pub timeout: i64,
    pub wait: bool,
    pub force: bool,
    pub description: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

impl RollbackReleaseRequest {
    pub fn new() -> RollbackReleaseRequest {
        ::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())
    }

    // bool dry_run = 2;


    pub fn get_dry_run(&self) -> bool {
        self.dry_run
    }
    pub fn clear_dry_run(&mut self) {
        self.dry_run = false;
    }

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

    // bool disable_hooks = 3;


    pub fn get_disable_hooks(&self) -> bool {
        self.disable_hooks
    }
    pub fn clear_disable_hooks(&mut self) {
        self.disable_hooks = false;
    }

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

    // int32 version = 4;


    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;
    }

    // bool recreate = 5;


    pub fn get_recreate(&self) -> bool {
        self.recreate
    }
    pub fn clear_recreate(&mut self) {
        self.recreate = false;
    }

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

    // int64 timeout = 6;


    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;
    }

    // bool wait = 7;


    pub fn get_wait(&self) -> bool {
        self.wait
    }
    pub fn clear_wait(&mut self) {
        self.wait = false;
    }

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

    // bool force = 8;


    pub fn get_force(&self) -> bool {
        self.force
    }
    pub fn clear_force(&mut self) {
        self.force = false;
    }

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

    // string description = 9;


    pub fn get_description(&self) -> &str {
        &self.description
    }
    pub fn clear_description(&mut self) {
        self.description.clear();
    }

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

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

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

impl ::protobuf::Message for RollbackReleaseRequest {
    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 => {
                    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.dry_run = 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_bool()?;
                    self.disable_hooks = 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.version = tmp;
                },
                5 => {
                    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.recreate = 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.timeout = tmp;
                },
                7 => {
                    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.wait = tmp;
                },
                8 => {
                    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.force = tmp;
                },
                9 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.description)?;
                },
                _ => {
                    ::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.dry_run != false {
            my_size += 2;
        }
        if self.disable_hooks != false {
            my_size += 2;
        }
        if self.version != 0 {
            my_size += ::protobuf::rt::value_size(4, self.version, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.recreate != false {
            my_size += 2;
        }
        if self.timeout != 0 {
            my_size += ::protobuf::rt::value_size(6, self.timeout, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.wait != false {
            my_size += 2;
        }
        if self.force != false {
            my_size += 2;
        }
        if !self.description.is_empty() {
            my_size += ::protobuf::rt::string_size(9, &self.description);
        }
        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.dry_run != false {
            os.write_bool(2, self.dry_run)?;
        }
        if self.disable_hooks != false {
            os.write_bool(3, self.disable_hooks)?;
        }
        if self.version != 0 {
            os.write_int32(4, self.version)?;
        }
        if self.recreate != false {
            os.write_bool(5, self.recreate)?;
        }
        if self.timeout != 0 {
            os.write_int64(6, self.timeout)?;
        }
        if self.wait != false {
            os.write_bool(7, self.wait)?;
        }
        if self.force != false {
            os.write_bool(8, self.force)?;
        }
        if !self.description.is_empty() {
            os.write_string(9, &self.description)?;
        }
        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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> RollbackReleaseRequest {
        RollbackReleaseRequest::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: &RollbackReleaseRequest| { &m.name },
                    |m: &mut RollbackReleaseRequest| { &mut m.name },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "dry_run",
                    |m: &RollbackReleaseRequest| { &m.dry_run },
                    |m: &mut RollbackReleaseRequest| { &mut m.dry_run },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "disable_hooks",
                    |m: &RollbackReleaseRequest| { &m.disable_hooks },
                    |m: &mut RollbackReleaseRequest| { &mut m.disable_hooks },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                    "version",
                    |m: &RollbackReleaseRequest| { &m.version },
                    |m: &mut RollbackReleaseRequest| { &mut m.version },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "recreate",
                    |m: &RollbackReleaseRequest| { &m.recreate },
                    |m: &mut RollbackReleaseRequest| { &mut m.recreate },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "timeout",
                    |m: &RollbackReleaseRequest| { &m.timeout },
                    |m: &mut RollbackReleaseRequest| { &mut m.timeout },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "wait",
                    |m: &RollbackReleaseRequest| { &m.wait },
                    |m: &mut RollbackReleaseRequest| { &mut m.wait },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "force",
                    |m: &RollbackReleaseRequest| { &m.force },
                    |m: &mut RollbackReleaseRequest| { &mut m.force },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "description",
                    |m: &RollbackReleaseRequest| { &m.description },
                    |m: &mut RollbackReleaseRequest| { &mut m.description },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<RollbackReleaseRequest>(
                    "RollbackReleaseRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for RollbackReleaseRequest {
    fn clear(&mut self) {
        self.name.clear();
        self.dry_run = false;
        self.disable_hooks = false;
        self.version = 0;
        self.recreate = false;
        self.timeout = 0;
        self.wait = false;
        self.force = false;
        self.description.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct RollbackReleaseResponse {
    // message fields
    pub release: ::protobuf::SingularPtrField<super::release::Release>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .hapi.release.Release release = 1;


    pub fn get_release(&self) -> &super::release::Release {
        self.release.as_ref().unwrap_or_else(|| super::release::Release::default_instance())
    }
    pub fn clear_release(&mut self) {
        self.release.clear();
    }

    pub fn has_release(&self) -> bool {
        self.release.is_some()
    }

    // Param is passed by value, moved
    pub fn set_release(&mut self, v: super::release::Release) {
        self.release = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_release(&mut self) -> &mut super::release::Release {
        if self.release.is_none() {
            self.release.set_default();
        }
        self.release.as_mut().unwrap()
    }

    // Take field
    pub fn take_release(&mut self) -> super::release::Release {
        self.release.take().unwrap_or_else(|| super::release::Release::new())
    }
}

impl ::protobuf::Message for RollbackReleaseResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.release {
            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_singular_message_into(wire_type, is, &mut self.release)?;
                },
                _ => {
                    ::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 let Some(ref v) = self.release.as_ref() {
            let len = v.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 let Some(ref v) = self.release.as_ref() {
            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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> RollbackReleaseResponse {
        RollbackReleaseResponse::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_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::release::Release>>(
                    "release",
                    |m: &RollbackReleaseResponse| { &m.release },
                    |m: &mut RollbackReleaseResponse| { &mut m.release },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<RollbackReleaseResponse>(
                    "RollbackReleaseResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct InstallReleaseRequest {
    // message fields
    pub chart: ::protobuf::SingularPtrField<super::chart::Chart>,
    pub values: ::protobuf::SingularPtrField<super::config::Config>,
    pub dry_run: bool,
    pub name: ::std::string::String,
    pub disable_hooks: bool,
    pub namespace: ::std::string::String,
    pub reuse_name: bool,
    pub timeout: i64,
    pub wait: bool,
    pub disable_crd_hook: bool,
    pub description: ::std::string::String,
    pub subNotes: bool,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .hapi.chart.Chart chart = 1;


    pub fn get_chart(&self) -> &super::chart::Chart {
        self.chart.as_ref().unwrap_or_else(|| super::chart::Chart::default_instance())
    }
    pub fn clear_chart(&mut self) {
        self.chart.clear();
    }

    pub fn has_chart(&self) -> bool {
        self.chart.is_some()
    }

    // Param is passed by value, moved
    pub fn set_chart(&mut self, v: super::chart::Chart) {
        self.chart = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_chart(&mut self) -> &mut super::chart::Chart {
        if self.chart.is_none() {
            self.chart.set_default();
        }
        self.chart.as_mut().unwrap()
    }

    // Take field
    pub fn take_chart(&mut self) -> super::chart::Chart {
        self.chart.take().unwrap_or_else(|| super::chart::Chart::new())
    }

    // .hapi.chart.Config values = 2;


    pub fn get_values(&self) -> &super::config::Config {
        self.values.as_ref().unwrap_or_else(|| super::config::Config::default_instance())
    }
    pub fn clear_values(&mut self) {
        self.values.clear();
    }

    pub fn has_values(&self) -> bool {
        self.values.is_some()
    }

    // Param is passed by value, moved
    pub fn set_values(&mut self, v: super::config::Config) {
        self.values = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_values(&mut self) -> &mut super::config::Config {
        if self.values.is_none() {
            self.values.set_default();
        }
        self.values.as_mut().unwrap()
    }

    // Take field
    pub fn take_values(&mut self) -> super::config::Config {
        self.values.take().unwrap_or_else(|| super::config::Config::new())
    }

    // bool dry_run = 3;


    pub fn get_dry_run(&self) -> bool {
        self.dry_run
    }
    pub fn clear_dry_run(&mut self) {
        self.dry_run = false;
    }

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

    // string name = 4;


    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())
    }

    // bool disable_hooks = 5;


    pub fn get_disable_hooks(&self) -> bool {
        self.disable_hooks
    }
    pub fn clear_disable_hooks(&mut self) {
        self.disable_hooks = false;
    }

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

    // string namespace = 6;


    pub fn get_namespace(&self) -> &str {
        &self.namespace
    }
    pub fn clear_namespace(&mut self) {
        self.namespace.clear();
    }

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

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

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

    // bool reuse_name = 7;


    pub fn get_reuse_name(&self) -> bool {
        self.reuse_name
    }
    pub fn clear_reuse_name(&mut self) {
        self.reuse_name = false;
    }

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

    // int64 timeout = 8;


    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;
    }

    // bool wait = 9;


    pub fn get_wait(&self) -> bool {
        self.wait
    }
    pub fn clear_wait(&mut self) {
        self.wait = false;
    }

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

    // bool disable_crd_hook = 10;


    pub fn get_disable_crd_hook(&self) -> bool {
        self.disable_crd_hook
    }
    pub fn clear_disable_crd_hook(&mut self) {
        self.disable_crd_hook = false;
    }

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

    // string description = 11;


    pub fn get_description(&self) -> &str {
        &self.description
    }
    pub fn clear_description(&mut self) {
        self.description.clear();
    }

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

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

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

    // bool subNotes = 12;


    pub fn get_subNotes(&self) -> bool {
        self.subNotes
    }
    pub fn clear_subNotes(&mut self) {
        self.subNotes = false;
    }

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

impl ::protobuf::Message for InstallReleaseRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.chart {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.values {
            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_singular_message_into(wire_type, is, &mut self.chart)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.values)?;
                },
                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.dry_run = tmp;
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                },
                5 => {
                    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.disable_hooks = tmp;
                },
                6 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.namespace)?;
                },
                7 => {
                    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.reuse_name = tmp;
                },
                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.timeout = tmp;
                },
                9 => {
                    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.wait = tmp;
                },
                10 => {
                    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.disable_crd_hook = tmp;
                },
                11 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.description)?;
                },
                12 => {
                    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.subNotes = 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 let Some(ref v) = self.chart.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.values.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if self.dry_run != false {
            my_size += 2;
        }
        if !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.name);
        }
        if self.disable_hooks != false {
            my_size += 2;
        }
        if !self.namespace.is_empty() {
            my_size += ::protobuf::rt::string_size(6, &self.namespace);
        }
        if self.reuse_name != false {
            my_size += 2;
        }
        if self.timeout != 0 {
            my_size += ::protobuf::rt::value_size(8, self.timeout, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.wait != false {
            my_size += 2;
        }
        if self.disable_crd_hook != false {
            my_size += 2;
        }
        if !self.description.is_empty() {
            my_size += ::protobuf::rt::string_size(11, &self.description);
        }
        if self.subNotes != 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 let Some(ref v) = self.chart.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.values.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if self.dry_run != false {
            os.write_bool(3, self.dry_run)?;
        }
        if !self.name.is_empty() {
            os.write_string(4, &self.name)?;
        }
        if self.disable_hooks != false {
            os.write_bool(5, self.disable_hooks)?;
        }
        if !self.namespace.is_empty() {
            os.write_string(6, &self.namespace)?;
        }
        if self.reuse_name != false {
            os.write_bool(7, self.reuse_name)?;
        }
        if self.timeout != 0 {
            os.write_int64(8, self.timeout)?;
        }
        if self.wait != false {
            os.write_bool(9, self.wait)?;
        }
        if self.disable_crd_hook != false {
            os.write_bool(10, self.disable_crd_hook)?;
        }
        if !self.description.is_empty() {
            os.write_string(11, &self.description)?;
        }
        if self.subNotes != false {
            os.write_bool(12, self.subNotes)?;
        }
        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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> InstallReleaseRequest {
        InstallReleaseRequest::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_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::chart::Chart>>(
                    "chart",
                    |m: &InstallReleaseRequest| { &m.chart },
                    |m: &mut InstallReleaseRequest| { &mut m.chart },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::config::Config>>(
                    "values",
                    |m: &InstallReleaseRequest| { &m.values },
                    |m: &mut InstallReleaseRequest| { &mut m.values },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "dry_run",
                    |m: &InstallReleaseRequest| { &m.dry_run },
                    |m: &mut InstallReleaseRequest| { &mut m.dry_run },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "name",
                    |m: &InstallReleaseRequest| { &m.name },
                    |m: &mut InstallReleaseRequest| { &mut m.name },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "disable_hooks",
                    |m: &InstallReleaseRequest| { &m.disable_hooks },
                    |m: &mut InstallReleaseRequest| { &mut m.disable_hooks },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "namespace",
                    |m: &InstallReleaseRequest| { &m.namespace },
                    |m: &mut InstallReleaseRequest| { &mut m.namespace },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "reuse_name",
                    |m: &InstallReleaseRequest| { &m.reuse_name },
                    |m: &mut InstallReleaseRequest| { &mut m.reuse_name },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "timeout",
                    |m: &InstallReleaseRequest| { &m.timeout },
                    |m: &mut InstallReleaseRequest| { &mut m.timeout },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "wait",
                    |m: &InstallReleaseRequest| { &m.wait },
                    |m: &mut InstallReleaseRequest| { &mut m.wait },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "disable_crd_hook",
                    |m: &InstallReleaseRequest| { &m.disable_crd_hook },
                    |m: &mut InstallReleaseRequest| { &mut m.disable_crd_hook },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "description",
                    |m: &InstallReleaseRequest| { &m.description },
                    |m: &mut InstallReleaseRequest| { &mut m.description },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "subNotes",
                    |m: &InstallReleaseRequest| { &m.subNotes },
                    |m: &mut InstallReleaseRequest| { &mut m.subNotes },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<InstallReleaseRequest>(
                    "InstallReleaseRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for InstallReleaseRequest {
    fn clear(&mut self) {
        self.chart.clear();
        self.values.clear();
        self.dry_run = false;
        self.name.clear();
        self.disable_hooks = false;
        self.namespace.clear();
        self.reuse_name = false;
        self.timeout = 0;
        self.wait = false;
        self.disable_crd_hook = false;
        self.description.clear();
        self.subNotes = false;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct InstallReleaseResponse {
    // message fields
    pub release: ::protobuf::SingularPtrField<super::release::Release>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .hapi.release.Release release = 1;


    pub fn get_release(&self) -> &super::release::Release {
        self.release.as_ref().unwrap_or_else(|| super::release::Release::default_instance())
    }
    pub fn clear_release(&mut self) {
        self.release.clear();
    }

    pub fn has_release(&self) -> bool {
        self.release.is_some()
    }

    // Param is passed by value, moved
    pub fn set_release(&mut self, v: super::release::Release) {
        self.release = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_release(&mut self) -> &mut super::release::Release {
        if self.release.is_none() {
            self.release.set_default();
        }
        self.release.as_mut().unwrap()
    }

    // Take field
    pub fn take_release(&mut self) -> super::release::Release {
        self.release.take().unwrap_or_else(|| super::release::Release::new())
    }
}

impl ::protobuf::Message for InstallReleaseResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.release {
            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_singular_message_into(wire_type, is, &mut self.release)?;
                },
                _ => {
                    ::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 let Some(ref v) = self.release.as_ref() {
            let len = v.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 let Some(ref v) = self.release.as_ref() {
            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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> InstallReleaseResponse {
        InstallReleaseResponse::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_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::release::Release>>(
                    "release",
                    |m: &InstallReleaseResponse| { &m.release },
                    |m: &mut InstallReleaseResponse| { &mut m.release },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<InstallReleaseResponse>(
                    "InstallReleaseResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct UninstallReleaseRequest {
    // message fields
    pub name: ::std::string::String,
    pub disable_hooks: bool,
    pub purge: bool,
    pub timeout: i64,
    pub description: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

impl UninstallReleaseRequest {
    pub fn new() -> UninstallReleaseRequest {
        ::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())
    }

    // bool disable_hooks = 2;


    pub fn get_disable_hooks(&self) -> bool {
        self.disable_hooks
    }
    pub fn clear_disable_hooks(&mut self) {
        self.disable_hooks = false;
    }

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

    // bool purge = 3;


    pub fn get_purge(&self) -> bool {
        self.purge
    }
    pub fn clear_purge(&mut self) {
        self.purge = false;
    }

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

    // int64 timeout = 4;


    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;
    }

    // string description = 5;


    pub fn get_description(&self) -> &str {
        &self.description
    }
    pub fn clear_description(&mut self) {
        self.description.clear();
    }

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

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

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

impl ::protobuf::Message for UninstallReleaseRequest {
    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 => {
                    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.disable_hooks = 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_bool()?;
                    self.purge = 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.timeout = tmp;
                },
                5 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.description)?;
                },
                _ => {
                    ::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.disable_hooks != false {
            my_size += 2;
        }
        if self.purge != false {
            my_size += 2;
        }
        if self.timeout != 0 {
            my_size += ::protobuf::rt::value_size(4, self.timeout, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.description.is_empty() {
            my_size += ::protobuf::rt::string_size(5, &self.description);
        }
        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.disable_hooks != false {
            os.write_bool(2, self.disable_hooks)?;
        }
        if self.purge != false {
            os.write_bool(3, self.purge)?;
        }
        if self.timeout != 0 {
            os.write_int64(4, self.timeout)?;
        }
        if !self.description.is_empty() {
            os.write_string(5, &self.description)?;
        }
        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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> UninstallReleaseRequest {
        UninstallReleaseRequest::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: &UninstallReleaseRequest| { &m.name },
                    |m: &mut UninstallReleaseRequest| { &mut m.name },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "disable_hooks",
                    |m: &UninstallReleaseRequest| { &m.disable_hooks },
                    |m: &mut UninstallReleaseRequest| { &mut m.disable_hooks },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "purge",
                    |m: &UninstallReleaseRequest| { &m.purge },
                    |m: &mut UninstallReleaseRequest| { &mut m.purge },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "timeout",
                    |m: &UninstallReleaseRequest| { &m.timeout },
                    |m: &mut UninstallReleaseRequest| { &mut m.timeout },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "description",
                    |m: &UninstallReleaseRequest| { &m.description },
                    |m: &mut UninstallReleaseRequest| { &mut m.description },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<UninstallReleaseRequest>(
                    "UninstallReleaseRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for UninstallReleaseRequest {
    fn clear(&mut self) {
        self.name.clear();
        self.disable_hooks = false;
        self.purge = false;
        self.timeout = 0;
        self.description.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct UninstallReleaseResponse {
    // message fields
    pub release: ::protobuf::SingularPtrField<super::release::Release>,
    pub info: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .hapi.release.Release release = 1;


    pub fn get_release(&self) -> &super::release::Release {
        self.release.as_ref().unwrap_or_else(|| super::release::Release::default_instance())
    }
    pub fn clear_release(&mut self) {
        self.release.clear();
    }

    pub fn has_release(&self) -> bool {
        self.release.is_some()
    }

    // Param is passed by value, moved
    pub fn set_release(&mut self, v: super::release::Release) {
        self.release = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_release(&mut self) -> &mut super::release::Release {
        if self.release.is_none() {
            self.release.set_default();
        }
        self.release.as_mut().unwrap()
    }

    // Take field
    pub fn take_release(&mut self) -> super::release::Release {
        self.release.take().unwrap_or_else(|| super::release::Release::new())
    }

    // string info = 2;


    pub fn get_info(&self) -> &str {
        &self.info
    }
    pub fn clear_info(&mut self) {
        self.info.clear();
    }

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

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

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

impl ::protobuf::Message for UninstallReleaseResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.release {
            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_singular_message_into(wire_type, is, &mut self.release)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.info)?;
                },
                _ => {
                    ::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 let Some(ref v) = self.release.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if !self.info.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.info);
        }
        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 let Some(ref v) = self.release.as_ref() {
            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.info.is_empty() {
            os.write_string(2, &self.info)?;
        }
        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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> UninstallReleaseResponse {
        UninstallReleaseResponse::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_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::release::Release>>(
                    "release",
                    |m: &UninstallReleaseResponse| { &m.release },
                    |m: &mut UninstallReleaseResponse| { &mut m.release },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "info",
                    |m: &UninstallReleaseResponse| { &m.info },
                    |m: &mut UninstallReleaseResponse| { &mut m.info },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<UninstallReleaseResponse>(
                    "UninstallReleaseResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

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

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

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

impl ::protobuf::Message for GetVersionRequest {
    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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> GetVersionRequest {
        GetVersionRequest::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::<GetVersionRequest>(
                    "GetVersionRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct GetVersionResponse {
    // message fields
    pub Version: ::protobuf::SingularPtrField<super::version::Version>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .hapi.version.Version Version = 1;


    pub fn get_Version(&self) -> &super::version::Version {
        self.Version.as_ref().unwrap_or_else(|| super::version::Version::default_instance())
    }
    pub fn clear_Version(&mut self) {
        self.Version.clear();
    }

    pub fn has_Version(&self) -> bool {
        self.Version.is_some()
    }

    // Param is passed by value, moved
    pub fn set_Version(&mut self, v: super::version::Version) {
        self.Version = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_Version(&mut self) -> &mut super::version::Version {
        if self.Version.is_none() {
            self.Version.set_default();
        }
        self.Version.as_mut().unwrap()
    }

    // Take field
    pub fn take_Version(&mut self) -> super::version::Version {
        self.Version.take().unwrap_or_else(|| super::version::Version::new())
    }
}

impl ::protobuf::Message for GetVersionResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.Version {
            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_singular_message_into(wire_type, is, &mut self.Version)?;
                },
                _ => {
                    ::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 let Some(ref v) = self.Version.as_ref() {
            let len = v.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 let Some(ref v) = self.Version.as_ref() {
            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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> GetVersionResponse {
        GetVersionResponse::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_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::version::Version>>(
                    "Version",
                    |m: &GetVersionResponse| { &m.Version },
                    |m: &mut GetVersionResponse| { &mut m.Version },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<GetVersionResponse>(
                    "GetVersionResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct GetHistoryRequest {
    // message fields
    pub name: ::std::string::String,
    pub max: i32,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

impl GetHistoryRequest {
    pub fn new() -> GetHistoryRequest {
        ::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())
    }

    // int32 max = 2;


    pub fn get_max(&self) -> i32 {
        self.max
    }
    pub fn clear_max(&mut self) {
        self.max = 0;
    }

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

impl ::protobuf::Message for GetHistoryRequest {
    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 => {
                    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.max = 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.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if self.max != 0 {
            my_size += ::protobuf::rt::value_size(2, self.max, ::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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if self.max != 0 {
            os.write_int32(2, self.max)?;
        }
        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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> GetHistoryRequest {
        GetHistoryRequest::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: &GetHistoryRequest| { &m.name },
                    |m: &mut GetHistoryRequest| { &mut m.name },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                    "max",
                    |m: &GetHistoryRequest| { &m.max },
                    |m: &mut GetHistoryRequest| { &mut m.max },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<GetHistoryRequest>(
                    "GetHistoryRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for GetHistoryRequest {
    fn clear(&mut self) {
        self.name.clear();
        self.max = 0;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct GetHistoryResponse {
    // message fields
    pub releases: ::protobuf::RepeatedField<super::release::Release>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .hapi.release.Release releases = 1;


    pub fn get_releases(&self) -> &[super::release::Release] {
        &self.releases
    }
    pub fn clear_releases(&mut self) {
        self.releases.clear();
    }

    // Param is passed by value, moved
    pub fn set_releases(&mut self, v: ::protobuf::RepeatedField<super::release::Release>) {
        self.releases = v;
    }

    // Mutable pointer to the field.
    pub fn mut_releases(&mut self) -> &mut ::protobuf::RepeatedField<super::release::Release> {
        &mut self.releases
    }

    // Take field
    pub fn take_releases(&mut self) -> ::protobuf::RepeatedField<super::release::Release> {
        ::std::mem::replace(&mut self.releases, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for GetHistoryResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.releases {
            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.releases)?;
                },
                _ => {
                    ::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.releases {
            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.releases {
            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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> GetHistoryResponse {
        GetHistoryResponse::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<super::release::Release>>(
                    "releases",
                    |m: &GetHistoryResponse| { &m.releases },
                    |m: &mut GetHistoryResponse| { &mut m.releases },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<GetHistoryResponse>(
                    "GetHistoryResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct TestReleaseRequest {
    // message fields
    pub name: ::std::string::String,
    pub timeout: i64,
    pub cleanup: bool,
    pub parallel: bool,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

impl TestReleaseRequest {
    pub fn new() -> TestReleaseRequest {
        ::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())
    }

    // int64 timeout = 2;


    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;
    }

    // bool cleanup = 3;


    pub fn get_cleanup(&self) -> bool {
        self.cleanup
    }
    pub fn clear_cleanup(&mut self) {
        self.cleanup = false;
    }

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

    // bool parallel = 4;


    pub fn get_parallel(&self) -> bool {
        self.parallel
    }
    pub fn clear_parallel(&mut self) {
        self.parallel = false;
    }

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

impl ::protobuf::Message for TestReleaseRequest {
    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 => {
                    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;
                },
                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.cleanup = 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_bool()?;
                    self.parallel = 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.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if self.timeout != 0 {
            my_size += ::protobuf::rt::value_size(2, self.timeout, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.cleanup != false {
            my_size += 2;
        }
        if self.parallel != 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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if self.timeout != 0 {
            os.write_int64(2, self.timeout)?;
        }
        if self.cleanup != false {
            os.write_bool(3, self.cleanup)?;
        }
        if self.parallel != false {
            os.write_bool(4, self.parallel)?;
        }
        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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> TestReleaseRequest {
        TestReleaseRequest::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: &TestReleaseRequest| { &m.name },
                    |m: &mut TestReleaseRequest| { &mut m.name },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "timeout",
                    |m: &TestReleaseRequest| { &m.timeout },
                    |m: &mut TestReleaseRequest| { &mut m.timeout },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "cleanup",
                    |m: &TestReleaseRequest| { &m.cleanup },
                    |m: &mut TestReleaseRequest| { &mut m.cleanup },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "parallel",
                    |m: &TestReleaseRequest| { &m.parallel },
                    |m: &mut TestReleaseRequest| { &mut m.parallel },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<TestReleaseRequest>(
                    "TestReleaseRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for TestReleaseRequest {
    fn clear(&mut self) {
        self.name.clear();
        self.timeout = 0;
        self.cleanup = false;
        self.parallel = false;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct TestReleaseResponse {
    // message fields
    pub msg: ::std::string::String,
    pub status: super::test_run::TestRun_Status,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string msg = 1;


    pub fn get_msg(&self) -> &str {
        &self.msg
    }
    pub fn clear_msg(&mut self) {
        self.msg.clear();
    }

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

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

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

    // .hapi.release.TestRun.Status status = 2;


    pub fn get_status(&self) -> super::test_run::TestRun_Status {
        self.status
    }
    pub fn clear_status(&mut self) {
        self.status = super::test_run::TestRun_Status::UNKNOWN;
    }

    // Param is passed by value, moved
    pub fn set_status(&mut self, v: super::test_run::TestRun_Status) {
        self.status = v;
    }
}

impl ::protobuf::Message for TestReleaseResponse {
    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.msg)?;
                },
                2 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.status, 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.msg.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.msg);
        }
        if self.status != super::test_run::TestRun_Status::UNKNOWN {
            my_size += ::protobuf::rt::enum_size(2, self.status);
        }
        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.msg.is_empty() {
            os.write_string(1, &self.msg)?;
        }
        if self.status != super::test_run::TestRun_Status::UNKNOWN {
            os.write_enum(2, self.status.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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

    fn new() -> TestReleaseResponse {
        TestReleaseResponse::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>(
                    "msg",
                    |m: &TestReleaseResponse| { &m.msg },
                    |m: &mut TestReleaseResponse| { &mut m.msg },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::test_run::TestRun_Status>>(
                    "status",
                    |m: &TestReleaseResponse| { &m.status },
                    |m: &mut TestReleaseResponse| { &mut m.status },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<TestReleaseResponse>(
                    "TestReleaseResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for TestReleaseResponse {
    fn clear(&mut self) {
        self.msg.clear();
        self.status = super::test_run::TestRun_Status::UNKNOWN;
        self.unknown_fields.clear();
    }
}

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x1ahapi/services/tiller.proto\x12\x14hapi.services.tiller\x1a\x16hapi\
    /chart/chart.proto\x1a\x17hapi/chart/config.proto\x1a\x1ahapi/release/re\
    lease.proto\x1a\x17hapi/release/info.proto\x1a\x1bhapi/release/test_run.\
    proto\x1a\x19hapi/release/status.proto\x1a\x1ahapi/version/version.proto\
    \"\xc0\x02\n\x13ListReleasesRequest\x12\x14\n\x05limit\x18\x01\x20\x01(\
    \x03R\x05limit\x12\x16\n\x06offset\x18\x02\x20\x01(\tR\x06offset\x12>\n\
    \x07sort_by\x18\x03\x20\x01(\x0e2%.hapi.services.tiller.ListSort.SortByR\
    \x06sortBy\x12\x16\n\x06filter\x18\x04\x20\x01(\tR\x06filter\x12G\n\nsor\
    t_order\x18\x05\x20\x01(\x0e2(.hapi.services.tiller.ListSort.SortOrderR\
    \tsortOrder\x12<\n\x0cstatus_codes\x18\x06\x20\x03(\x0e2\x19.hapi.releas\
    e.Status.CodeR\x0bstatusCodes\x12\x1c\n\tnamespace\x18\x07\x20\x01(\tR\t\
    namespace\"n\n\x08ListSort\"B\n\x06SortBy\x12\x0b\n\x07UNKNOWN\x10\0\x12\
    \x08\n\x04NAME\x10\x01\x12\x11\n\rLAST_RELEASED\x10\x02\x12\x0e\n\nCHART\
    _NAME\x10\x03\"\x1e\n\tSortOrder\x12\x07\n\x03ASC\x10\0\x12\x08\n\x04DES\
    C\x10\x01\"\x89\x01\n\x14ListReleasesResponse\x12\x14\n\x05count\x18\x01\
    \x20\x01(\x03R\x05count\x12\x12\n\x04next\x18\x02\x20\x01(\tR\x04next\
    \x12\x14\n\x05total\x18\x03\x20\x01(\x03R\x05total\x121\n\x08releases\
    \x18\x04\x20\x03(\x0b2\x15.hapi.release.ReleaseR\x08releases\"G\n\x17Get\
    ReleaseStatusRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\
    \x18\n\x07version\x18\x02\x20\x01(\x05R\x07version\"t\n\x18GetReleaseSta\
    tusResponse\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12&\n\x04info\
    \x18\x02\x20\x01(\x0b2\x12.hapi.release.InfoR\x04info\x12\x1c\n\tnamespa\
    ce\x18\x03\x20\x01(\tR\tnamespace\"H\n\x18GetReleaseContentRequest\x12\
    \x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\x18\n\x07version\x18\x02\
    \x20\x01(\x05R\x07version\"L\n\x19GetReleaseContentResponse\x12/\n\x07re\
    lease\x18\x01\x20\x01(\x0b2\x15.hapi.release.ReleaseR\x07release\"\xa1\
    \x03\n\x14UpdateReleaseRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04\
    name\x12'\n\x05chart\x18\x02\x20\x01(\x0b2\x11.hapi.chart.ChartR\x05char\
    t\x12*\n\x06values\x18\x03\x20\x01(\x0b2\x12.hapi.chart.ConfigR\x06value\
    s\x12\x17\n\x07dry_run\x18\x04\x20\x01(\x08R\x06dryRun\x12#\n\rdisable_h\
    ooks\x18\x05\x20\x01(\x08R\x0cdisableHooks\x12\x1a\n\x08recreate\x18\x06\
    \x20\x01(\x08R\x08recreate\x12\x18\n\x07timeout\x18\x07\x20\x01(\x03R\
    \x07timeout\x12!\n\x0creset_values\x18\x08\x20\x01(\x08R\x0bresetValues\
    \x12\x12\n\x04wait\x18\t\x20\x01(\x08R\x04wait\x12!\n\x0creuse_values\
    \x18\n\x20\x01(\x08R\x0breuseValues\x12\x14\n\x05force\x18\x0b\x20\x01(\
    \x08R\x05force\x12\x20\n\x0bdescription\x18\x0c\x20\x01(\tR\x0bdescripti\
    on\x12\x1a\n\x08subNotes\x18\r\x20\x01(\x08R\x08subNotes\"H\n\x15UpdateR\
    eleaseResponse\x12/\n\x07release\x18\x01\x20\x01(\x0b2\x15.hapi.release.\
    ReleaseR\x07release\"\x86\x02\n\x16RollbackReleaseRequest\x12\x12\n\x04n\
    ame\x18\x01\x20\x01(\tR\x04name\x12\x17\n\x07dry_run\x18\x02\x20\x01(\
    \x08R\x06dryRun\x12#\n\rdisable_hooks\x18\x03\x20\x01(\x08R\x0cdisableHo\
    oks\x12\x18\n\x07version\x18\x04\x20\x01(\x05R\x07version\x12\x1a\n\x08r\
    ecreate\x18\x05\x20\x01(\x08R\x08recreate\x12\x18\n\x07timeout\x18\x06\
    \x20\x01(\x03R\x07timeout\x12\x12\n\x04wait\x18\x07\x20\x01(\x08R\x04wai\
    t\x12\x14\n\x05force\x18\x08\x20\x01(\x08R\x05force\x12\x20\n\x0bdescrip\
    tion\x18\t\x20\x01(\tR\x0bdescription\"J\n\x17RollbackReleaseResponse\
    \x12/\n\x07release\x18\x01\x20\x01(\x0b2\x15.hapi.release.ReleaseR\x07re\
    lease\"\x91\x03\n\x15InstallReleaseRequest\x12'\n\x05chart\x18\x01\x20\
    \x01(\x0b2\x11.hapi.chart.ChartR\x05chart\x12*\n\x06values\x18\x02\x20\
    \x01(\x0b2\x12.hapi.chart.ConfigR\x06values\x12\x17\n\x07dry_run\x18\x03\
    \x20\x01(\x08R\x06dryRun\x12\x12\n\x04name\x18\x04\x20\x01(\tR\x04name\
    \x12#\n\rdisable_hooks\x18\x05\x20\x01(\x08R\x0cdisableHooks\x12\x1c\n\t\
    namespace\x18\x06\x20\x01(\tR\tnamespace\x12\x1d\n\nreuse_name\x18\x07\
    \x20\x01(\x08R\treuseName\x12\x18\n\x07timeout\x18\x08\x20\x01(\x03R\x07\
    timeout\x12\x12\n\x04wait\x18\t\x20\x01(\x08R\x04wait\x12(\n\x10disable_\
    crd_hook\x18\n\x20\x01(\x08R\x0edisableCrdHook\x12\x20\n\x0bdescription\
    \x18\x0b\x20\x01(\tR\x0bdescription\x12\x1a\n\x08subNotes\x18\x0c\x20\
    \x01(\x08R\x08subNotes\"I\n\x16InstallReleaseResponse\x12/\n\x07release\
    \x18\x01\x20\x01(\x0b2\x15.hapi.release.ReleaseR\x07release\"\xa4\x01\n\
    \x17UninstallReleaseRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04nam\
    e\x12#\n\rdisable_hooks\x18\x02\x20\x01(\x08R\x0cdisableHooks\x12\x14\n\
    \x05purge\x18\x03\x20\x01(\x08R\x05purge\x12\x18\n\x07timeout\x18\x04\
    \x20\x01(\x03R\x07timeout\x12\x20\n\x0bdescription\x18\x05\x20\x01(\tR\
    \x0bdescription\"_\n\x18UninstallReleaseResponse\x12/\n\x07release\x18\
    \x01\x20\x01(\x0b2\x15.hapi.release.ReleaseR\x07release\x12\x12\n\x04inf\
    o\x18\x02\x20\x01(\tR\x04info\"\x13\n\x11GetVersionRequest\"E\n\x12GetVe\
    rsionResponse\x12/\n\x07Version\x18\x01\x20\x01(\x0b2\x15.hapi.version.V\
    ersionR\x07Version\"9\n\x11GetHistoryRequest\x12\x12\n\x04name\x18\x01\
    \x20\x01(\tR\x04name\x12\x10\n\x03max\x18\x02\x20\x01(\x05R\x03max\"G\n\
    \x12GetHistoryResponse\x121\n\x08releases\x18\x01\x20\x03(\x0b2\x15.hapi\
    .release.ReleaseR\x08releases\"x\n\x12TestReleaseRequest\x12\x12\n\x04na\
    me\x18\x01\x20\x01(\tR\x04name\x12\x18\n\x07timeout\x18\x02\x20\x01(\x03\
    R\x07timeout\x12\x18\n\x07cleanup\x18\x03\x20\x01(\x08R\x07cleanup\x12\
    \x1a\n\x08parallel\x18\x04\x20\x01(\x08R\x08parallel\"]\n\x13TestRelease\
    Response\x12\x10\n\x03msg\x18\x01\x20\x01(\tR\x03msg\x124\n\x06status\
    \x18\x02\x20\x01(\x0e2\x1c.hapi.release.TestRun.StatusR\x06status2\xdb\
    \x08\n\x0eReleaseService\x12i\n\x0cListReleases\x12).hapi.services.tille\
    r.ListReleasesRequest\x1a*.hapi.services.tiller.ListReleasesResponse\"\0\
    0\x01\x12s\n\x10GetReleaseStatus\x12-.hapi.services.tiller.GetReleaseSta\
    tusRequest\x1a..hapi.services.tiller.GetReleaseStatusResponse\"\0\x12v\n\
    \x11GetReleaseContent\x12..hapi.services.tiller.GetReleaseContentRequest\
    \x1a/.hapi.services.tiller.GetReleaseContentResponse\"\0\x12j\n\rUpdateR\
    elease\x12*.hapi.services.tiller.UpdateReleaseRequest\x1a+.hapi.services\
    .tiller.UpdateReleaseResponse\"\0\x12m\n\x0eInstallRelease\x12+.hapi.ser\
    vices.tiller.InstallReleaseRequest\x1a,.hapi.services.tiller.InstallRele\
    aseResponse\"\0\x12s\n\x10UninstallRelease\x12-.hapi.services.tiller.Uni\
    nstallReleaseRequest\x1a..hapi.services.tiller.UninstallReleaseResponse\
    \"\0\x12a\n\nGetVersion\x12'.hapi.services.tiller.GetVersionRequest\x1a(\
    .hapi.services.tiller.GetVersionResponse\"\0\x12p\n\x0fRollbackRelease\
    \x12,.hapi.services.tiller.RollbackReleaseRequest\x1a-.hapi.services.til\
    ler.RollbackReleaseResponse\"\0\x12a\n\nGetHistory\x12'.hapi.services.ti\
    ller.GetHistoryRequest\x1a(.hapi.services.tiller.GetHistoryResponse\"\0\
    \x12i\n\x0eRunReleaseTest\x12(.hapi.services.tiller.TestReleaseRequest\
    \x1a).hapi.services.tiller.TestReleaseResponse\"\00\x01B\nZ\x08servicesb\
    \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()
        })
    }
}