make regen-apis

2026-02-23 15:49:49 +01:00 · 2024-05-16 21:23:40 +02:00
parent 52d2e89e51
commit ad85cafeef
5108 changed files with 1615625 additions and 992044 deletions
--- a/gen/bigtableadmin2/Cargo.toml
+++ b/gen/bigtableadmin2/Cargo.toml
@@ -4,12 +4,12 @@
 [package]

 name = "google-bigtableadmin2"
-version = "5.0.4+20240221"
+version = "5.0.5+20240331"
 authors = ["Sebastian Thiel <byronimo@gmail.com>"]
 description = "A complete library to interact with Bigtable Admin (protocol v2)"
 repository = "https://github.com/Byron/google-apis-rs/tree/main/gen/bigtableadmin2"
 homepage = "https://cloud.google.com/bigtable/"
-documentation = "https://docs.rs/google-bigtableadmin2/5.0.4+20240221"
+documentation = "https://docs.rs/google-bigtableadmin2/5.0.5+20240331"
 license = "MIT"
 keywords = ["bigtableadmin", "google", "protocol", "web", "api"]
 autobins = false
@@ -18,12 +18,12 @@ edition = "2018"

 [dependencies]
 anyhow = "^ 1.0"
-hyper-rustls = "0.24.0"
+hyper-rustls = "0.25.0"
 mime = "^ 0.3.0"
 serde = { version = "^ 1.0", features = ["derive"] }
 serde_json = "^ 1.0"
 itertools = "^ 0.10"
-google-apis-common = { path = "../../google-apis-common", version = "6.0" }
+google-apis-common = { path = "../../google-apis-common", version = "6.0.3" }
 hyper = "^ 0.14"
 http = "^0.2"
 tokio = "^1.0"
--- a/gen/bigtableadmin2/LICENSE.md
+++ b/gen/bigtableadmin2/LICENSE.md
@@ -6,7 +6,7 @@ DO NOT EDIT !
 The MIT License (MIT)
 =====================

-Copyright © `2015-2020` `Sebastian Thiel`
+Copyright 2015–2024 Sebastian Thiel

 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation
--- a/gen/bigtableadmin2/README.md
+++ b/gen/bigtableadmin2/README.md
--- a/gen/bigtableadmin2/src/api/call_builders.rs
+++ b/gen/bigtableadmin2/src/api/call_builders.rs
--- a/gen/bigtableadmin2/src/api/enums.rs
+++ b/gen/bigtableadmin2/src/api/enums.rs
@@ -0,0 +1,893 @@
+use super::*;
+
+
+
+// region AppProfilePriorityEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// This field has been deprecated in favor of `standard_isolation.priority`. If you set this field, `standard_isolation.priority` will be set instead. The priority of requests sent using this app profile.
+pub enum AppProfilePriorityEnum {
+    
+
+    /// Default value. Mapped to PRIORITY_HIGH (the legacy behavior) on creation.
+    ///
+    /// "PRIORITY_UNSPECIFIED"
+    #[serde(rename="PRIORITY_UNSPECIFIED")]
+    PRIORITYUNSPECIFIED,
+    
+    /// "PRIORITY_LOW"
+    #[serde(rename="PRIORITY_LOW")]
+    PRIORITYLOW,
+    
+    /// "PRIORITY_MEDIUM"
+    #[serde(rename="PRIORITY_MEDIUM")]
+    PRIORITYMEDIUM,
+    
+    /// "PRIORITY_HIGH"
+    #[serde(rename="PRIORITY_HIGH")]
+    PRIORITYHIGH,
+}
+
+impl AsRef<str> for AppProfilePriorityEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            AppProfilePriorityEnum::PRIORITYUNSPECIFIED => "PRIORITY_UNSPECIFIED",
+            AppProfilePriorityEnum::PRIORITYLOW => "PRIORITY_LOW",
+            AppProfilePriorityEnum::PRIORITYMEDIUM => "PRIORITY_MEDIUM",
+            AppProfilePriorityEnum::PRIORITYHIGH => "PRIORITY_HIGH",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for AppProfilePriorityEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "PRIORITY_UNSPECIFIED" => Ok(AppProfilePriorityEnum::PRIORITYUNSPECIFIED),
+           "PRIORITY_LOW" => Ok(AppProfilePriorityEnum::PRIORITYLOW),
+           "PRIORITY_MEDIUM" => Ok(AppProfilePriorityEnum::PRIORITYMEDIUM),
+           "PRIORITY_HIGH" => Ok(AppProfilePriorityEnum::PRIORITYHIGH),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a AppProfilePriorityEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region AuditLogConfigLogTypeEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// The log type that this config enables.
+pub enum AuditLogConfigLogTypeEnum {
+    
+
+    /// Default case. Should never be this.
+    ///
+    /// "LOG_TYPE_UNSPECIFIED"
+    #[serde(rename="LOG_TYPE_UNSPECIFIED")]
+    LOGTYPEUNSPECIFIED,
+    
+
+    /// Admin reads. Example: CloudIAM getIamPolicy
+    ///
+    /// "ADMIN_READ"
+    #[serde(rename="ADMIN_READ")]
+    ADMINREAD,
+    
+
+    /// Data writes. Example: CloudSQL Users create
+    ///
+    /// "DATA_WRITE"
+    #[serde(rename="DATA_WRITE")]
+    DATAWRITE,
+    
+
+    /// Data reads. Example: CloudSQL Users list
+    ///
+    /// "DATA_READ"
+    #[serde(rename="DATA_READ")]
+    DATAREAD,
+}
+
+impl AsRef<str> for AuditLogConfigLogTypeEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            AuditLogConfigLogTypeEnum::LOGTYPEUNSPECIFIED => "LOG_TYPE_UNSPECIFIED",
+            AuditLogConfigLogTypeEnum::ADMINREAD => "ADMIN_READ",
+            AuditLogConfigLogTypeEnum::DATAWRITE => "DATA_WRITE",
+            AuditLogConfigLogTypeEnum::DATAREAD => "DATA_READ",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for AuditLogConfigLogTypeEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "LOG_TYPE_UNSPECIFIED" => Ok(AuditLogConfigLogTypeEnum::LOGTYPEUNSPECIFIED),
+           "ADMIN_READ" => Ok(AuditLogConfigLogTypeEnum::ADMINREAD),
+           "DATA_WRITE" => Ok(AuditLogConfigLogTypeEnum::DATAWRITE),
+           "DATA_READ" => Ok(AuditLogConfigLogTypeEnum::DATAREAD),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a AuditLogConfigLogTypeEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region BackupStateEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// Output only. The current state of the backup.
+pub enum BackupStateEnum {
+    
+
+    /// Not specified.
+    ///
+    /// "STATE_UNSPECIFIED"
+    #[serde(rename="STATE_UNSPECIFIED")]
+    STATEUNSPECIFIED,
+    
+
+    /// The pending backup is still being created. Operations on the backup may fail with `FAILED_PRECONDITION` in this state.
+    ///
+    /// "CREATING"
+    #[serde(rename="CREATING")]
+    CREATING,
+    
+
+    /// The backup is complete and ready for use.
+    ///
+    /// "READY"
+    #[serde(rename="READY")]
+    READY,
+}
+
+impl AsRef<str> for BackupStateEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            BackupStateEnum::STATEUNSPECIFIED => "STATE_UNSPECIFIED",
+            BackupStateEnum::CREATING => "CREATING",
+            BackupStateEnum::READY => "READY",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for BackupStateEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "STATE_UNSPECIFIED" => Ok(BackupStateEnum::STATEUNSPECIFIED),
+           "CREATING" => Ok(BackupStateEnum::CREATING),
+           "READY" => Ok(BackupStateEnum::READY),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a BackupStateEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region ClusterDefaultStorageTypeEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// Immutable. The type of storage used by this cluster to serve its parent instance's tables, unless explicitly overridden.
+pub enum ClusterDefaultStorageTypeEnum {
+    
+
+    /// The user did not specify a storage type.
+    ///
+    /// "STORAGE_TYPE_UNSPECIFIED"
+    #[serde(rename="STORAGE_TYPE_UNSPECIFIED")]
+    STORAGETYPEUNSPECIFIED,
+    
+
+    /// Flash (SSD) storage should be used.
+    ///
+    /// "SSD"
+    #[serde(rename="SSD")]
+    SSD,
+    
+
+    /// Magnetic drive (HDD) storage should be used.
+    ///
+    /// "HDD"
+    #[serde(rename="HDD")]
+    HDD,
+}
+
+impl AsRef<str> for ClusterDefaultStorageTypeEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            ClusterDefaultStorageTypeEnum::STORAGETYPEUNSPECIFIED => "STORAGE_TYPE_UNSPECIFIED",
+            ClusterDefaultStorageTypeEnum::SSD => "SSD",
+            ClusterDefaultStorageTypeEnum::HDD => "HDD",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for ClusterDefaultStorageTypeEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "STORAGE_TYPE_UNSPECIFIED" => Ok(ClusterDefaultStorageTypeEnum::STORAGETYPEUNSPECIFIED),
+           "SSD" => Ok(ClusterDefaultStorageTypeEnum::SSD),
+           "HDD" => Ok(ClusterDefaultStorageTypeEnum::HDD),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a ClusterDefaultStorageTypeEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region ClusterStateEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// Output only. The current state of the cluster.
+pub enum ClusterStateEnum {
+    
+
+    /// The state of the cluster could not be determined.
+    ///
+    /// "STATE_NOT_KNOWN"
+    #[serde(rename="STATE_NOT_KNOWN")]
+    STATENOTKNOWN,
+    
+
+    /// The cluster has been successfully created and is ready to serve requests.
+    ///
+    /// "READY"
+    #[serde(rename="READY")]
+    READY,
+    
+
+    /// The cluster is currently being created, and may be destroyed if the creation process encounters an error. A cluster may not be able to serve requests while being created.
+    ///
+    /// "CREATING"
+    #[serde(rename="CREATING")]
+    CREATING,
+    
+
+    /// The cluster is currently being resized, and may revert to its previous node count if the process encounters an error. A cluster is still capable of serving requests while being resized, but may exhibit performance as if its number of allocated nodes is between the starting and requested states.
+    ///
+    /// "RESIZING"
+    #[serde(rename="RESIZING")]
+    RESIZING,
+    
+
+    /// The cluster has no backing nodes. The data (tables) still exist, but no operations can be performed on the cluster.
+    ///
+    /// "DISABLED"
+    #[serde(rename="DISABLED")]
+    DISABLED,
+}
+
+impl AsRef<str> for ClusterStateEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            ClusterStateEnum::STATENOTKNOWN => "STATE_NOT_KNOWN",
+            ClusterStateEnum::READY => "READY",
+            ClusterStateEnum::CREATING => "CREATING",
+            ClusterStateEnum::RESIZING => "RESIZING",
+            ClusterStateEnum::DISABLED => "DISABLED",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for ClusterStateEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "STATE_NOT_KNOWN" => Ok(ClusterStateEnum::STATENOTKNOWN),
+           "READY" => Ok(ClusterStateEnum::READY),
+           "CREATING" => Ok(ClusterStateEnum::CREATING),
+           "RESIZING" => Ok(ClusterStateEnum::RESIZING),
+           "DISABLED" => Ok(ClusterStateEnum::DISABLED),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a ClusterStateEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region ClusterStateReplicationStateEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// Output only. The state of replication for the table in this cluster.
+pub enum ClusterStateReplicationStateEnum {
+    
+
+    /// The replication state of the table is unknown in this cluster.
+    ///
+    /// "STATE_NOT_KNOWN"
+    #[serde(rename="STATE_NOT_KNOWN")]
+    STATENOTKNOWN,
+    
+
+    /// The cluster was recently created, and the table must finish copying over pre-existing data from other clusters before it can begin receiving live replication updates and serving Data API requests.
+    ///
+    /// "INITIALIZING"
+    #[serde(rename="INITIALIZING")]
+    INITIALIZING,
+    
+
+    /// The table is temporarily unable to serve Data API requests from this cluster due to planned internal maintenance.
+    ///
+    /// "PLANNED_MAINTENANCE"
+    #[serde(rename="PLANNED_MAINTENANCE")]
+    PLANNEDMAINTENANCE,
+    
+
+    /// The table is temporarily unable to serve Data API requests from this cluster due to unplanned or emergency maintenance.
+    ///
+    /// "UNPLANNED_MAINTENANCE"
+    #[serde(rename="UNPLANNED_MAINTENANCE")]
+    UNPLANNEDMAINTENANCE,
+    
+
+    /// The table can serve Data API requests from this cluster. Depending on replication delay, reads may not immediately reflect the state of the table in other clusters.
+    ///
+    /// "READY"
+    #[serde(rename="READY")]
+    READY,
+    
+
+    /// The table is fully created and ready for use after a restore, and is being optimized for performance. When optimizations are complete, the table will transition to `READY` state.
+    ///
+    /// "READY_OPTIMIZING"
+    #[serde(rename="READY_OPTIMIZING")]
+    READYOPTIMIZING,
+}
+
+impl AsRef<str> for ClusterStateReplicationStateEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            ClusterStateReplicationStateEnum::STATENOTKNOWN => "STATE_NOT_KNOWN",
+            ClusterStateReplicationStateEnum::INITIALIZING => "INITIALIZING",
+            ClusterStateReplicationStateEnum::PLANNEDMAINTENANCE => "PLANNED_MAINTENANCE",
+            ClusterStateReplicationStateEnum::UNPLANNEDMAINTENANCE => "UNPLANNED_MAINTENANCE",
+            ClusterStateReplicationStateEnum::READY => "READY",
+            ClusterStateReplicationStateEnum::READYOPTIMIZING => "READY_OPTIMIZING",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for ClusterStateReplicationStateEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "STATE_NOT_KNOWN" => Ok(ClusterStateReplicationStateEnum::STATENOTKNOWN),
+           "INITIALIZING" => Ok(ClusterStateReplicationStateEnum::INITIALIZING),
+           "PLANNED_MAINTENANCE" => Ok(ClusterStateReplicationStateEnum::PLANNEDMAINTENANCE),
+           "UNPLANNED_MAINTENANCE" => Ok(ClusterStateReplicationStateEnum::UNPLANNEDMAINTENANCE),
+           "READY" => Ok(ClusterStateReplicationStateEnum::READY),
+           "READY_OPTIMIZING" => Ok(ClusterStateReplicationStateEnum::READYOPTIMIZING),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a ClusterStateReplicationStateEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region DataBoostIsolationReadOnlyComputeBillingOwnerEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// The Compute Billing Owner for this Data Boost App Profile.
+pub enum DataBoostIsolationReadOnlyComputeBillingOwnerEnum {
+    
+
+    /// Unspecified value.
+    ///
+    /// "COMPUTE_BILLING_OWNER_UNSPECIFIED"
+    #[serde(rename="COMPUTE_BILLING_OWNER_UNSPECIFIED")]
+    COMPUTEBILLINGOWNERUNSPECIFIED,
+    
+
+    /// The host Cloud Project containing the targeted Bigtable Instance / Table pays for compute.
+    ///
+    /// "HOST_PAYS"
+    #[serde(rename="HOST_PAYS")]
+    HOSTPAYS,
+}
+
+impl AsRef<str> for DataBoostIsolationReadOnlyComputeBillingOwnerEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            DataBoostIsolationReadOnlyComputeBillingOwnerEnum::COMPUTEBILLINGOWNERUNSPECIFIED => "COMPUTE_BILLING_OWNER_UNSPECIFIED",
+            DataBoostIsolationReadOnlyComputeBillingOwnerEnum::HOSTPAYS => "HOST_PAYS",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for DataBoostIsolationReadOnlyComputeBillingOwnerEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "COMPUTE_BILLING_OWNER_UNSPECIFIED" => Ok(DataBoostIsolationReadOnlyComputeBillingOwnerEnum::COMPUTEBILLINGOWNERUNSPECIFIED),
+           "HOST_PAYS" => Ok(DataBoostIsolationReadOnlyComputeBillingOwnerEnum::HOSTPAYS),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a DataBoostIsolationReadOnlyComputeBillingOwnerEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region EncryptionInfoEncryptionTypeEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// Output only. The type of encryption used to protect this resource.
+pub enum EncryptionInfoEncryptionTypeEnum {
+    
+
+    /// Encryption type was not specified, though data at rest remains encrypted.
+    ///
+    /// "ENCRYPTION_TYPE_UNSPECIFIED"
+    #[serde(rename="ENCRYPTION_TYPE_UNSPECIFIED")]
+    ENCRYPTIONTYPEUNSPECIFIED,
+    
+
+    /// The data backing this resource is encrypted at rest with a key that is fully managed by Google. No key version or status will be populated. This is the default state.
+    ///
+    /// "GOOGLE_DEFAULT_ENCRYPTION"
+    #[serde(rename="GOOGLE_DEFAULT_ENCRYPTION")]
+    GOOGLEDEFAULTENCRYPTION,
+    
+
+    /// The data backing this resource is encrypted at rest with a key that is managed by the customer. The in-use version of the key and its status are populated for CMEK-protected tables. CMEK-protected backups are pinned to the key version that was in use at the time the backup was taken. This key version is populated but its status is not tracked and is reported as `UNKNOWN`.
+    ///
+    /// "CUSTOMER_MANAGED_ENCRYPTION"
+    #[serde(rename="CUSTOMER_MANAGED_ENCRYPTION")]
+    CUSTOMERMANAGEDENCRYPTION,
+}
+
+impl AsRef<str> for EncryptionInfoEncryptionTypeEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            EncryptionInfoEncryptionTypeEnum::ENCRYPTIONTYPEUNSPECIFIED => "ENCRYPTION_TYPE_UNSPECIFIED",
+            EncryptionInfoEncryptionTypeEnum::GOOGLEDEFAULTENCRYPTION => "GOOGLE_DEFAULT_ENCRYPTION",
+            EncryptionInfoEncryptionTypeEnum::CUSTOMERMANAGEDENCRYPTION => "CUSTOMER_MANAGED_ENCRYPTION",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for EncryptionInfoEncryptionTypeEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "ENCRYPTION_TYPE_UNSPECIFIED" => Ok(EncryptionInfoEncryptionTypeEnum::ENCRYPTIONTYPEUNSPECIFIED),
+           "GOOGLE_DEFAULT_ENCRYPTION" => Ok(EncryptionInfoEncryptionTypeEnum::GOOGLEDEFAULTENCRYPTION),
+           "CUSTOMER_MANAGED_ENCRYPTION" => Ok(EncryptionInfoEncryptionTypeEnum::CUSTOMERMANAGEDENCRYPTION),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a EncryptionInfoEncryptionTypeEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region InstanceStateEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// Output only. The current state of the instance.
+pub enum InstanceStateEnum {
+    
+
+    /// The state of the instance could not be determined.
+    ///
+    /// "STATE_NOT_KNOWN"
+    #[serde(rename="STATE_NOT_KNOWN")]
+    STATENOTKNOWN,
+    
+
+    /// The instance has been successfully created and can serve requests to its tables.
+    ///
+    /// "READY"
+    #[serde(rename="READY")]
+    READY,
+    
+
+    /// The instance is currently being created, and may be destroyed if the creation process encounters an error.
+    ///
+    /// "CREATING"
+    #[serde(rename="CREATING")]
+    CREATING,
+}
+
+impl AsRef<str> for InstanceStateEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            InstanceStateEnum::STATENOTKNOWN => "STATE_NOT_KNOWN",
+            InstanceStateEnum::READY => "READY",
+            InstanceStateEnum::CREATING => "CREATING",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for InstanceStateEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "STATE_NOT_KNOWN" => Ok(InstanceStateEnum::STATENOTKNOWN),
+           "READY" => Ok(InstanceStateEnum::READY),
+           "CREATING" => Ok(InstanceStateEnum::CREATING),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a InstanceStateEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region InstanceTypeEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// The type of the instance. Defaults to `PRODUCTION`.
+pub enum InstanceTypeEnum {
+    
+
+    /// The type of the instance is unspecified. If set when creating an instance, a `PRODUCTION` instance will be created. If set when updating an instance, the type will be left unchanged.
+    ///
+    /// "TYPE_UNSPECIFIED"
+    #[serde(rename="TYPE_UNSPECIFIED")]
+    TYPEUNSPECIFIED,
+    
+
+    /// An instance meant for production use. `serve_nodes` must be set on the cluster.
+    ///
+    /// "PRODUCTION"
+    #[serde(rename="PRODUCTION")]
+    PRODUCTION,
+    
+
+    /// DEPRECATED: Prefer PRODUCTION for all use cases, as it no longer enforces a higher minimum node count than DEVELOPMENT.
+    ///
+    /// "DEVELOPMENT"
+    #[serde(rename="DEVELOPMENT")]
+    DEVELOPMENT,
+}
+
+impl AsRef<str> for InstanceTypeEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            InstanceTypeEnum::TYPEUNSPECIFIED => "TYPE_UNSPECIFIED",
+            InstanceTypeEnum::PRODUCTION => "PRODUCTION",
+            InstanceTypeEnum::DEVELOPMENT => "DEVELOPMENT",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for InstanceTypeEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "TYPE_UNSPECIFIED" => Ok(InstanceTypeEnum::TYPEUNSPECIFIED),
+           "PRODUCTION" => Ok(InstanceTypeEnum::PRODUCTION),
+           "DEVELOPMENT" => Ok(InstanceTypeEnum::DEVELOPMENT),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a InstanceTypeEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region RestoreInfoSourceTypeEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// The type of the restore source.
+pub enum RestoreInfoSourceTypeEnum {
+    
+
+    /// No restore associated.
+    ///
+    /// "RESTORE_SOURCE_TYPE_UNSPECIFIED"
+    #[serde(rename="RESTORE_SOURCE_TYPE_UNSPECIFIED")]
+    RESTORESOURCETYPEUNSPECIFIED,
+    
+
+    /// A backup was used as the source of the restore.
+    ///
+    /// "BACKUP"
+    #[serde(rename="BACKUP")]
+    BACKUP,
+}
+
+impl AsRef<str> for RestoreInfoSourceTypeEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            RestoreInfoSourceTypeEnum::RESTORESOURCETYPEUNSPECIFIED => "RESTORE_SOURCE_TYPE_UNSPECIFIED",
+            RestoreInfoSourceTypeEnum::BACKUP => "BACKUP",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for RestoreInfoSourceTypeEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "RESTORE_SOURCE_TYPE_UNSPECIFIED" => Ok(RestoreInfoSourceTypeEnum::RESTORESOURCETYPEUNSPECIFIED),
+           "BACKUP" => Ok(RestoreInfoSourceTypeEnum::BACKUP),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a RestoreInfoSourceTypeEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region StandardIsolationPriorityEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// The priority of requests sent using this app profile.
+pub enum StandardIsolationPriorityEnum {
+    
+
+    /// Default value. Mapped to PRIORITY_HIGH (the legacy behavior) on creation.
+    ///
+    /// "PRIORITY_UNSPECIFIED"
+    #[serde(rename="PRIORITY_UNSPECIFIED")]
+    PRIORITYUNSPECIFIED,
+    
+    /// "PRIORITY_LOW"
+    #[serde(rename="PRIORITY_LOW")]
+    PRIORITYLOW,
+    
+    /// "PRIORITY_MEDIUM"
+    #[serde(rename="PRIORITY_MEDIUM")]
+    PRIORITYMEDIUM,
+    
+    /// "PRIORITY_HIGH"
+    #[serde(rename="PRIORITY_HIGH")]
+    PRIORITYHIGH,
+}
+
+impl AsRef<str> for StandardIsolationPriorityEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            StandardIsolationPriorityEnum::PRIORITYUNSPECIFIED => "PRIORITY_UNSPECIFIED",
+            StandardIsolationPriorityEnum::PRIORITYLOW => "PRIORITY_LOW",
+            StandardIsolationPriorityEnum::PRIORITYMEDIUM => "PRIORITY_MEDIUM",
+            StandardIsolationPriorityEnum::PRIORITYHIGH => "PRIORITY_HIGH",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for StandardIsolationPriorityEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "PRIORITY_UNSPECIFIED" => Ok(StandardIsolationPriorityEnum::PRIORITYUNSPECIFIED),
+           "PRIORITY_LOW" => Ok(StandardIsolationPriorityEnum::PRIORITYLOW),
+           "PRIORITY_MEDIUM" => Ok(StandardIsolationPriorityEnum::PRIORITYMEDIUM),
+           "PRIORITY_HIGH" => Ok(StandardIsolationPriorityEnum::PRIORITYHIGH),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a StandardIsolationPriorityEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region TableGranularityEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// Immutable. The granularity (i.e. `MILLIS`) at which timestamps are stored in this table. Timestamps not matching the granularity will be rejected. If unspecified at creation time, the value will be set to `MILLIS`. Views: `SCHEMA_VIEW`, `FULL`.
+pub enum TableGranularityEnum {
+    
+
+    /// The user did not specify a granularity. Should not be returned. When specified during table creation, MILLIS will be used.
+    ///
+    /// "TIMESTAMP_GRANULARITY_UNSPECIFIED"
+    #[serde(rename="TIMESTAMP_GRANULARITY_UNSPECIFIED")]
+    TIMESTAMPGRANULARITYUNSPECIFIED,
+    
+
+    /// The table keeps data versioned at a granularity of 1ms.
+    ///
+    /// "MILLIS"
+    #[serde(rename="MILLIS")]
+    MILLIS,
+}
+
+impl AsRef<str> for TableGranularityEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            TableGranularityEnum::TIMESTAMPGRANULARITYUNSPECIFIED => "TIMESTAMP_GRANULARITY_UNSPECIFIED",
+            TableGranularityEnum::MILLIS => "MILLIS",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for TableGranularityEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "TIMESTAMP_GRANULARITY_UNSPECIFIED" => Ok(TableGranularityEnum::TIMESTAMPGRANULARITYUNSPECIFIED),
+           "MILLIS" => Ok(TableGranularityEnum::MILLIS),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a TableGranularityEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region ProjectViewEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// The view to be applied to the returned tables' fields. Only NAME_ONLY view (default), REPLICATION_VIEW and ENCRYPTION_VIEW are supported.
+pub enum ProjectViewEnum {
+    
+
+    /// Uses the default view for each method as documented in its request.
+    ///
+    /// "VIEW_UNSPECIFIED"
+    #[serde(rename="VIEW_UNSPECIFIED")]
+    VIEWUNSPECIFIED,
+    
+
+    /// Only populates `name`.
+    ///
+    /// "NAME_ONLY"
+    #[serde(rename="NAME_ONLY")]
+    NAMEONLY,
+    
+
+    /// Only populates `name` and fields related to the table's schema.
+    ///
+    /// "SCHEMA_VIEW"
+    #[serde(rename="SCHEMA_VIEW")]
+    SCHEMAVIEW,
+    
+
+    /// Only populates `name` and fields related to the table's replication state.
+    ///
+    /// "REPLICATION_VIEW"
+    #[serde(rename="REPLICATION_VIEW")]
+    REPLICATIONVIEW,
+    
+
+    /// Only populates `name` and fields related to the table's encryption state.
+    ///
+    /// "ENCRYPTION_VIEW"
+    #[serde(rename="ENCRYPTION_VIEW")]
+    ENCRYPTIONVIEW,
+    
+
+    /// Only populates `name` and fields related to the table's stats (e.g. TableStats and ColumnFamilyStats).
+    ///
+    /// "STATS_VIEW"
+    #[serde(rename="STATS_VIEW")]
+    STATSVIEW,
+    
+
+    /// Populates all fields except for stats. See STATS_VIEW to request stats.
+    ///
+    /// "FULL"
+    #[serde(rename="FULL")]
+    FULL,
+}
+
+impl AsRef<str> for ProjectViewEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            ProjectViewEnum::VIEWUNSPECIFIED => "VIEW_UNSPECIFIED",
+            ProjectViewEnum::NAMEONLY => "NAME_ONLY",
+            ProjectViewEnum::SCHEMAVIEW => "SCHEMA_VIEW",
+            ProjectViewEnum::REPLICATIONVIEW => "REPLICATION_VIEW",
+            ProjectViewEnum::ENCRYPTIONVIEW => "ENCRYPTION_VIEW",
+            ProjectViewEnum::STATSVIEW => "STATS_VIEW",
+            ProjectViewEnum::FULL => "FULL",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for ProjectViewEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "VIEW_UNSPECIFIED" => Ok(ProjectViewEnum::VIEWUNSPECIFIED),
+           "NAME_ONLY" => Ok(ProjectViewEnum::NAMEONLY),
+           "SCHEMA_VIEW" => Ok(ProjectViewEnum::SCHEMAVIEW),
+           "REPLICATION_VIEW" => Ok(ProjectViewEnum::REPLICATIONVIEW),
+           "ENCRYPTION_VIEW" => Ok(ProjectViewEnum::ENCRYPTIONVIEW),
+           "STATS_VIEW" => Ok(ProjectViewEnum::STATSVIEW),
+           "FULL" => Ok(ProjectViewEnum::FULL),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a ProjectViewEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
--- a/gen/bigtableadmin2/src/api/hub.rs
+++ b/gen/bigtableadmin2/src/api/hub.rs
@@ -0,0 +1,113 @@
+use super::*;
+
+/// Central instance to access all BigtableAdmin related resource activities
+///
+/// # Examples
+///
+/// Instantiate a new hub
+///
+/// ```test_harness,no_run
+/// extern crate hyper;
+/// extern crate hyper_rustls;
+/// extern crate google_bigtableadmin2 as bigtableadmin2;
+/// use bigtableadmin2::{Result, Error};
+/// use bigtableadmin2::api::enums::*;
+/// # async fn dox() {
+/// use std::default::Default;
+/// use bigtableadmin2::{BigtableAdmin, oauth2, hyper, hyper_rustls, chrono, FieldMask};
+/// 
+/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and
+/// // `client_secret`, among other things.
+/// let secret: oauth2::ApplicationSecret = Default::default();
+/// // Instantiate the authenticator. It will choose a suitable authentication flow for you,
+/// // unless you replace  `None` with the desired Flow.
+/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about
+/// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and
+/// // retrieve them from storage.
+/// let auth = oauth2::InstalledFlowAuthenticator::builder(
+///         secret,
+///         oauth2::InstalledFlowReturnMethod::HTTPRedirect,
+///     ).build().await.unwrap();
+/// let mut hub = BigtableAdmin::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().unwrap().https_or_http().enable_http1().build()), auth);
+/// // You can configure optional parameters by calling the respective setters at will, and
+/// // execute the final call using `doit()`.
+/// // Values shown here are possibly random and not representative !
+/// let result = hub.operations().projects_operations_list("name")
+///              .page_token("takimata")
+///              .page_size(-52)
+///              .filter("duo")
+///              .doit().await;
+/// 
+/// match result {
+///     Err(e) => match e {
+///         // The Error enum provides details about what exactly happened.
+///         // You can also just use its `Debug`, `Display` or `Error` traits
+///          Error::HttpError(_)
+///         |Error::Io(_)
+///         |Error::MissingAPIKey
+///         |Error::MissingToken(_)
+///         |Error::Cancelled
+///         |Error::UploadSizeLimitExceeded(_, _)
+///         |Error::Failure(_)
+///         |Error::BadRequest(_)
+///         |Error::FieldClash(_)
+///         |Error::JsonDecodeError(_, _) => println!("{}", e),
+///     },
+///     Ok(res) => println!("Success: {:?}", res),
+/// }
+/// # }
+/// ```
+#[derive(Clone)]
+pub struct BigtableAdmin<S> {
+    pub client: hyper::Client<S, hyper::body::Body>,
+    pub auth: Box<dyn client::GetToken>,
+    pub(super) _user_agent: String,
+    pub(super) _base_url: String,
+    pub(super) _root_url: String,
+}
+
+impl<'a, S> client::Hub for BigtableAdmin<S> {}
+
+impl<'a, S> BigtableAdmin<S> {
+
+    pub fn new<A: 'static + client::GetToken>(client: hyper::Client<S, hyper::body::Body>, auth: A) -> BigtableAdmin<S> {
+        BigtableAdmin {
+            client,
+            auth: Box::new(auth),
+            _user_agent: "google-api-rust-client/5.0.5".to_string(),
+            _base_url: "https://bigtableadmin.googleapis.com/".to_string(),
+            _root_url: "https://bigtableadmin.googleapis.com/".to_string(),
+        }
+    }
+
+    pub fn operations(&'a self) -> OperationMethods<'a, S> {
+        OperationMethods { hub: &self }
+    }
+    pub fn projects(&'a self) -> ProjectMethods<'a, S> {
+        ProjectMethods { hub: &self }
+    }
+
+    /// Set the user-agent header field to use in all requests to the server.
+    /// It defaults to `google-api-rust-client/5.0.5`.
+    ///
+    /// Returns the previously set user-agent.
+    pub fn user_agent(&mut self, agent_name: String) -> String {
+        mem::replace(&mut self._user_agent, agent_name)
+    }
+
+    /// Set the base url to use in all requests to the server.
+    /// It defaults to `https://bigtableadmin.googleapis.com/`.
+    ///
+    /// Returns the previously set base url.
+    pub fn base_url(&mut self, new_base_url: String) -> String {
+        mem::replace(&mut self._base_url, new_base_url)
+    }
+
+    /// Set the root url to use in all requests to the server.
+    /// It defaults to `https://bigtableadmin.googleapis.com/`.
+    ///
+    /// Returns the previously set root url.
+    pub fn root_url(&mut self, new_root_url: String) -> String {
+        mem::replace(&mut self._root_url, new_root_url)
+    }
+}
--- a/gen/bigtableadmin2/src/api/method_builders.rs
+++ b/gen/bigtableadmin2/src/api/method_builders.rs
--- a/gen/bigtableadmin2/src/api/mod.rs
+++ b/gen/bigtableadmin2/src/api/mod.rs
@@ -0,0 +1,35 @@
+use std::collections::HashMap;
+use std::cell::RefCell;
+use std::default::Default;
+use std::collections::BTreeSet;
+use std::error::Error as StdError;
+use serde_json as json;
+use std::io;
+use std::fs;
+use std::mem;
+
+use hyper::client::connect;
+use tokio::io::{AsyncRead, AsyncWrite};
+use tokio::time::sleep;
+use tower_service;
+use serde::{Serialize, Deserialize};
+
+use crate::{client, client::GetToken, client::serde_with};
+
+mod utilities;
+pub use utilities::*;
+
+mod hub;
+pub use hub::*;
+
+mod schemas;
+pub use schemas::*;
+
+mod method_builders;
+pub use method_builders::*;
+
+mod call_builders;
+pub use call_builders::*;
+
+pub mod enums;
+pub(crate) use enums::*;
--- a/gen/bigtableadmin2/src/api/schemas.rs
+++ b/gen/bigtableadmin2/src/api/schemas.rs
--- a/gen/bigtableadmin2/src/api/utilities.rs
+++ b/gen/bigtableadmin2/src/api/utilities.rs
@@ -0,0 +1,56 @@
+use super::*;
+/// Identifies the an OAuth2 authorization scope.
+/// A scope is needed when requesting an
+/// [authorization token](https://developers.google.com/youtube/v3/guides/authentication).
+#[derive(PartialEq, Eq, Hash, Debug, Clone)]
+pub enum Scope {
+    /// Administer your Cloud Bigtable tables and clusters
+    BigtableAdmin,
+
+    /// Administer your Cloud Bigtable clusters
+    BigtableAdminCluster,
+
+    /// Administer your Cloud Bigtable clusters
+    BigtableAdminInstance,
+
+    /// Administer your Cloud Bigtable tables
+    BigtableAdminTable,
+
+    /// Administer your Cloud Bigtable tables and clusters
+    CloudBigtableAdmin,
+
+    /// Administer your Cloud Bigtable clusters
+    CloudBigtableAdminCluster,
+
+    /// Administer your Cloud Bigtable tables
+    CloudBigtableAdminTable,
+
+    /// See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account.
+    CloudPlatform,
+
+    /// View your data across Google Cloud services and see the email address of your Google Account
+    CloudPlatformReadOnly,
+}
+
+impl AsRef<str> for Scope {
+    fn as_ref(&self) -> &str {
+        match *self {
+            Scope::BigtableAdmin => "https://www.googleapis.com/auth/bigtable.admin",
+            Scope::BigtableAdminCluster => "https://www.googleapis.com/auth/bigtable.admin.cluster",
+            Scope::BigtableAdminInstance => "https://www.googleapis.com/auth/bigtable.admin.instance",
+            Scope::BigtableAdminTable => "https://www.googleapis.com/auth/bigtable.admin.table",
+            Scope::CloudBigtableAdmin => "https://www.googleapis.com/auth/cloud-bigtable.admin",
+            Scope::CloudBigtableAdminCluster => "https://www.googleapis.com/auth/cloud-bigtable.admin.cluster",
+            Scope::CloudBigtableAdminTable => "https://www.googleapis.com/auth/cloud-bigtable.admin.table",
+            Scope::CloudPlatform => "https://www.googleapis.com/auth/cloud-platform",
+            Scope::CloudPlatformReadOnly => "https://www.googleapis.com/auth/cloud-platform.read-only",
+        }
+    }
+}
+
+impl Default for Scope {
+    fn default() -> Scope {
+        Scope::BigtableAdmin
+    }
+}
+
--- a/gen/bigtableadmin2/src/lib.rs
+++ b/gen/bigtableadmin2/src/lib.rs
@@ -2,19 +2,19 @@
 // This file was generated automatically from 'src/generator/templates/api/lib.rs.mako'
 // DO NOT EDIT !

-//! This documentation was generated from *Bigtable Admin* crate version *5.0.4+20240221*, where *20240221* is the exact revision of the *bigtableadmin:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v5.0.4*.
+//! This documentation was generated from *Bigtable Admin* crate version *5.0.5+20240331*, where *20240331* is the exact revision of the *bigtableadmin:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v5.0.5*.
 //! 
 //! Everything else about the *Bigtable Admin* *v2* API can be found at the
 //! [official documentation site](https://cloud.google.com/bigtable/).
 //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/bigtableadmin2).
 //! # Features
 //! 
-//! Handle the following *Resources* with ease from the central [hub](BigtableAdmin) ... 
+//! Handle the following *Resources* with ease from the central [hub](BigtableAdmin) ...
 //! 
 //! * [operations](api::Operation)
 //!  * [*get*](api::OperationGetCall) and [*projects operations list*](api::OperationProjectOperationListCall)
 //! * projects
-//!  * [*instances app profiles create*](api::ProjectInstanceAppProfileCreateCall), [*instances app profiles delete*](api::ProjectInstanceAppProfileDeleteCall), [*instances app profiles get*](api::ProjectInstanceAppProfileGetCall), [*instances app profiles list*](api::ProjectInstanceAppProfileListCall), [*instances app profiles patch*](api::ProjectInstanceAppProfilePatchCall), [*instances clusters backups copy*](api::ProjectInstanceClusterBackupCopyCall), [*instances clusters backups create*](api::ProjectInstanceClusterBackupCreateCall), [*instances clusters backups delete*](api::ProjectInstanceClusterBackupDeleteCall), [*instances clusters backups get*](api::ProjectInstanceClusterBackupGetCall), [*instances clusters backups get iam policy*](api::ProjectInstanceClusterBackupGetIamPolicyCall), [*instances clusters backups list*](api::ProjectInstanceClusterBackupListCall), [*instances clusters backups patch*](api::ProjectInstanceClusterBackupPatchCall), [*instances clusters backups set iam policy*](api::ProjectInstanceClusterBackupSetIamPolicyCall), [*instances clusters backups test iam permissions*](api::ProjectInstanceClusterBackupTestIamPermissionCall), [*instances clusters create*](api::ProjectInstanceClusterCreateCall), [*instances clusters delete*](api::ProjectInstanceClusterDeleteCall), [*instances clusters get*](api::ProjectInstanceClusterGetCall), [*instances clusters hot tablets list*](api::ProjectInstanceClusterHotTabletListCall), [*instances clusters list*](api::ProjectInstanceClusterListCall), [*instances clusters partial update cluster*](api::ProjectInstanceClusterPartialUpdateClusterCall), [*instances clusters update*](api::ProjectInstanceClusterUpdateCall), [*instances create*](api::ProjectInstanceCreateCall), [*instances delete*](api::ProjectInstanceDeleteCall), [*instances get*](api::ProjectInstanceGetCall), [*instances get iam policy*](api::ProjectInstanceGetIamPolicyCall), [*instances list*](api::ProjectInstanceListCall), [*instances partial update instance*](api::ProjectInstancePartialUpdateInstanceCall), [*instances set iam policy*](api::ProjectInstanceSetIamPolicyCall), [*instances tables check consistency*](api::ProjectInstanceTableCheckConsistencyCall), [*instances tables create*](api::ProjectInstanceTableCreateCall), [*instances tables delete*](api::ProjectInstanceTableDeleteCall), [*instances tables drop row range*](api::ProjectInstanceTableDropRowRangeCall), [*instances tables generate consistency token*](api::ProjectInstanceTableGenerateConsistencyTokenCall), [*instances tables get*](api::ProjectInstanceTableGetCall), [*instances tables get iam policy*](api::ProjectInstanceTableGetIamPolicyCall), [*instances tables list*](api::ProjectInstanceTableListCall), [*instances tables modify column families*](api::ProjectInstanceTableModifyColumnFamilyCall), [*instances tables patch*](api::ProjectInstanceTablePatchCall), [*instances tables restore*](api::ProjectInstanceTableRestoreCall), [*instances tables set iam policy*](api::ProjectInstanceTableSetIamPolicyCall), [*instances tables test iam permissions*](api::ProjectInstanceTableTestIamPermissionCall), [*instances tables undelete*](api::ProjectInstanceTableUndeleteCall), [*instances test iam permissions*](api::ProjectInstanceTestIamPermissionCall), [*instances update*](api::ProjectInstanceUpdateCall) and [*locations list*](api::ProjectLocationListCall)
+//!  * [*instances app profiles create*](api::ProjectInstanceAppProfileCreateCall), [*instances app profiles delete*](api::ProjectInstanceAppProfileDeleteCall), [*instances app profiles get*](api::ProjectInstanceAppProfileGetCall), [*instances app profiles list*](api::ProjectInstanceAppProfileListCall), [*instances app profiles patch*](api::ProjectInstanceAppProfilePatchCall), [*instances clusters backups copy*](api::ProjectInstanceClusterBackupCopyCall), [*instances clusters backups create*](api::ProjectInstanceClusterBackupCreateCall), [*instances clusters backups delete*](api::ProjectInstanceClusterBackupDeleteCall), [*instances clusters backups get*](api::ProjectInstanceClusterBackupGetCall), [*instances clusters backups get iam policy*](api::ProjectInstanceClusterBackupGetIamPolicyCall), [*instances clusters backups list*](api::ProjectInstanceClusterBackupListCall), [*instances clusters backups patch*](api::ProjectInstanceClusterBackupPatchCall), [*instances clusters backups set iam policy*](api::ProjectInstanceClusterBackupSetIamPolicyCall), [*instances clusters backups test iam permissions*](api::ProjectInstanceClusterBackupTestIamPermissionCall), [*instances clusters create*](api::ProjectInstanceClusterCreateCall), [*instances clusters delete*](api::ProjectInstanceClusterDeleteCall), [*instances clusters get*](api::ProjectInstanceClusterGetCall), [*instances clusters hot tablets list*](api::ProjectInstanceClusterHotTabletListCall), [*instances clusters list*](api::ProjectInstanceClusterListCall), [*instances clusters partial update cluster*](api::ProjectInstanceClusterPartialUpdateClusterCall), [*instances clusters update*](api::ProjectInstanceClusterUpdateCall), [*instances create*](api::ProjectInstanceCreateCall), [*instances delete*](api::ProjectInstanceDeleteCall), [*instances get*](api::ProjectInstanceGetCall), [*instances get iam policy*](api::ProjectInstanceGetIamPolicyCall), [*instances list*](api::ProjectInstanceListCall), [*instances partial update instance*](api::ProjectInstancePartialUpdateInstanceCall), [*instances set iam policy*](api::ProjectInstanceSetIamPolicyCall), [*instances tables authorized views create*](api::ProjectInstanceTableAuthorizedViewCreateCall), [*instances tables authorized views delete*](api::ProjectInstanceTableAuthorizedViewDeleteCall), [*instances tables authorized views get*](api::ProjectInstanceTableAuthorizedViewGetCall), [*instances tables authorized views get iam policy*](api::ProjectInstanceTableAuthorizedViewGetIamPolicyCall), [*instances tables authorized views list*](api::ProjectInstanceTableAuthorizedViewListCall), [*instances tables authorized views patch*](api::ProjectInstanceTableAuthorizedViewPatchCall), [*instances tables authorized views set iam policy*](api::ProjectInstanceTableAuthorizedViewSetIamPolicyCall), [*instances tables authorized views test iam permissions*](api::ProjectInstanceTableAuthorizedViewTestIamPermissionCall), [*instances tables check consistency*](api::ProjectInstanceTableCheckConsistencyCall), [*instances tables create*](api::ProjectInstanceTableCreateCall), [*instances tables delete*](api::ProjectInstanceTableDeleteCall), [*instances tables drop row range*](api::ProjectInstanceTableDropRowRangeCall), [*instances tables generate consistency token*](api::ProjectInstanceTableGenerateConsistencyTokenCall), [*instances tables get*](api::ProjectInstanceTableGetCall), [*instances tables get iam policy*](api::ProjectInstanceTableGetIamPolicyCall), [*instances tables list*](api::ProjectInstanceTableListCall), [*instances tables modify column families*](api::ProjectInstanceTableModifyColumnFamilyCall), [*instances tables patch*](api::ProjectInstanceTablePatchCall), [*instances tables restore*](api::ProjectInstanceTableRestoreCall), [*instances tables set iam policy*](api::ProjectInstanceTableSetIamPolicyCall), [*instances tables test iam permissions*](api::ProjectInstanceTableTestIamPermissionCall), [*instances tables undelete*](api::ProjectInstanceTableUndeleteCall), [*instances test iam permissions*](api::ProjectInstanceTestIamPermissionCall), [*instances update*](api::ProjectInstanceUpdateCall) and [*locations list*](api::ProjectLocationListCall)
 //! 
 //! 
 //! 
@@ -57,6 +57,8 @@
 //! let r = hub.projects().instances_clusters_create(...).doit().await
 //! let r = hub.projects().instances_clusters_partial_update_cluster(...).doit().await
 //! let r = hub.projects().instances_clusters_update(...).doit().await
+//! let r = hub.projects().instances_tables_authorized_views_create(...).doit().await
+//! let r = hub.projects().instances_tables_authorized_views_patch(...).doit().await
 //! let r = hub.projects().instances_tables_patch(...).doit().await
 //! let r = hub.projects().instances_tables_restore(...).doit().await
 //! let r = hub.projects().instances_tables_undelete(...).doit().await
@@ -64,8 +66,8 @@
 //! let r = hub.projects().instances_partial_update_instance(...).doit().await
 //! ```
 //! 
-//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` 
-//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be 
+//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities`
+//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be
 //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired.
 //! The `doit()` method performs the actual communication with the server and returns the respective result.
 //! 
@@ -89,23 +91,24 @@
 //! extern crate hyper_rustls;
 //! extern crate google_bigtableadmin2 as bigtableadmin2;
 //! use bigtableadmin2::{Result, Error};
+//! use bigtableadmin2::api::enums::*;
 //! # async fn dox() {
 //! use std::default::Default;
 //! use bigtableadmin2::{BigtableAdmin, oauth2, hyper, hyper_rustls, chrono, FieldMask};
 //! 
-//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and 
+//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and
 //! // `client_secret`, among other things.
 //! let secret: oauth2::ApplicationSecret = Default::default();
-//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, 
+//! // Instantiate the authenticator. It will choose a suitable authentication flow for you,
 //! // unless you replace  `None` with the desired Flow.
-//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about 
+//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about
 //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and
 //! // retrieve them from storage.
 //! let auth = oauth2::InstalledFlowAuthenticator::builder(
 //!         secret,
 //!         oauth2::InstalledFlowReturnMethod::HTTPRedirect,
 //!     ).build().await.unwrap();
-//! let mut hub = BigtableAdmin::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().build()), auth);
+//! let mut hub = BigtableAdmin::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().unwrap().https_or_http().enable_http1().build()), auth);
 //! // You can configure optional parameters by calling the respective setters at will, and
 //! // execute the final call using `doit()`.
 //! // Values shown here are possibly random and not representative !
@@ -137,10 +140,10 @@
 //! ## Handling Errors
 //! 
 //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of
-//! the doit() methods, or handed as possibly intermediate results to either the 
+//! the doit() methods, or handed as possibly intermediate results to either the
 //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html).
 //! 
-//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This 
+//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This
 //! makes the system potentially resilient to all kinds of errors.
 //! 
 //! ## Uploads and Downloads
@@ -150,25 +153,25 @@
 //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making
 //! this call: `.param("alt", "media")`.
 //! 
-//! Methods supporting uploads can do so using up to 2 different protocols: 
-//! *simple* and *resumable*. The distinctiveness of each is represented by customized 
+//! Methods supporting uploads can do so using up to 2 different protocols:
+//! *simple* and *resumable*. The distinctiveness of each is represented by customized
 //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively.
 //! 
 //! ## Customization and Callbacks
 //! 
-//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the 
-//! [Method Builder](client::CallBuilder) before making the final `doit()` call. 
-//! Respective methods will be called to provide progress information, as well as determine whether the system should 
+//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the
+//! [Method Builder](client::CallBuilder) before making the final `doit()` call.
+//! Respective methods will be called to provide progress information, as well as determine whether the system should
 //! retry on failure.
 //! 
 //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort.
 //! 
 //! ## Optional Parts in Server-Requests
 //! 
-//! All structures provided by this library are made to be [encodable](client::RequestValue) and 
-//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses 
+//! All structures provided by this library are made to be [encodable](client::RequestValue) and
+//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses
 //! are valid.
-//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to 
+//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to
 //! the server to indicate either the set parts of the request or the desired parts in the response.
 //! 
 //! ## Builder Arguments