#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_imports)]
#![allow(unused_results)]
#[derive(PartialEq,Clone,Default)]
pub struct Instance {
pub name: ::std::string::String,
pub display_name: ::std::string::String,
pub state: Instance_State,
pub field_type: Instance_Type,
pub labels: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Instance {
fn default() -> &'a Instance {
<Instance as ::protobuf::Message>::default_instance()
}
}
impl Instance {
pub fn new() -> Instance {
::std::default::Default::default()
}
pub fn get_name(&self) -> &str {
&self.name
}
pub fn clear_name(&mut self) {
self.name.clear();
}
pub fn set_name(&mut self, v: ::std::string::String) {
self.name = v;
}
pub fn mut_name(&mut self) -> &mut ::std::string::String {
&mut self.name
}
pub fn take_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.name, ::std::string::String::new())
}
pub fn get_display_name(&self) -> &str {
&self.display_name
}
pub fn clear_display_name(&mut self) {
self.display_name.clear();
}
pub fn set_display_name(&mut self, v: ::std::string::String) {
self.display_name = v;
}
pub fn mut_display_name(&mut self) -> &mut ::std::string::String {
&mut self.display_name
}
pub fn take_display_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.display_name, ::std::string::String::new())
}
pub fn get_state(&self) -> Instance_State {
self.state
}
pub fn clear_state(&mut self) {
self.state = Instance_State::STATE_NOT_KNOWN;
}
pub fn set_state(&mut self, v: Instance_State) {
self.state = v;
}
pub fn get_field_type(&self) -> Instance_Type {
self.field_type
}
pub fn clear_field_type(&mut self) {
self.field_type = Instance_Type::TYPE_UNSPECIFIED;
}
pub fn set_field_type(&mut self, v: Instance_Type) {
self.field_type = v;
}
pub fn get_labels(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> {
&self.labels
}
pub fn clear_labels(&mut self) {
self.labels.clear();
}
pub fn set_labels(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) {
self.labels = v;
}
pub fn mut_labels(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> {
&mut self.labels
}
pub fn take_labels(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> {
::std::mem::replace(&mut self.labels, ::std::collections::HashMap::new())
}
}
impl ::protobuf::Message for Instance {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.display_name)?;
},
3 => {
::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 3, &mut self.unknown_fields)?
},
4 => {
::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.field_type, 4, &mut self.unknown_fields)?
},
5 => {
::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.labels)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[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.display_name.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.display_name);
}
if self.state != Instance_State::STATE_NOT_KNOWN {
my_size += ::protobuf::rt::enum_size(3, self.state);
}
if self.field_type != Instance_Type::TYPE_UNSPECIFIED {
my_size += ::protobuf::rt::enum_size(4, self.field_type);
}
my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(5, &self.labels);
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.display_name.is_empty() {
os.write_string(2, &self.display_name)?;
}
if self.state != Instance_State::STATE_NOT_KNOWN {
os.write_enum(3, ::protobuf::ProtobufEnum::value(&self.state))?;
}
if self.field_type != Instance_Type::TYPE_UNSPECIFIED {
os.write_enum(4, ::protobuf::ProtobufEnum::value(&self.field_type))?;
}
::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(5, &self.labels, os)?;
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Instance {
Instance::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"name",
|m: &Instance| { &m.name },
|m: &mut Instance| { &mut m.name },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"display_name",
|m: &Instance| { &m.display_name },
|m: &mut Instance| { &mut m.display_name },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Instance_State>>(
"state",
|m: &Instance| { &m.state },
|m: &mut Instance| { &mut m.state },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Instance_Type>>(
"type",
|m: &Instance| { &m.field_type },
|m: &mut Instance| { &mut m.field_type },
));
fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(
"labels",
|m: &Instance| { &m.labels },
|m: &mut Instance| { &mut m.labels },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<Instance>(
"Instance",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static Instance {
static instance: ::protobuf::rt::LazyV2<Instance> = ::protobuf::rt::LazyV2::INIT;
instance.get(Instance::new)
}
}
impl ::protobuf::Clear for Instance {
fn clear(&mut self) {
self.name.clear();
self.display_name.clear();
self.state = Instance_State::STATE_NOT_KNOWN;
self.field_type = Instance_Type::TYPE_UNSPECIFIED;
self.labels.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Instance {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Instance {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum Instance_State {
STATE_NOT_KNOWN = 0,
READY = 1,
CREATING = 2,
}
impl ::protobuf::ProtobufEnum for Instance_State {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<Instance_State> {
match value {
0 => ::std::option::Option::Some(Instance_State::STATE_NOT_KNOWN),
1 => ::std::option::Option::Some(Instance_State::READY),
2 => ::std::option::Option::Some(Instance_State::CREATING),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [Instance_State] = &[
Instance_State::STATE_NOT_KNOWN,
Instance_State::READY,
Instance_State::CREATING,
];
values
}
fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new_pb_name::<Instance_State>("Instance.State", file_descriptor_proto())
})
}
}
impl ::std::marker::Copy for Instance_State {
}
impl ::std::default::Default for Instance_State {
fn default() -> Self {
Instance_State::STATE_NOT_KNOWN
}
}
impl ::protobuf::reflect::ProtobufValue for Instance_State {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum Instance_Type {
TYPE_UNSPECIFIED = 0,
PRODUCTION = 1,
DEVELOPMENT = 2,
}
impl ::protobuf::ProtobufEnum for Instance_Type {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<Instance_Type> {
match value {
0 => ::std::option::Option::Some(Instance_Type::TYPE_UNSPECIFIED),
1 => ::std::option::Option::Some(Instance_Type::PRODUCTION),
2 => ::std::option::Option::Some(Instance_Type::DEVELOPMENT),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [Instance_Type] = &[
Instance_Type::TYPE_UNSPECIFIED,
Instance_Type::PRODUCTION,
Instance_Type::DEVELOPMENT,
];
values
}
fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new_pb_name::<Instance_Type>("Instance.Type", file_descriptor_proto())
})
}
}
impl ::std::marker::Copy for Instance_Type {
}
impl ::std::default::Default for Instance_Type {
fn default() -> Self {
Instance_Type::TYPE_UNSPECIFIED
}
}
impl ::protobuf::reflect::ProtobufValue for Instance_Type {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Cluster {
pub name: ::std::string::String,
pub location: ::std::string::String,
pub state: Cluster_State,
pub serve_nodes: i32,
pub default_storage_type: super::common::StorageType,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Cluster {
fn default() -> &'a Cluster {
<Cluster as ::protobuf::Message>::default_instance()
}
}
impl Cluster {
pub fn new() -> Cluster {
::std::default::Default::default()
}
pub fn get_name(&self) -> &str {
&self.name
}
pub fn clear_name(&mut self) {
self.name.clear();
}
pub fn set_name(&mut self, v: ::std::string::String) {
self.name = v;
}
pub fn mut_name(&mut self) -> &mut ::std::string::String {
&mut self.name
}
pub fn take_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.name, ::std::string::String::new())
}
pub fn get_location(&self) -> &str {
&self.location
}
pub fn clear_location(&mut self) {
self.location.clear();
}
pub fn set_location(&mut self, v: ::std::string::String) {
self.location = v;
}
pub fn mut_location(&mut self) -> &mut ::std::string::String {
&mut self.location
}
pub fn take_location(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.location, ::std::string::String::new())
}
pub fn get_state(&self) -> Cluster_State {
self.state
}
pub fn clear_state(&mut self) {
self.state = Cluster_State::STATE_NOT_KNOWN;
}
pub fn set_state(&mut self, v: Cluster_State) {
self.state = v;
}
pub fn get_serve_nodes(&self) -> i32 {
self.serve_nodes
}
pub fn clear_serve_nodes(&mut self) {
self.serve_nodes = 0;
}
pub fn set_serve_nodes(&mut self, v: i32) {
self.serve_nodes = v;
}
pub fn get_default_storage_type(&self) -> super::common::StorageType {
self.default_storage_type
}
pub fn clear_default_storage_type(&mut self) {
self.default_storage_type = super::common::StorageType::STORAGE_TYPE_UNSPECIFIED;
}
pub fn set_default_storage_type(&mut self, v: super::common::StorageType) {
self.default_storage_type = v;
}
}
impl ::protobuf::Message for Cluster {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.location)?;
},
3 => {
::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 3, &mut self.unknown_fields)?
},
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.serve_nodes = tmp;
},
5 => {
::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.default_storage_type, 5, &mut self.unknown_fields)?
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[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.location.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.location);
}
if self.state != Cluster_State::STATE_NOT_KNOWN {
my_size += ::protobuf::rt::enum_size(3, self.state);
}
if self.serve_nodes != 0 {
my_size += ::protobuf::rt::value_size(4, self.serve_nodes, ::protobuf::wire_format::WireTypeVarint);
}
if self.default_storage_type != super::common::StorageType::STORAGE_TYPE_UNSPECIFIED {
my_size += ::protobuf::rt::enum_size(5, self.default_storage_type);
}
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.location.is_empty() {
os.write_string(2, &self.location)?;
}
if self.state != Cluster_State::STATE_NOT_KNOWN {
os.write_enum(3, ::protobuf::ProtobufEnum::value(&self.state))?;
}
if self.serve_nodes != 0 {
os.write_int32(4, self.serve_nodes)?;
}
if self.default_storage_type != super::common::StorageType::STORAGE_TYPE_UNSPECIFIED {
os.write_enum(5, ::protobuf::ProtobufEnum::value(&self.default_storage_type))?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Cluster {
Cluster::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"name",
|m: &Cluster| { &m.name },
|m: &mut Cluster| { &mut m.name },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"location",
|m: &Cluster| { &m.location },
|m: &mut Cluster| { &mut m.location },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Cluster_State>>(
"state",
|m: &Cluster| { &m.state },
|m: &mut Cluster| { &mut m.state },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"serve_nodes",
|m: &Cluster| { &m.serve_nodes },
|m: &mut Cluster| { &mut m.serve_nodes },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::common::StorageType>>(
"default_storage_type",
|m: &Cluster| { &m.default_storage_type },
|m: &mut Cluster| { &mut m.default_storage_type },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<Cluster>(
"Cluster",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static Cluster {
static instance: ::protobuf::rt::LazyV2<Cluster> = ::protobuf::rt::LazyV2::INIT;
instance.get(Cluster::new)
}
}
impl ::protobuf::Clear for Cluster {
fn clear(&mut self) {
self.name.clear();
self.location.clear();
self.state = Cluster_State::STATE_NOT_KNOWN;
self.serve_nodes = 0;
self.default_storage_type = super::common::StorageType::STORAGE_TYPE_UNSPECIFIED;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Cluster {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Cluster {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum Cluster_State {
STATE_NOT_KNOWN = 0,
READY = 1,
CREATING = 2,
RESIZING = 3,
DISABLED = 4,
}
impl ::protobuf::ProtobufEnum for Cluster_State {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<Cluster_State> {
match value {
0 => ::std::option::Option::Some(Cluster_State::STATE_NOT_KNOWN),
1 => ::std::option::Option::Some(Cluster_State::READY),
2 => ::std::option::Option::Some(Cluster_State::CREATING),
3 => ::std::option::Option::Some(Cluster_State::RESIZING),
4 => ::std::option::Option::Some(Cluster_State::DISABLED),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [Cluster_State] = &[
Cluster_State::STATE_NOT_KNOWN,
Cluster_State::READY,
Cluster_State::CREATING,
Cluster_State::RESIZING,
Cluster_State::DISABLED,
];
values
}
fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new_pb_name::<Cluster_State>("Cluster.State", file_descriptor_proto())
})
}
}
impl ::std::marker::Copy for Cluster_State {
}
impl ::std::default::Default for Cluster_State {
fn default() -> Self {
Cluster_State::STATE_NOT_KNOWN
}
}
impl ::protobuf::reflect::ProtobufValue for Cluster_State {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
}
}
#[derive(PartialEq,Clone,Default)]
pub struct AppProfile {
pub name: ::std::string::String,
pub etag: ::std::string::String,
pub description: ::std::string::String,
pub routing_policy: ::std::option::Option<AppProfile_oneof_routing_policy>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a AppProfile {
fn default() -> &'a AppProfile {
<AppProfile as ::protobuf::Message>::default_instance()
}
}
#[derive(Clone,PartialEq,Debug)]
pub enum AppProfile_oneof_routing_policy {
multi_cluster_routing_use_any(AppProfile_MultiClusterRoutingUseAny),
single_cluster_routing(AppProfile_SingleClusterRouting),
}
impl AppProfile {
pub fn new() -> AppProfile {
::std::default::Default::default()
}
pub fn get_name(&self) -> &str {
&self.name
}
pub fn clear_name(&mut self) {
self.name.clear();
}
pub fn set_name(&mut self, v: ::std::string::String) {
self.name = v;
}
pub fn mut_name(&mut self) -> &mut ::std::string::String {
&mut self.name
}
pub fn take_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.name, ::std::string::String::new())
}
pub fn get_etag(&self) -> &str {
&self.etag
}
pub fn clear_etag(&mut self) {
self.etag.clear();
}
pub fn set_etag(&mut self, v: ::std::string::String) {
self.etag = v;
}
pub fn mut_etag(&mut self) -> &mut ::std::string::String {
&mut self.etag
}
pub fn take_etag(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.etag, ::std::string::String::new())
}
pub fn get_description(&self) -> &str {
&self.description
}
pub fn clear_description(&mut self) {
self.description.clear();
}
pub fn set_description(&mut self, v: ::std::string::String) {
self.description = v;
}
pub fn mut_description(&mut self) -> &mut ::std::string::String {
&mut self.description
}
pub fn take_description(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.description, ::std::string::String::new())
}
pub fn get_multi_cluster_routing_use_any(&self) -> &AppProfile_MultiClusterRoutingUseAny {
match self.routing_policy {
::std::option::Option::Some(AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(ref v)) => v,
_ => <AppProfile_MultiClusterRoutingUseAny as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_multi_cluster_routing_use_any(&mut self) {
self.routing_policy = ::std::option::Option::None;
}
pub fn has_multi_cluster_routing_use_any(&self) -> bool {
match self.routing_policy {
::std::option::Option::Some(AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(..)) => true,
_ => false,
}
}
pub fn set_multi_cluster_routing_use_any(&mut self, v: AppProfile_MultiClusterRoutingUseAny) {
self.routing_policy = ::std::option::Option::Some(AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(v))
}
pub fn mut_multi_cluster_routing_use_any(&mut self) -> &mut AppProfile_MultiClusterRoutingUseAny {
if let ::std::option::Option::Some(AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(_)) = self.routing_policy {
} else {
self.routing_policy = ::std::option::Option::Some(AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(AppProfile_MultiClusterRoutingUseAny::new()));
}
match self.routing_policy {
::std::option::Option::Some(AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_multi_cluster_routing_use_any(&mut self) -> AppProfile_MultiClusterRoutingUseAny {
if self.has_multi_cluster_routing_use_any() {
match self.routing_policy.take() {
::std::option::Option::Some(AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(v)) => v,
_ => panic!(),
}
} else {
AppProfile_MultiClusterRoutingUseAny::new()
}
}
pub fn get_single_cluster_routing(&self) -> &AppProfile_SingleClusterRouting {
match self.routing_policy {
::std::option::Option::Some(AppProfile_oneof_routing_policy::single_cluster_routing(ref v)) => v,
_ => <AppProfile_SingleClusterRouting as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_single_cluster_routing(&mut self) {
self.routing_policy = ::std::option::Option::None;
}
pub fn has_single_cluster_routing(&self) -> bool {
match self.routing_policy {
::std::option::Option::Some(AppProfile_oneof_routing_policy::single_cluster_routing(..)) => true,
_ => false,
}
}
pub fn set_single_cluster_routing(&mut self, v: AppProfile_SingleClusterRouting) {
self.routing_policy = ::std::option::Option::Some(AppProfile_oneof_routing_policy::single_cluster_routing(v))
}
pub fn mut_single_cluster_routing(&mut self) -> &mut AppProfile_SingleClusterRouting {
if let ::std::option::Option::Some(AppProfile_oneof_routing_policy::single_cluster_routing(_)) = self.routing_policy {
} else {
self.routing_policy = ::std::option::Option::Some(AppProfile_oneof_routing_policy::single_cluster_routing(AppProfile_SingleClusterRouting::new()));
}
match self.routing_policy {
::std::option::Option::Some(AppProfile_oneof_routing_policy::single_cluster_routing(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_single_cluster_routing(&mut self) -> AppProfile_SingleClusterRouting {
if self.has_single_cluster_routing() {
match self.routing_policy.take() {
::std::option::Option::Some(AppProfile_oneof_routing_policy::single_cluster_routing(v)) => v,
_ => panic!(),
}
} else {
AppProfile_SingleClusterRouting::new()
}
}
}
impl ::protobuf::Message for AppProfile {
fn is_initialized(&self) -> bool {
if let Some(AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(ref v)) = self.routing_policy {
if !v.is_initialized() {
return false;
}
}
if let Some(AppProfile_oneof_routing_policy::single_cluster_routing(ref v)) = self.routing_policy {
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_proto3_string_into(wire_type, is, &mut self.etag)?;
},
3 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.description)?;
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.routing_policy = ::std::option::Option::Some(AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(is.read_message()?));
},
6 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.routing_policy = ::std::option::Option::Some(AppProfile_oneof_routing_policy::single_cluster_routing(is.read_message()?));
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[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.etag.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.etag);
}
if !self.description.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.description);
}
if let ::std::option::Option::Some(ref v) = self.routing_policy {
match v {
&AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&AppProfile_oneof_routing_policy::single_cluster_routing(ref v) => {
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 !self.name.is_empty() {
os.write_string(1, &self.name)?;
}
if !self.etag.is_empty() {
os.write_string(2, &self.etag)?;
}
if !self.description.is_empty() {
os.write_string(3, &self.description)?;
}
if let ::std::option::Option::Some(ref v) = self.routing_policy {
match v {
&AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(ref v) => {
os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
&AppProfile_oneof_routing_policy::single_cluster_routing(ref v) => {
os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
};
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> AppProfile {
AppProfile::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"name",
|m: &AppProfile| { &m.name },
|m: &mut AppProfile| { &mut m.name },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"etag",
|m: &AppProfile| { &m.etag },
|m: &mut AppProfile| { &mut m.etag },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"description",
|m: &AppProfile| { &m.description },
|m: &mut AppProfile| { &mut m.description },
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, AppProfile_MultiClusterRoutingUseAny>(
"multi_cluster_routing_use_any",
AppProfile::has_multi_cluster_routing_use_any,
AppProfile::get_multi_cluster_routing_use_any,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, AppProfile_SingleClusterRouting>(
"single_cluster_routing",
AppProfile::has_single_cluster_routing,
AppProfile::get_single_cluster_routing,
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<AppProfile>(
"AppProfile",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static AppProfile {
static instance: ::protobuf::rt::LazyV2<AppProfile> = ::protobuf::rt::LazyV2::INIT;
instance.get(AppProfile::new)
}
}
impl ::protobuf::Clear for AppProfile {
fn clear(&mut self) {
self.name.clear();
self.etag.clear();
self.description.clear();
self.routing_policy = ::std::option::Option::None;
self.routing_policy = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for AppProfile {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for AppProfile {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct AppProfile_MultiClusterRoutingUseAny {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a AppProfile_MultiClusterRoutingUseAny {
fn default() -> &'a AppProfile_MultiClusterRoutingUseAny {
<AppProfile_MultiClusterRoutingUseAny as ::protobuf::Message>::default_instance()
}
}
impl AppProfile_MultiClusterRoutingUseAny {
pub fn new() -> AppProfile_MultiClusterRoutingUseAny {
::std::default::Default::default()
}
}
impl ::protobuf::Message for AppProfile_MultiClusterRoutingUseAny {
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(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> AppProfile_MultiClusterRoutingUseAny {
AppProfile_MultiClusterRoutingUseAny::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let fields = ::std::vec::Vec::new();
::protobuf::reflect::MessageDescriptor::new_pb_name::<AppProfile_MultiClusterRoutingUseAny>(
"AppProfile.MultiClusterRoutingUseAny",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static AppProfile_MultiClusterRoutingUseAny {
static instance: ::protobuf::rt::LazyV2<AppProfile_MultiClusterRoutingUseAny> = ::protobuf::rt::LazyV2::INIT;
instance.get(AppProfile_MultiClusterRoutingUseAny::new)
}
}
impl ::protobuf::Clear for AppProfile_MultiClusterRoutingUseAny {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for AppProfile_MultiClusterRoutingUseAny {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for AppProfile_MultiClusterRoutingUseAny {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct AppProfile_SingleClusterRouting {
pub cluster_id: ::std::string::String,
pub allow_transactional_writes: bool,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a AppProfile_SingleClusterRouting {
fn default() -> &'a AppProfile_SingleClusterRouting {
<AppProfile_SingleClusterRouting as ::protobuf::Message>::default_instance()
}
}
impl AppProfile_SingleClusterRouting {
pub fn new() -> AppProfile_SingleClusterRouting {
::std::default::Default::default()
}
pub fn get_cluster_id(&self) -> &str {
&self.cluster_id
}
pub fn clear_cluster_id(&mut self) {
self.cluster_id.clear();
}
pub fn set_cluster_id(&mut self, v: ::std::string::String) {
self.cluster_id = v;
}
pub fn mut_cluster_id(&mut self) -> &mut ::std::string::String {
&mut self.cluster_id
}
pub fn take_cluster_id(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.cluster_id, ::std::string::String::new())
}
pub fn get_allow_transactional_writes(&self) -> bool {
self.allow_transactional_writes
}
pub fn clear_allow_transactional_writes(&mut self) {
self.allow_transactional_writes = false;
}
pub fn set_allow_transactional_writes(&mut self, v: bool) {
self.allow_transactional_writes = v;
}
}
impl ::protobuf::Message for AppProfile_SingleClusterRouting {
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.cluster_id)?;
},
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.allow_transactional_writes = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.cluster_id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.cluster_id);
}
if self.allow_transactional_writes != 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.cluster_id.is_empty() {
os.write_string(1, &self.cluster_id)?;
}
if self.allow_transactional_writes != false {
os.write_bool(2, self.allow_transactional_writes)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> AppProfile_SingleClusterRouting {
AppProfile_SingleClusterRouting::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"cluster_id",
|m: &AppProfile_SingleClusterRouting| { &m.cluster_id },
|m: &mut AppProfile_SingleClusterRouting| { &mut m.cluster_id },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"allow_transactional_writes",
|m: &AppProfile_SingleClusterRouting| { &m.allow_transactional_writes },
|m: &mut AppProfile_SingleClusterRouting| { &mut m.allow_transactional_writes },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<AppProfile_SingleClusterRouting>(
"AppProfile.SingleClusterRouting",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static AppProfile_SingleClusterRouting {
static instance: ::protobuf::rt::LazyV2<AppProfile_SingleClusterRouting> = ::protobuf::rt::LazyV2::INIT;
instance.get(AppProfile_SingleClusterRouting::new)
}
}
impl ::protobuf::Clear for AppProfile_SingleClusterRouting {
fn clear(&mut self) {
self.cluster_id.clear();
self.allow_transactional_writes = false;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for AppProfile_SingleClusterRouting {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for AppProfile_SingleClusterRouting {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n'google/bigtable/admin/v2/instance.proto\x12\x18google.bigtable.admin.\
v2\x1a\x1cgoogle/api/annotations.proto\x1a%google/bigtable/admin/v2/comm\
on.proto\"\xb7\x03\n\x08Instance\x12\x12\n\x04name\x18\x01\x20\x01(\tR\
\x04name\x12!\n\x0cdisplay_name\x18\x02\x20\x01(\tR\x0bdisplayName\x12>\
\n\x05state\x18\x03\x20\x01(\x0e2(.google.bigtable.admin.v2.Instance.Sta\
teR\x05state\x12;\n\x04type\x18\x04\x20\x01(\x0e2'.google.bigtable.admin\
.v2.Instance.TypeR\x04type\x12F\n\x06labels\x18\x05\x20\x03(\x0b2..googl\
e.bigtable.admin.v2.Instance.LabelsEntryR\x06labels\x1a9\n\x0bLabelsEntr\
y\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\
\x20\x01(\tR\x05value:\x028\x01\"5\n\x05State\x12\x13\n\x0fSTATE_NOT_KNO\
WN\x10\0\x12\t\n\x05READY\x10\x01\x12\x0c\n\x08CREATING\x10\x02\"=\n\x04\
Type\x12\x14\n\x10TYPE_UNSPECIFIED\x10\0\x12\x0e\n\nPRODUCTION\x10\x01\
\x12\x0f\n\x0bDEVELOPMENT\x10\x02\"\xc5\x02\n\x07Cluster\x12\x12\n\x04na\
me\x18\x01\x20\x01(\tR\x04name\x12\x1a\n\x08location\x18\x02\x20\x01(\tR\
\x08location\x12=\n\x05state\x18\x03\x20\x01(\x0e2'.google.bigtable.admi\
n.v2.Cluster.StateR\x05state\x12\x1f\n\x0bserve_nodes\x18\x04\x20\x01(\
\x05R\nserveNodes\x12W\n\x14default_storage_type\x18\x05\x20\x01(\x0e2%.\
google.bigtable.admin.v2.StorageTypeR\x12defaultStorageType\"Q\n\x05Stat\
e\x12\x13\n\x0fSTATE_NOT_KNOWN\x10\0\x12\t\n\x05READY\x10\x01\x12\x0c\n\
\x08CREATING\x10\x02\x12\x0c\n\x08RESIZING\x10\x03\x12\x0c\n\x08DISABLED\
\x10\x04\"\xf2\x03\n\nAppProfile\x12\x12\n\x04name\x18\x01\x20\x01(\tR\
\x04name\x12\x12\n\x04etag\x18\x02\x20\x01(\tR\x04etag\x12\x20\n\x0bdesc\
ription\x18\x03\x20\x01(\tR\x0bdescription\x12\x82\x01\n\x1dmulti_cluste\
r_routing_use_any\x18\x05\x20\x01(\x0b2>.google.bigtable.admin.v2.AppPro\
file.MultiClusterRoutingUseAnyH\0R\x19multiClusterRoutingUseAny\x12q\n\
\x16single_cluster_routing\x18\x06\x20\x01(\x0b29.google.bigtable.admin.\
v2.AppProfile.SingleClusterRoutingH\0R\x14singleClusterRouting\x1a\x1b\n\
\x19MultiClusterRoutingUseAny\x1as\n\x14SingleClusterRouting\x12\x1d\n\n\
cluster_id\x18\x01\x20\x01(\tR\tclusterId\x12<\n\x1aallow_transactional_\
writes\x18\x02\x20\x01(\x08R\x18allowTransactionalWritesB\x10\n\x0erouti\
ng_policyB\xb0\x01\n\x1ccom.google.bigtable.admin.v2B\rInstanceProtoP\
\x01Z=google.golang.org/genproto/googleapis/bigtable/admin/v2;admin\xaa\
\x02\x1eGoogle.Cloud.Bigtable.Admin.V2\xca\x02\x1eGoogle\\Cloud\\Bigtabl\
e\\Admin\\V2J\xc5?\n\x07\x12\x05\x0f\0\xcc\x01\x01\n\xbe\x04\n\x01\x0c\
\x12\x03\x0f\0\x122\xb3\x04\x20Copyright\x202018\x20Google\x20LLC.\n\n\
\x20Licensed\x20under\x20the\x20Apache\x20License,\x20Version\x202.0\x20\
(the\x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\x20e\
xcept\x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20may\x20\
obtain\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\x20\
\x20http://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20required\
\x20by\x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\x20s\
oftware\n\x20distributed\x20under\x20the\x20License\x20is\x20distributed\
\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\
\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\x20impli\
ed.\n\x20See\x20the\x20License\x20for\x20the\x20specific\x20language\x20\
governing\x20permissions\x20and\n\x20limitations\x20under\x20the\x20Lice\
nse.\n\n\n\x08\n\x01\x02\x12\x03\x11\0!\n\t\n\x02\x03\0\x12\x03\x13\0&\n\
\t\n\x02\x03\x01\x12\x03\x14\0/\n\x08\n\x01\x08\x12\x03\x16\0;\n\t\n\x02\
\x08%\x12\x03\x16\0;\n\x08\n\x01\x08\x12\x03\x17\0T\n\t\n\x02\x08\x0b\
\x12\x03\x17\0T\n\x08\n\x01\x08\x12\x03\x18\0\"\n\t\n\x02\x08\n\x12\x03\
\x18\0\"\n\x08\n\x01\x08\x12\x03\x19\0.\n\t\n\x02\x08\x08\x12\x03\x19\0.\
\n\x08\n\x01\x08\x12\x03\x1a\05\n\t\n\x02\x08\x01\x12\x03\x1a\05\n\x08\n\
\x01\x08\x12\x03\x1b\0<\n\t\n\x02\x08)\x12\x03\x1b\0<\n\xd6\x01\n\x02\
\x04\0\x12\x04!\0b\x01\x1a\xc9\x01\x20A\x20collection\x20of\x20Bigtable\
\x20[Tables][google.bigtable.admin.v2.Table]\x20and\n\x20the\x20resource\
s\x20that\x20serve\x20them.\n\x20All\x20tables\x20in\x20an\x20instance\
\x20are\x20served\x20from\x20a\x20single\n\x20[Cluster][google.bigtable.\
admin.v2.Cluster].\n\n\n\n\x03\x04\0\x01\x12\x03!\x08\x10\n/\n\x04\x04\0\
\x04\0\x12\x04#\x02.\x03\x1a!\x20Possible\x20states\x20of\x20an\x20insta\
nce.\n\n\x0c\n\x05\x04\0\x04\0\x01\x12\x03#\x07\x0c\nC\n\x06\x04\0\x04\0\
\x02\0\x12\x03%\x04\x18\x1a4\x20The\x20state\x20of\x20the\x20instance\
\x20could\x20not\x20be\x20determined.\n\n\x0e\n\x07\x04\0\x04\0\x02\0\
\x01\x12\x03%\x04\x13\n\x0e\n\x07\x04\0\x04\0\x02\0\x02\x12\x03%\x16\x17\
\nb\n\x06\x04\0\x04\0\x02\x01\x12\x03)\x04\x0e\x1aS\x20The\x20instance\
\x20has\x20been\x20successfully\x20created\x20and\x20can\x20serve\x20req\
uests\n\x20to\x20its\x20tables.\n\n\x0e\n\x07\x04\0\x04\0\x02\x01\x01\
\x12\x03)\x04\t\n\x0e\n\x07\x04\0\x04\0\x02\x01\x02\x12\x03)\x0c\r\n|\n\
\x06\x04\0\x04\0\x02\x02\x12\x03-\x04\x11\x1am\x20The\x20instance\x20is\
\x20currently\x20being\x20created,\x20and\x20may\x20be\x20destroyed\n\
\x20if\x20the\x20creation\x20process\x20encounters\x20an\x20error.\n\n\
\x0e\n\x07\x04\0\x04\0\x02\x02\x01\x12\x03-\x04\x0c\n\x0e\n\x07\x04\0\
\x04\0\x02\x02\x02\x12\x03-\x0f\x10\n)\n\x04\x04\0\x04\x01\x12\x041\x02C\
\x03\x1a\x1b\x20The\x20type\x20of\x20the\x20instance.\n\n\x0c\n\x05\x04\
\0\x04\x01\x01\x12\x031\x07\x0b\n\xca\x01\n\x06\x04\0\x04\x01\x02\0\x12\
\x035\x04\x19\x1a\xba\x01\x20The\x20type\x20of\x20the\x20instance\x20is\
\x20unspecified.\x20If\x20set\x20when\x20creating\x20an\n\x20instance,\
\x20a\x20`PRODUCTION`\x20instance\x20will\x20be\x20created.\x20If\x20set\
\x20when\x20updating\n\x20an\x20instance,\x20the\x20type\x20will\x20be\
\x20left\x20unchanged.\n\n\x0e\n\x07\x04\0\x04\x01\x02\0\x01\x12\x035\
\x04\x14\n\x0e\n\x07\x04\0\x04\x01\x02\0\x02\x12\x035\x17\x18\na\n\x06\
\x04\0\x04\x01\x02\x01\x12\x039\x04\x13\x1aR\x20An\x20instance\x20meant\
\x20for\x20production\x20use.\x20`serve_nodes`\x20must\x20be\x20set\n\
\x20on\x20the\x20cluster.\n\n\x0e\n\x07\x04\0\x04\x01\x02\x01\x01\x12\
\x039\x04\x0e\n\x0e\n\x07\x04\0\x04\x01\x02\x01\x02\x12\x039\x11\x12\n\
\xb7\x03\n\x06\x04\0\x04\x01\x02\x02\x12\x03B\x04\x14\x1a\xa7\x03\x20The\
\x20instance\x20is\x20meant\x20for\x20development\x20and\x20testing\x20p\
urposes\x20only;\x20it\x20has\n\x20no\x20performance\x20or\x20uptime\x20\
guarantees\x20and\x20is\x20not\x20covered\x20by\x20SLA.\n\x20After\x20a\
\x20development\x20instance\x20is\x20created,\x20it\x20can\x20be\x20upgr\
aded\x20by\n\x20updating\x20the\x20instance\x20to\x20type\x20`PRODUCTION\
`.\x20An\x20instance\x20created\n\x20as\x20a\x20production\x20instance\
\x20cannot\x20be\x20changed\x20to\x20a\x20development\x20instance.\n\x20\
When\x20creating\x20a\x20development\x20instance,\x20`serve_nodes`\x20on\
\x20the\x20cluster\x20must\n\x20not\x20be\x20set.\n\n\x0e\n\x07\x04\0\
\x04\x01\x02\x02\x01\x12\x03B\x04\x0f\n\x0e\n\x07\x04\0\x04\x01\x02\x02\
\x02\x12\x03B\x12\x13\n\x92\x01\n\x04\x04\0\x02\0\x12\x03H\x02\x12\x1a\
\x84\x01\x20(`OutputOnly`)\n\x20The\x20unique\x20name\x20of\x20the\x20in\
stance.\x20Values\x20are\x20of\x20the\x20form\n\x20`projects/<project>/i\
nstances/[a-z][a-z0-9\\\\-]+[a-z0-9]`.\n\n\x0c\n\x05\x04\0\x02\0\x05\x12\
\x03H\x02\x08\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03H\t\r\n\x0c\n\x05\x04\0\
\x02\0\x03\x12\x03H\x10\x11\n\xa1\x01\n\x04\x04\0\x02\x01\x12\x03M\x02\
\x1a\x1a\x93\x01\x20The\x20descriptive\x20name\x20for\x20this\x20instanc\
e\x20as\x20it\x20appears\x20in\x20UIs.\n\x20Can\x20be\x20changed\x20at\
\x20any\x20time,\x20but\x20should\x20be\x20kept\x20globally\x20unique\n\
\x20to\x20avoid\x20confusion.\n\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x03M\
\x02\x08\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03M\t\x15\n\x0c\n\x05\x04\0\
\x02\x01\x03\x12\x03M\x18\x19\nA\n\x04\x04\0\x02\x02\x12\x03Q\x02\x12\
\x1a4\x20(`OutputOnly`)\n\x20The\x20current\x20state\x20of\x20the\x20ins\
tance.\n\n\x0c\n\x05\x04\0\x02\x02\x06\x12\x03Q\x02\x07\n\x0c\n\x05\x04\
\0\x02\x02\x01\x12\x03Q\x08\r\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03Q\x10\
\x11\nB\n\x04\x04\0\x02\x03\x12\x03T\x02\x10\x1a5\x20The\x20type\x20of\
\x20the\x20instance.\x20Defaults\x20to\x20`PRODUCTION`.\n\n\x0c\n\x05\
\x04\0\x02\x03\x06\x12\x03T\x02\x06\n\x0c\n\x05\x04\0\x02\x03\x01\x12\
\x03T\x07\x0b\n\x0c\n\x05\x04\0\x02\x03\x03\x12\x03T\x0e\x0f\n\x82\x05\n\
\x04\x04\0\x02\x04\x12\x03a\x02!\x1a\xf4\x04\x20Labels\x20are\x20a\x20fl\
exible\x20and\x20lightweight\x20mechanism\x20for\x20organizing\x20cloud\
\n\x20resources\x20into\x20groups\x20that\x20reflect\x20a\x20customer's\
\x20organizational\x20needs\x20and\n\x20deployment\x20strategies.\x20The\
y\x20can\x20be\x20used\x20to\x20filter\x20resources\x20and\x20aggregate\
\n\x20metrics.\n\n\x20*\x20Label\x20keys\x20must\x20be\x20between\x201\
\x20and\x2063\x20characters\x20long\x20and\x20must\x20conform\x20to\n\
\x20\x20\x20the\x20regular\x20expression:\x20`[\\p{Ll}\\p{Lo}][\\p{Ll}\\\
p{Lo}\\p{N}_-]{0,62}`.\n\x20*\x20Label\x20values\x20must\x20be\x20betwee\
n\x200\x20and\x2063\x20characters\x20long\x20and\x20must\x20conform\x20t\
o\n\x20\x20\x20the\x20regular\x20expression:\x20`[\\p{Ll}\\p{Lo}\\p{N}_-\
]{0,63}`.\n\x20*\x20No\x20more\x20than\x2064\x20labels\x20can\x20be\x20a\
ssociated\x20with\x20a\x20given\x20resource.\n\x20*\x20Keys\x20and\x20va\
lues\x20must\x20both\x20be\x20under\x20128\x20bytes.\n\n\x0c\n\x05\x04\0\
\x02\x04\x06\x12\x03a\x02\x15\n\x0c\n\x05\x04\0\x02\x04\x01\x12\x03a\x16\
\x1c\n\x0c\n\x05\x04\0\x02\x04\x03\x12\x03a\x1f\x20\n\xc9\x01\n\x02\x04\
\x01\x12\x05g\0\x99\x01\x01\x1a\xbb\x01\x20A\x20resizable\x20group\x20of\
\x20nodes\x20in\x20a\x20particular\x20cloud\x20location,\x20capable\n\
\x20of\x20serving\x20all\x20[Tables][google.bigtable.admin.v2.Table]\x20\
in\x20the\x20parent\n\x20[Instance][google.bigtable.admin.v2.Instance].\
\n\n\n\n\x03\x04\x01\x01\x12\x03g\x08\x0f\n-\n\x04\x04\x01\x04\0\x12\x04\
i\x02\x7f\x03\x1a\x1f\x20Possible\x20states\x20of\x20a\x20cluster.\n\n\
\x0c\n\x05\x04\x01\x04\0\x01\x12\x03i\x07\x0c\nB\n\x06\x04\x01\x04\0\x02\
\0\x12\x03k\x04\x18\x1a3\x20The\x20state\x20of\x20the\x20cluster\x20coul\
d\x20not\x20be\x20determined.\n\n\x0e\n\x07\x04\x01\x04\0\x02\0\x01\x12\
\x03k\x04\x13\n\x0e\n\x07\x04\x01\x04\0\x02\0\x02\x12\x03k\x16\x17\nZ\n\
\x06\x04\x01\x04\0\x02\x01\x12\x03n\x04\x0e\x1aK\x20The\x20cluster\x20ha\
s\x20been\x20successfully\x20created\x20and\x20is\x20ready\x20to\x20serv\
e\x20requests.\n\n\x0e\n\x07\x04\x01\x04\0\x02\x01\x01\x12\x03n\x04\t\n\
\x0e\n\x07\x04\x01\x04\0\x02\x01\x02\x12\x03n\x0c\r\n\xbe\x01\n\x06\x04\
\x01\x04\0\x02\x02\x12\x03s\x04\x11\x1a\xae\x01\x20The\x20cluster\x20is\
\x20currently\x20being\x20created,\x20and\x20may\x20be\x20destroyed\n\
\x20if\x20the\x20creation\x20process\x20encounters\x20an\x20error.\n\x20\
A\x20cluster\x20may\x20not\x20be\x20able\x20to\x20serve\x20requests\x20w\
hile\x20being\x20created.\n\n\x0e\n\x07\x04\x01\x04\0\x02\x02\x01\x12\
\x03s\x04\x0c\n\x0e\n\x07\x04\x01\x04\0\x02\x02\x02\x12\x03s\x0f\x10\n\
\xbd\x02\n\x06\x04\x01\x04\0\x02\x03\x12\x03z\x04\x11\x1a\xad\x02\x20The\
\x20cluster\x20is\x20currently\x20being\x20resized,\x20and\x20may\x20rev\
ert\x20to\x20its\x20previous\n\x20node\x20count\x20if\x20the\x20process\
\x20encounters\x20an\x20error.\n\x20A\x20cluster\x20is\x20still\x20capab\
le\x20of\x20serving\x20requests\x20while\x20being\x20resized,\n\x20but\
\x20may\x20exhibit\x20performance\x20as\x20if\x20its\x20number\x20of\x20\
allocated\x20nodes\x20is\n\x20between\x20the\x20starting\x20and\x20reque\
sted\x20states.\n\n\x0e\n\x07\x04\x01\x04\0\x02\x03\x01\x12\x03z\x04\x0c\
\n\x0e\n\x07\x04\x01\x04\0\x02\x03\x02\x12\x03z\x0f\x10\n\x85\x01\n\x06\
\x04\x01\x04\0\x02\x04\x12\x03~\x04\x11\x1av\x20The\x20cluster\x20has\
\x20no\x20backing\x20nodes.\x20The\x20data\x20(tables)\x20still\n\x20exi\
st,\x20but\x20no\x20operations\x20can\x20be\x20performed\x20on\x20the\
\x20cluster.\n\n\x0e\n\x07\x04\x01\x04\0\x02\x04\x01\x12\x03~\x04\x0c\n\
\x0e\n\x07\x04\x01\x04\0\x02\x04\x02\x12\x03~\x0f\x10\n\x9c\x01\n\x04\
\x04\x01\x02\0\x12\x04\x84\x01\x02\x12\x1a\x8d\x01\x20(`OutputOnly`)\n\
\x20The\x20unique\x20name\x20of\x20the\x20cluster.\x20Values\x20are\x20o\
f\x20the\x20form\n\x20`projects/<project>/instances/<instance>/clusters/\
[a-z][-a-z0-9]*`.\n\n\r\n\x05\x04\x01\x02\0\x05\x12\x04\x84\x01\x02\x08\
\n\r\n\x05\x04\x01\x02\0\x01\x12\x04\x84\x01\t\r\n\r\n\x05\x04\x01\x02\0\
\x03\x12\x04\x84\x01\x10\x11\n\xa2\x02\n\x04\x04\x01\x02\x01\x12\x04\x8b\
\x01\x02\x16\x1a\x93\x02\x20(`CreationOnly`)\n\x20The\x20location\x20whe\
re\x20this\x20cluster's\x20nodes\x20and\x20storage\x20reside.\x20For\x20\
best\n\x20performance,\x20clients\x20should\x20be\x20located\x20as\x20cl\
ose\x20as\x20possible\x20to\x20this\n\x20cluster.\x20Currently\x20only\
\x20zones\x20are\x20supported,\x20so\x20values\x20should\x20be\x20of\x20\
the\n\x20form\x20`projects/<project>/locations/<zone>`.\n\n\r\n\x05\x04\
\x01\x02\x01\x05\x12\x04\x8b\x01\x02\x08\n\r\n\x05\x04\x01\x02\x01\x01\
\x12\x04\x8b\x01\t\x11\n\r\n\x05\x04\x01\x02\x01\x03\x12\x04\x8b\x01\x14\
\x15\nA\n\x04\x04\x01\x02\x02\x12\x04\x8f\x01\x02\x12\x1a3\x20(`OutputOn\
ly`)\n\x20The\x20current\x20state\x20of\x20the\x20cluster.\n\n\r\n\x05\
\x04\x01\x02\x02\x06\x12\x04\x8f\x01\x02\x07\n\r\n\x05\x04\x01\x02\x02\
\x01\x12\x04\x8f\x01\x08\r\n\r\n\x05\x04\x01\x02\x02\x03\x12\x04\x8f\x01\
\x10\x11\n\x84\x01\n\x04\x04\x01\x02\x03\x12\x04\x93\x01\x02\x18\x1av\
\x20The\x20number\x20of\x20nodes\x20allocated\x20to\x20this\x20cluster.\
\x20More\x20nodes\x20enable\x20higher\n\x20throughput\x20and\x20more\x20\
consistent\x20performance.\n\n\r\n\x05\x04\x01\x02\x03\x05\x12\x04\x93\
\x01\x02\x07\n\r\n\x05\x04\x01\x02\x03\x01\x12\x04\x93\x01\x08\x13\n\r\n\
\x05\x04\x01\x02\x03\x03\x12\x04\x93\x01\x16\x17\n\x91\x01\n\x04\x04\x01\
\x02\x04\x12\x04\x98\x01\x02'\x1a\x82\x01\x20(`CreationOnly`)\n\x20The\
\x20type\x20of\x20storage\x20used\x20by\x20this\x20cluster\x20to\x20serv\
e\x20its\n\x20parent\x20instance's\x20tables,\x20unless\x20explicitly\
\x20overridden.\n\n\r\n\x05\x04\x01\x02\x04\x06\x12\x04\x98\x01\x02\r\n\
\r\n\x05\x04\x01\x02\x04\x01\x12\x04\x98\x01\x0e\"\n\r\n\x05\x04\x01\x02\
\x04\x03\x12\x04\x98\x01%&\n\x82\x01\n\x02\x04\x02\x12\x06\x9d\x01\0\xcc\
\x01\x01\x1at\x20A\x20configuration\x20object\x20describing\x20how\x20Cl\
oud\x20Bigtable\x20should\x20treat\x20traffic\n\x20from\x20a\x20particul\
ar\x20end\x20user\x20application.\n\n\x0b\n\x03\x04\x02\x01\x12\x04\x9d\
\x01\x08\x12\n\xfd\x01\n\x04\x04\x02\x03\0\x12\x04\xa2\x01\x02&\x1a\xee\
\x01\x20Read/write\x20requests\x20may\x20be\x20routed\x20to\x20any\x20cl\
uster\x20in\x20the\x20instance,\x20and\x20will\n\x20fail\x20over\x20to\
\x20another\x20cluster\x20in\x20the\x20event\x20of\x20transient\x20error\
s\x20or\x20delays.\n\x20Choosing\x20this\x20option\x20sacrifices\x20read\
-your-writes\x20consistency\x20to\x20improve\n\x20availability.\n\n\r\n\
\x05\x04\x02\x03\0\x01\x12\x04\xa2\x01\n#\n\xb1\x01\n\x04\x04\x02\x03\
\x01\x12\x06\xa7\x01\x02\xaf\x01\x03\x1a\xa0\x01\x20Unconditionally\x20r\
outes\x20all\x20read/write\x20requests\x20to\x20a\x20specific\x20cluster\
.\n\x20This\x20option\x20preserves\x20read-your-writes\x20consistency,\
\x20but\x20does\x20not\x20improve\n\x20availability.\n\n\r\n\x05\x04\x02\
\x03\x01\x01\x12\x04\xa7\x01\n\x1e\nL\n\x06\x04\x02\x03\x01\x02\0\x12\
\x04\xa9\x01\x04\x1a\x1a<\x20The\x20cluster\x20to\x20which\x20read/write\
\x20requests\x20should\x20be\x20routed.\n\n\x0f\n\x07\x04\x02\x03\x01\
\x02\0\x05\x12\x04\xa9\x01\x04\n\n\x0f\n\x07\x04\x02\x03\x01\x02\0\x01\
\x12\x04\xa9\x01\x0b\x15\n\x0f\n\x07\x04\x02\x03\x01\x02\0\x03\x12\x04\
\xa9\x01\x18\x19\n\xd1\x01\n\x06\x04\x02\x03\x01\x02\x01\x12\x04\xae\x01\
\x04(\x1a\xc0\x01\x20Whether\x20or\x20not\x20`CheckAndMutateRow`\x20and\
\x20`ReadModifyWriteRow`\x20requests\x20are\n\x20allowed\x20by\x20this\
\x20app\x20profile.\x20It\x20is\x20unsafe\x20to\x20send\x20these\x20requ\
ests\x20to\n\x20the\x20same\x20table/row/column\x20in\x20multiple\x20clu\
sters.\n\n\x0f\n\x07\x04\x02\x03\x01\x02\x01\x05\x12\x04\xae\x01\x04\x08\
\n\x0f\n\x07\x04\x02\x03\x01\x02\x01\x01\x12\x04\xae\x01\t#\n\x0f\n\x07\
\x04\x02\x03\x01\x02\x01\x03\x12\x04\xae\x01&'\n\xaf\x01\n\x04\x04\x02\
\x02\0\x12\x04\xb4\x01\x02\x12\x1a\xa0\x01\x20(`OutputOnly`)\n\x20The\
\x20unique\x20name\x20of\x20the\x20app\x20profile.\x20Values\x20are\x20o\
f\x20the\x20form\n\x20`projects/<project>/instances/<instance>/appProfil\
es/[_a-zA-Z0-9][-_.a-zA-Z0-9]*`.\n\n\r\n\x05\x04\x02\x02\0\x05\x12\x04\
\xb4\x01\x02\x08\n\r\n\x05\x04\x02\x02\0\x01\x12\x04\xb4\x01\t\r\n\r\n\
\x05\x04\x02\x02\0\x03\x12\x04\xb4\x01\x10\x11\n\xcd\x03\n\x04\x04\x02\
\x02\x01\x12\x04\xbe\x01\x02\x12\x1a\xbe\x03\x20Strongly\x20validated\
\x20etag\x20for\x20optimistic\x20concurrency\x20control.\x20Preserve\x20\
the\n\x20value\x20returned\x20from\x20`GetAppProfile`\x20when\x20calling\
\x20`UpdateAppProfile`\x20to\n\x20fail\x20the\x20request\x20if\x20there\
\x20has\x20been\x20a\x20modification\x20in\x20the\x20mean\x20time.\x20Th\
e\n\x20`update_mask`\x20of\x20the\x20request\x20need\x20not\x20include\
\x20`etag`\x20for\x20this\x20protection\n\x20to\x20apply.\n\x20See\x20[W\
ikipedia](https://en.wikipedia.org/wiki/HTTP_ETag)\x20and\n\x20[RFC\x207\
232](https://tools.ietf.org/html/rfc7232#section-2.3)\x20for\x20more\n\
\x20details.\n\n\r\n\x05\x04\x02\x02\x01\x05\x12\x04\xbe\x01\x02\x08\n\r\
\n\x05\x04\x02\x02\x01\x01\x12\x04\xbe\x01\t\r\n\r\n\x05\x04\x02\x02\x01\
\x03\x12\x04\xbe\x01\x10\x11\nS\n\x04\x04\x02\x02\x02\x12\x04\xc1\x01\
\x02\x19\x1aE\x20Optional\x20long\x20form\x20description\x20of\x20the\
\x20use\x20case\x20for\x20this\x20AppProfile.\n\n\r\n\x05\x04\x02\x02\
\x02\x05\x12\x04\xc1\x01\x02\x08\n\r\n\x05\x04\x02\x02\x02\x01\x12\x04\
\xc1\x01\t\x14\n\r\n\x05\x04\x02\x02\x02\x03\x12\x04\xc1\x01\x17\x18\n}\
\n\x04\x04\x02\x08\0\x12\x06\xc5\x01\x02\xcb\x01\x03\x1am\x20The\x20rout\
ing\x20policy\x20for\x20all\x20read/write\x20requests\x20which\x20use\
\x20this\x20app\x20profile.\n\x20A\x20value\x20must\x20be\x20explicitly\
\x20set.\n\n\r\n\x05\x04\x02\x08\0\x01\x12\x04\xc5\x01\x08\x16\nM\n\x04\
\x04\x02\x02\x03\x12\x04\xc7\x01\x04@\x1a?\x20Use\x20a\x20multi-cluster\
\x20routing\x20policy\x20that\x20may\x20pick\x20any\x20cluster.\n\n\r\n\
\x05\x04\x02\x02\x03\x06\x12\x04\xc7\x01\x04\x1d\n\r\n\x05\x04\x02\x02\
\x03\x01\x12\x04\xc7\x01\x1e;\n\r\n\x05\x04\x02\x02\x03\x03\x12\x04\xc7\
\x01>?\n4\n\x04\x04\x02\x02\x04\x12\x04\xca\x01\x044\x1a&\x20Use\x20a\
\x20single-cluster\x20routing\x20policy.\n\n\r\n\x05\x04\x02\x02\x04\x06\
\x12\x04\xca\x01\x04\x18\n\r\n\x05\x04\x02\x02\x04\x01\x12\x04\xca\x01\
\x19/\n\r\n\x05\x04\x02\x02\x04\x03\x12\x04\xca\x0123b\x06proto3\
";
static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}