make regen-apis

gen/cloudbilling1/src/api/enums.rs

@@ -0,0 +1,238 @@
+use super::*;
+
+
+
+// region AggregationInfoAggregationIntervalEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+pub enum AggregationInfoAggregationIntervalEnum {
+    
+    /// "AGGREGATION_INTERVAL_UNSPECIFIED"
+    #[serde(rename="AGGREGATION_INTERVAL_UNSPECIFIED")]
+    AGGREGATIONINTERVALUNSPECIFIED,
+    
+    /// "DAILY"
+    #[serde(rename="DAILY")]
+    DAILY,
+    
+    /// "MONTHLY"
+    #[serde(rename="MONTHLY")]
+    MONTHLY,
+}
+
+impl AsRef<str> for AggregationInfoAggregationIntervalEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            AggregationInfoAggregationIntervalEnum::AGGREGATIONINTERVALUNSPECIFIED => "AGGREGATION_INTERVAL_UNSPECIFIED",
+            AggregationInfoAggregationIntervalEnum::DAILY => "DAILY",
+            AggregationInfoAggregationIntervalEnum::MONTHLY => "MONTHLY",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for AggregationInfoAggregationIntervalEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "AGGREGATION_INTERVAL_UNSPECIFIED" => Ok(AggregationInfoAggregationIntervalEnum::AGGREGATIONINTERVALUNSPECIFIED),
+           "DAILY" => Ok(AggregationInfoAggregationIntervalEnum::DAILY),
+           "MONTHLY" => Ok(AggregationInfoAggregationIntervalEnum::MONTHLY),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a AggregationInfoAggregationIntervalEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region AggregationInfoAggregationLevelEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+pub enum AggregationInfoAggregationLevelEnum {
+    
+    /// "AGGREGATION_LEVEL_UNSPECIFIED"
+    #[serde(rename="AGGREGATION_LEVEL_UNSPECIFIED")]
+    AGGREGATIONLEVELUNSPECIFIED,
+    
+    /// "ACCOUNT"
+    #[serde(rename="ACCOUNT")]
+    ACCOUNT,
+    
+    /// "PROJECT"
+    #[serde(rename="PROJECT")]
+    PROJECT,
+}
+
+impl AsRef<str> for AggregationInfoAggregationLevelEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            AggregationInfoAggregationLevelEnum::AGGREGATIONLEVELUNSPECIFIED => "AGGREGATION_LEVEL_UNSPECIFIED",
+            AggregationInfoAggregationLevelEnum::ACCOUNT => "ACCOUNT",
+            AggregationInfoAggregationLevelEnum::PROJECT => "PROJECT",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for AggregationInfoAggregationLevelEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "AGGREGATION_LEVEL_UNSPECIFIED" => Ok(AggregationInfoAggregationLevelEnum::AGGREGATIONLEVELUNSPECIFIED),
+           "ACCOUNT" => Ok(AggregationInfoAggregationLevelEnum::ACCOUNT),
+           "PROJECT" => Ok(AggregationInfoAggregationLevelEnum::PROJECT),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a AggregationInfoAggregationLevelEnum {
+    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 GeoTaxonomyTypeEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// The type of Geo Taxonomy: GLOBAL, REGIONAL, or MULTI_REGIONAL.
+pub enum GeoTaxonomyTypeEnum {
+    
+
+    /// The type is not specified.
+    ///
+    /// "TYPE_UNSPECIFIED"
+    #[serde(rename="TYPE_UNSPECIFIED")]
+    TYPEUNSPECIFIED,
+    
+
+    /// The sku is global in nature, e.g. a license sku. Global skus are available in all regions, and so have an empty region list.
+    ///
+    /// "GLOBAL"
+    #[serde(rename="GLOBAL")]
+    GLOBAL,
+    
+
+    /// The sku is available in a specific region, e.g. "us-west2".
+    ///
+    /// "REGIONAL"
+    #[serde(rename="REGIONAL")]
+    REGIONAL,
+    
+
+    /// The sku is associated with multiple regions, e.g. "us-west2" and "us-east1".
+    ///
+    /// "MULTI_REGIONAL"
+    #[serde(rename="MULTI_REGIONAL")]
+    MULTIREGIONAL,
+}
+
+impl AsRef<str> for GeoTaxonomyTypeEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            GeoTaxonomyTypeEnum::TYPEUNSPECIFIED => "TYPE_UNSPECIFIED",
+            GeoTaxonomyTypeEnum::GLOBAL => "GLOBAL",
+            GeoTaxonomyTypeEnum::REGIONAL => "REGIONAL",
+            GeoTaxonomyTypeEnum::MULTIREGIONAL => "MULTI_REGIONAL",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for GeoTaxonomyTypeEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "TYPE_UNSPECIFIED" => Ok(GeoTaxonomyTypeEnum::TYPEUNSPECIFIED),
+           "GLOBAL" => Ok(GeoTaxonomyTypeEnum::GLOBAL),
+           "REGIONAL" => Ok(GeoTaxonomyTypeEnum::REGIONAL),
+           "MULTI_REGIONAL" => Ok(GeoTaxonomyTypeEnum::MULTIREGIONAL),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a GeoTaxonomyTypeEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+