make regen-apis

gen/datastore1/src/api/enums.rs

@@ -0,0 +1,820 @@
+use super::*;
+
+
+
+// region AggregationResultBatchMoreResultsEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// The state of the query after the current batch. Only COUNT(*) aggregations are supported in the initial launch. Therefore, expected result type is limited to `NO_MORE_RESULTS`.
+pub enum AggregationResultBatchMoreResultsEnum {
+    
+
+    /// Unspecified. This value is never used.
+    ///
+    /// "MORE_RESULTS_TYPE_UNSPECIFIED"
+    #[serde(rename="MORE_RESULTS_TYPE_UNSPECIFIED")]
+    MORERESULTSTYPEUNSPECIFIED,
+    
+
+    /// There may be additional batches to fetch from this query.
+    ///
+    /// "NOT_FINISHED"
+    #[serde(rename="NOT_FINISHED")]
+    NOTFINISHED,
+    
+
+    /// The query is finished, but there may be more results after the limit.
+    ///
+    /// "MORE_RESULTS_AFTER_LIMIT"
+    #[serde(rename="MORE_RESULTS_AFTER_LIMIT")]
+    MORERESULTSAFTERLIMIT,
+    
+
+    /// The query is finished, but there may be more results after the end cursor.
+    ///
+    /// "MORE_RESULTS_AFTER_CURSOR"
+    #[serde(rename="MORE_RESULTS_AFTER_CURSOR")]
+    MORERESULTSAFTERCURSOR,
+    
+
+    /// The query is finished, and there are no more results.
+    ///
+    /// "NO_MORE_RESULTS"
+    #[serde(rename="NO_MORE_RESULTS")]
+    NOMORERESULTS,
+}
+
+impl AsRef<str> for AggregationResultBatchMoreResultsEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            AggregationResultBatchMoreResultsEnum::MORERESULTSTYPEUNSPECIFIED => "MORE_RESULTS_TYPE_UNSPECIFIED",
+            AggregationResultBatchMoreResultsEnum::NOTFINISHED => "NOT_FINISHED",
+            AggregationResultBatchMoreResultsEnum::MORERESULTSAFTERLIMIT => "MORE_RESULTS_AFTER_LIMIT",
+            AggregationResultBatchMoreResultsEnum::MORERESULTSAFTERCURSOR => "MORE_RESULTS_AFTER_CURSOR",
+            AggregationResultBatchMoreResultsEnum::NOMORERESULTS => "NO_MORE_RESULTS",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for AggregationResultBatchMoreResultsEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "MORE_RESULTS_TYPE_UNSPECIFIED" => Ok(AggregationResultBatchMoreResultsEnum::MORERESULTSTYPEUNSPECIFIED),
+           "NOT_FINISHED" => Ok(AggregationResultBatchMoreResultsEnum::NOTFINISHED),
+           "MORE_RESULTS_AFTER_LIMIT" => Ok(AggregationResultBatchMoreResultsEnum::MORERESULTSAFTERLIMIT),
+           "MORE_RESULTS_AFTER_CURSOR" => Ok(AggregationResultBatchMoreResultsEnum::MORERESULTSAFTERCURSOR),
+           "NO_MORE_RESULTS" => Ok(AggregationResultBatchMoreResultsEnum::NOMORERESULTS),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a AggregationResultBatchMoreResultsEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region CommitRequestModeEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// The type of commit to perform. Defaults to `TRANSACTIONAL`.
+pub enum CommitRequestModeEnum {
+    
+
+    /// Unspecified. This value must not be used.
+    ///
+    /// "MODE_UNSPECIFIED"
+    #[serde(rename="MODE_UNSPECIFIED")]
+    MODEUNSPECIFIED,
+    
+
+    /// Transactional: The mutations are either all applied, or none are applied. Learn about transactions [here](https://cloud.google.com/datastore/docs/concepts/transactions).
+    ///
+    /// "TRANSACTIONAL"
+    #[serde(rename="TRANSACTIONAL")]
+    TRANSACTIONAL,
+    
+
+    /// Non-transactional: The mutations may not apply as all or none.
+    ///
+    /// "NON_TRANSACTIONAL"
+    #[serde(rename="NON_TRANSACTIONAL")]
+    NONTRANSACTIONAL,
+}
+
+impl AsRef<str> for CommitRequestModeEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            CommitRequestModeEnum::MODEUNSPECIFIED => "MODE_UNSPECIFIED",
+            CommitRequestModeEnum::TRANSACTIONAL => "TRANSACTIONAL",
+            CommitRequestModeEnum::NONTRANSACTIONAL => "NON_TRANSACTIONAL",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for CommitRequestModeEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "MODE_UNSPECIFIED" => Ok(CommitRequestModeEnum::MODEUNSPECIFIED),
+           "TRANSACTIONAL" => Ok(CommitRequestModeEnum::TRANSACTIONAL),
+           "NON_TRANSACTIONAL" => Ok(CommitRequestModeEnum::NONTRANSACTIONAL),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a CommitRequestModeEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region CompositeFilterOpEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// The operator for combining multiple filters.
+pub enum CompositeFilterOpEnum {
+    
+
+    /// Unspecified. This value must not be used.
+    ///
+    /// "OPERATOR_UNSPECIFIED"
+    #[serde(rename="OPERATOR_UNSPECIFIED")]
+    OPERATORUNSPECIFIED,
+    
+
+    /// The results are required to satisfy each of the combined filters.
+    ///
+    /// "AND"
+    #[serde(rename="AND")]
+    AND,
+    
+
+    /// Documents are required to satisfy at least one of the combined filters.
+    ///
+    /// "OR"
+    #[serde(rename="OR")]
+    OR,
+}
+
+impl AsRef<str> for CompositeFilterOpEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            CompositeFilterOpEnum::OPERATORUNSPECIFIED => "OPERATOR_UNSPECIFIED",
+            CompositeFilterOpEnum::AND => "AND",
+            CompositeFilterOpEnum::OR => "OR",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for CompositeFilterOpEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "OPERATOR_UNSPECIFIED" => Ok(CompositeFilterOpEnum::OPERATORUNSPECIFIED),
+           "AND" => Ok(CompositeFilterOpEnum::AND),
+           "OR" => Ok(CompositeFilterOpEnum::OR),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a CompositeFilterOpEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region GoogleDatastoreAdminV1IndexAncestorEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// Required. The index's ancestor mode. Must not be ANCESTOR_MODE_UNSPECIFIED.
+pub enum GoogleDatastoreAdminV1IndexAncestorEnum {
+    
+
+    /// The ancestor mode is unspecified.
+    ///
+    /// "ANCESTOR_MODE_UNSPECIFIED"
+    #[serde(rename="ANCESTOR_MODE_UNSPECIFIED")]
+    ANCESTORMODEUNSPECIFIED,
+    
+
+    /// Do not include the entity's ancestors in the index.
+    ///
+    /// "NONE"
+    #[serde(rename="NONE")]
+    NONE,
+    
+
+    /// Include all the entity's ancestors in the index.
+    ///
+    /// "ALL_ANCESTORS"
+    #[serde(rename="ALL_ANCESTORS")]
+    ALLANCESTORS,
+}
+
+impl AsRef<str> for GoogleDatastoreAdminV1IndexAncestorEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            GoogleDatastoreAdminV1IndexAncestorEnum::ANCESTORMODEUNSPECIFIED => "ANCESTOR_MODE_UNSPECIFIED",
+            GoogleDatastoreAdminV1IndexAncestorEnum::NONE => "NONE",
+            GoogleDatastoreAdminV1IndexAncestorEnum::ALLANCESTORS => "ALL_ANCESTORS",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for GoogleDatastoreAdminV1IndexAncestorEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "ANCESTOR_MODE_UNSPECIFIED" => Ok(GoogleDatastoreAdminV1IndexAncestorEnum::ANCESTORMODEUNSPECIFIED),
+           "NONE" => Ok(GoogleDatastoreAdminV1IndexAncestorEnum::NONE),
+           "ALL_ANCESTORS" => Ok(GoogleDatastoreAdminV1IndexAncestorEnum::ALLANCESTORS),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a GoogleDatastoreAdminV1IndexAncestorEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region GoogleDatastoreAdminV1IndexStateEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// Output only. The state of the index.
+pub enum GoogleDatastoreAdminV1IndexStateEnum {
+    
+
+    /// The state is unspecified.
+    ///
+    /// "STATE_UNSPECIFIED"
+    #[serde(rename="STATE_UNSPECIFIED")]
+    STATEUNSPECIFIED,
+    
+
+    /// The index is being created, and cannot be used by queries. There is an active long-running operation for the index. The index is updated when writing an entity. Some index data may exist.
+    ///
+    /// "CREATING"
+    #[serde(rename="CREATING")]
+    CREATING,
+    
+
+    /// The index is ready to be used. The index is updated when writing an entity. The index is fully populated from all stored entities it applies to.
+    ///
+    /// "READY"
+    #[serde(rename="READY")]
+    READY,
+    
+
+    /// The index is being deleted, and cannot be used by queries. There is an active long-running operation for the index. The index is not updated when writing an entity. Some index data may exist.
+    ///
+    /// "DELETING"
+    #[serde(rename="DELETING")]
+    DELETING,
+    
+
+    /// The index was being created or deleted, but something went wrong. The index cannot by used by queries. There is no active long-running operation for the index, and the most recently finished long-running operation failed. The index is not updated when writing an entity. Some index data may exist.
+    ///
+    /// "ERROR"
+    #[serde(rename="ERROR")]
+    ERROR,
+}
+
+impl AsRef<str> for GoogleDatastoreAdminV1IndexStateEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            GoogleDatastoreAdminV1IndexStateEnum::STATEUNSPECIFIED => "STATE_UNSPECIFIED",
+            GoogleDatastoreAdminV1IndexStateEnum::CREATING => "CREATING",
+            GoogleDatastoreAdminV1IndexStateEnum::READY => "READY",
+            GoogleDatastoreAdminV1IndexStateEnum::DELETING => "DELETING",
+            GoogleDatastoreAdminV1IndexStateEnum::ERROR => "ERROR",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for GoogleDatastoreAdminV1IndexStateEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "STATE_UNSPECIFIED" => Ok(GoogleDatastoreAdminV1IndexStateEnum::STATEUNSPECIFIED),
+           "CREATING" => Ok(GoogleDatastoreAdminV1IndexStateEnum::CREATING),
+           "READY" => Ok(GoogleDatastoreAdminV1IndexStateEnum::READY),
+           "DELETING" => Ok(GoogleDatastoreAdminV1IndexStateEnum::DELETING),
+           "ERROR" => Ok(GoogleDatastoreAdminV1IndexStateEnum::ERROR),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a GoogleDatastoreAdminV1IndexStateEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region GoogleDatastoreAdminV1IndexedPropertyDirectionEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// Required. The indexed property's direction. Must not be DIRECTION_UNSPECIFIED.
+pub enum GoogleDatastoreAdminV1IndexedPropertyDirectionEnum {
+    
+
+    /// The direction is unspecified.
+    ///
+    /// "DIRECTION_UNSPECIFIED"
+    #[serde(rename="DIRECTION_UNSPECIFIED")]
+    DIRECTIONUNSPECIFIED,
+    
+
+    /// The property's values are indexed so as to support sequencing in ascending order and also query by <, >, <=, >=, and =.
+    ///
+    /// "ASCENDING"
+    #[serde(rename="ASCENDING")]
+    ASCENDING,
+    
+
+    /// The property's values are indexed so as to support sequencing in descending order and also query by <, >, <=, >=, and =.
+    ///
+    /// "DESCENDING"
+    #[serde(rename="DESCENDING")]
+    DESCENDING,
+}
+
+impl AsRef<str> for GoogleDatastoreAdminV1IndexedPropertyDirectionEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            GoogleDatastoreAdminV1IndexedPropertyDirectionEnum::DIRECTIONUNSPECIFIED => "DIRECTION_UNSPECIFIED",
+            GoogleDatastoreAdminV1IndexedPropertyDirectionEnum::ASCENDING => "ASCENDING",
+            GoogleDatastoreAdminV1IndexedPropertyDirectionEnum::DESCENDING => "DESCENDING",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for GoogleDatastoreAdminV1IndexedPropertyDirectionEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "DIRECTION_UNSPECIFIED" => Ok(GoogleDatastoreAdminV1IndexedPropertyDirectionEnum::DIRECTIONUNSPECIFIED),
+           "ASCENDING" => Ok(GoogleDatastoreAdminV1IndexedPropertyDirectionEnum::ASCENDING),
+           "DESCENDING" => Ok(GoogleDatastoreAdminV1IndexedPropertyDirectionEnum::DESCENDING),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a GoogleDatastoreAdminV1IndexedPropertyDirectionEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region PropertyFilterOpEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// The operator to filter by.
+pub enum PropertyFilterOpEnum {
+    
+
+    /// Unspecified. This value must not be used.
+    ///
+    /// "OPERATOR_UNSPECIFIED"
+    #[serde(rename="OPERATOR_UNSPECIFIED")]
+    OPERATORUNSPECIFIED,
+    
+
+    /// The given `property` is less than the given `value`. Requires: * That `property` comes first in `order_by`.
+    ///
+    /// "LESS_THAN"
+    #[serde(rename="LESS_THAN")]
+    LESSTHAN,
+    
+
+    /// The given `property` is less than or equal to the given `value`. Requires: * That `property` comes first in `order_by`.
+    ///
+    /// "LESS_THAN_OR_EQUAL"
+    #[serde(rename="LESS_THAN_OR_EQUAL")]
+    LESSTHANOREQUAL,
+    
+
+    /// The given `property` is greater than the given `value`. Requires: * That `property` comes first in `order_by`.
+    ///
+    /// "GREATER_THAN"
+    #[serde(rename="GREATER_THAN")]
+    GREATERTHAN,
+    
+
+    /// The given `property` is greater than or equal to the given `value`. Requires: * That `property` comes first in `order_by`.
+    ///
+    /// "GREATER_THAN_OR_EQUAL"
+    #[serde(rename="GREATER_THAN_OR_EQUAL")]
+    GREATERTHANOREQUAL,
+    
+
+    /// The given `property` is equal to the given `value`.
+    ///
+    /// "EQUAL"
+    #[serde(rename="EQUAL")]
+    EQUAL,
+    
+
+    /// The given `property` is equal to at least one value in the given array. Requires: * That `value` is a non-empty `ArrayValue`, subject to disjunction limits. * No `NOT_IN` is in the same query.
+    ///
+    /// "IN"
+    #[serde(rename="IN")]
+    IN,
+    
+
+    /// The given `property` is not equal to the given `value`. Requires: * No other `NOT_EQUAL` or `NOT_IN` is in the same query. * That `property` comes first in the `order_by`.
+    ///
+    /// "NOT_EQUAL"
+    #[serde(rename="NOT_EQUAL")]
+    NOTEQUAL,
+    
+
+    /// Limit the result set to the given entity and its descendants. Requires: * That `value` is an entity key. * All evaluated disjunctions must have the same `HAS_ANCESTOR` filter.
+    ///
+    /// "HAS_ANCESTOR"
+    #[serde(rename="HAS_ANCESTOR")]
+    HASANCESTOR,
+    
+
+    /// The value of the `property` is not in the given array. Requires: * That `value` is a non-empty `ArrayValue` with at most 10 values. * No other `OR`, `IN`, `NOT_IN`, `NOT_EQUAL` is in the same query. * That `field` comes first in the `order_by`.
+    ///
+    /// "NOT_IN"
+    #[serde(rename="NOT_IN")]
+    NOTIN,
+}
+
+impl AsRef<str> for PropertyFilterOpEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            PropertyFilterOpEnum::OPERATORUNSPECIFIED => "OPERATOR_UNSPECIFIED",
+            PropertyFilterOpEnum::LESSTHAN => "LESS_THAN",
+            PropertyFilterOpEnum::LESSTHANOREQUAL => "LESS_THAN_OR_EQUAL",
+            PropertyFilterOpEnum::GREATERTHAN => "GREATER_THAN",
+            PropertyFilterOpEnum::GREATERTHANOREQUAL => "GREATER_THAN_OR_EQUAL",
+            PropertyFilterOpEnum::EQUAL => "EQUAL",
+            PropertyFilterOpEnum::IN => "IN",
+            PropertyFilterOpEnum::NOTEQUAL => "NOT_EQUAL",
+            PropertyFilterOpEnum::HASANCESTOR => "HAS_ANCESTOR",
+            PropertyFilterOpEnum::NOTIN => "NOT_IN",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for PropertyFilterOpEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "OPERATOR_UNSPECIFIED" => Ok(PropertyFilterOpEnum::OPERATORUNSPECIFIED),
+           "LESS_THAN" => Ok(PropertyFilterOpEnum::LESSTHAN),
+           "LESS_THAN_OR_EQUAL" => Ok(PropertyFilterOpEnum::LESSTHANOREQUAL),
+           "GREATER_THAN" => Ok(PropertyFilterOpEnum::GREATERTHAN),
+           "GREATER_THAN_OR_EQUAL" => Ok(PropertyFilterOpEnum::GREATERTHANOREQUAL),
+           "EQUAL" => Ok(PropertyFilterOpEnum::EQUAL),
+           "IN" => Ok(PropertyFilterOpEnum::IN),
+           "NOT_EQUAL" => Ok(PropertyFilterOpEnum::NOTEQUAL),
+           "HAS_ANCESTOR" => Ok(PropertyFilterOpEnum::HASANCESTOR),
+           "NOT_IN" => Ok(PropertyFilterOpEnum::NOTIN),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a PropertyFilterOpEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region PropertyOrderDirectionEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// The direction to order by. Defaults to `ASCENDING`.
+pub enum PropertyOrderDirectionEnum {
+    
+
+    /// Unspecified. This value must not be used.
+    ///
+    /// "DIRECTION_UNSPECIFIED"
+    #[serde(rename="DIRECTION_UNSPECIFIED")]
+    DIRECTIONUNSPECIFIED,
+    
+
+    /// Ascending.
+    ///
+    /// "ASCENDING"
+    #[serde(rename="ASCENDING")]
+    ASCENDING,
+    
+
+    /// Descending.
+    ///
+    /// "DESCENDING"
+    #[serde(rename="DESCENDING")]
+    DESCENDING,
+}
+
+impl AsRef<str> for PropertyOrderDirectionEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            PropertyOrderDirectionEnum::DIRECTIONUNSPECIFIED => "DIRECTION_UNSPECIFIED",
+            PropertyOrderDirectionEnum::ASCENDING => "ASCENDING",
+            PropertyOrderDirectionEnum::DESCENDING => "DESCENDING",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for PropertyOrderDirectionEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "DIRECTION_UNSPECIFIED" => Ok(PropertyOrderDirectionEnum::DIRECTIONUNSPECIFIED),
+           "ASCENDING" => Ok(PropertyOrderDirectionEnum::ASCENDING),
+           "DESCENDING" => Ok(PropertyOrderDirectionEnum::DESCENDING),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a PropertyOrderDirectionEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region QueryResultBatchEntityResultTypeEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// The result type for every entity in `entity_results`.
+pub enum QueryResultBatchEntityResultTypeEnum {
+    
+
+    /// Unspecified. This value is never used.
+    ///
+    /// "RESULT_TYPE_UNSPECIFIED"
+    #[serde(rename="RESULT_TYPE_UNSPECIFIED")]
+    RESULTTYPEUNSPECIFIED,
+    
+
+    /// The key and properties.
+    ///
+    /// "FULL"
+    #[serde(rename="FULL")]
+    FULL,
+    
+
+    /// A projected subset of properties. The entity may have no key.
+    ///
+    /// "PROJECTION"
+    #[serde(rename="PROJECTION")]
+    PROJECTION,
+    
+
+    /// Only the key.
+    ///
+    /// "KEY_ONLY"
+    #[serde(rename="KEY_ONLY")]
+    KEYONLY,
+}
+
+impl AsRef<str> for QueryResultBatchEntityResultTypeEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            QueryResultBatchEntityResultTypeEnum::RESULTTYPEUNSPECIFIED => "RESULT_TYPE_UNSPECIFIED",
+            QueryResultBatchEntityResultTypeEnum::FULL => "FULL",
+            QueryResultBatchEntityResultTypeEnum::PROJECTION => "PROJECTION",
+            QueryResultBatchEntityResultTypeEnum::KEYONLY => "KEY_ONLY",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for QueryResultBatchEntityResultTypeEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "RESULT_TYPE_UNSPECIFIED" => Ok(QueryResultBatchEntityResultTypeEnum::RESULTTYPEUNSPECIFIED),
+           "FULL" => Ok(QueryResultBatchEntityResultTypeEnum::FULL),
+           "PROJECTION" => Ok(QueryResultBatchEntityResultTypeEnum::PROJECTION),
+           "KEY_ONLY" => Ok(QueryResultBatchEntityResultTypeEnum::KEYONLY),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a QueryResultBatchEntityResultTypeEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region QueryResultBatchMoreResultsEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// The state of the query after the current batch.
+pub enum QueryResultBatchMoreResultsEnum {
+    
+
+    /// Unspecified. This value is never used.
+    ///
+    /// "MORE_RESULTS_TYPE_UNSPECIFIED"
+    #[serde(rename="MORE_RESULTS_TYPE_UNSPECIFIED")]
+    MORERESULTSTYPEUNSPECIFIED,
+    
+
+    /// There may be additional batches to fetch from this query.
+    ///
+    /// "NOT_FINISHED"
+    #[serde(rename="NOT_FINISHED")]
+    NOTFINISHED,
+    
+
+    /// The query is finished, but there may be more results after the limit.
+    ///
+    /// "MORE_RESULTS_AFTER_LIMIT"
+    #[serde(rename="MORE_RESULTS_AFTER_LIMIT")]
+    MORERESULTSAFTERLIMIT,
+    
+
+    /// The query is finished, but there may be more results after the end cursor.
+    ///
+    /// "MORE_RESULTS_AFTER_CURSOR"
+    #[serde(rename="MORE_RESULTS_AFTER_CURSOR")]
+    MORERESULTSAFTERCURSOR,
+    
+
+    /// The query is finished, and there are no more results.
+    ///
+    /// "NO_MORE_RESULTS"
+    #[serde(rename="NO_MORE_RESULTS")]
+    NOMORERESULTS,
+}
+
+impl AsRef<str> for QueryResultBatchMoreResultsEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            QueryResultBatchMoreResultsEnum::MORERESULTSTYPEUNSPECIFIED => "MORE_RESULTS_TYPE_UNSPECIFIED",
+            QueryResultBatchMoreResultsEnum::NOTFINISHED => "NOT_FINISHED",
+            QueryResultBatchMoreResultsEnum::MORERESULTSAFTERLIMIT => "MORE_RESULTS_AFTER_LIMIT",
+            QueryResultBatchMoreResultsEnum::MORERESULTSAFTERCURSOR => "MORE_RESULTS_AFTER_CURSOR",
+            QueryResultBatchMoreResultsEnum::NOMORERESULTS => "NO_MORE_RESULTS",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for QueryResultBatchMoreResultsEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "MORE_RESULTS_TYPE_UNSPECIFIED" => Ok(QueryResultBatchMoreResultsEnum::MORERESULTSTYPEUNSPECIFIED),
+           "NOT_FINISHED" => Ok(QueryResultBatchMoreResultsEnum::NOTFINISHED),
+           "MORE_RESULTS_AFTER_LIMIT" => Ok(QueryResultBatchMoreResultsEnum::MORERESULTSAFTERLIMIT),
+           "MORE_RESULTS_AFTER_CURSOR" => Ok(QueryResultBatchMoreResultsEnum::MORERESULTSAFTERCURSOR),
+           "NO_MORE_RESULTS" => Ok(QueryResultBatchMoreResultsEnum::NOMORERESULTS),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a QueryResultBatchMoreResultsEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region ReadOptionReadConsistencyEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// The non-transactional read consistency to use.
+pub enum ReadOptionReadConsistencyEnum {
+    
+
+    /// Unspecified. This value must not be used.
+    ///
+    /// "READ_CONSISTENCY_UNSPECIFIED"
+    #[serde(rename="READ_CONSISTENCY_UNSPECIFIED")]
+    READCONSISTENCYUNSPECIFIED,
+    
+
+    /// Strong consistency.
+    ///
+    /// "STRONG"
+    #[serde(rename="STRONG")]
+    STRONG,
+    
+
+    /// Eventual consistency.
+    ///
+    /// "EVENTUAL"
+    #[serde(rename="EVENTUAL")]
+    EVENTUAL,
+}
+
+impl AsRef<str> for ReadOptionReadConsistencyEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            ReadOptionReadConsistencyEnum::READCONSISTENCYUNSPECIFIED => "READ_CONSISTENCY_UNSPECIFIED",
+            ReadOptionReadConsistencyEnum::STRONG => "STRONG",
+            ReadOptionReadConsistencyEnum::EVENTUAL => "EVENTUAL",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for ReadOptionReadConsistencyEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "READ_CONSISTENCY_UNSPECIFIED" => Ok(ReadOptionReadConsistencyEnum::READCONSISTENCYUNSPECIFIED),
+           "STRONG" => Ok(ReadOptionReadConsistencyEnum::STRONG),
+           "EVENTUAL" => Ok(ReadOptionReadConsistencyEnum::EVENTUAL),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a ReadOptionReadConsistencyEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region ValueNullValueEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// A null value.
+pub enum ValueNullValueEnum {
+    
+
+    /// Null value.
+    ///
+    /// "NULL_VALUE"
+    #[serde(rename="NULL_VALUE")]
+    NULLVALUE,
+}
+
+impl AsRef<str> for ValueNullValueEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            ValueNullValueEnum::NULLVALUE => "NULL_VALUE",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for ValueNullValueEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "NULL_VALUE" => Ok(ValueNullValueEnum::NULLVALUE),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a ValueNullValueEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+

gen/datastore1/src/api/hub.rs

@@ -0,0 +1,113 @@
+use super::*;
+
+/// Central instance to access all Datastore related resource activities
+///
+/// # Examples
+///
+/// Instantiate a new hub
+///
+/// ```test_harness,no_run
+/// extern crate hyper;
+/// extern crate hyper_rustls;
+/// extern crate google_datastore1 as datastore1;
+/// use datastore1::api::GoogleDatastoreAdminV1Index;
+/// use datastore1::{Result, Error};
+/// use datastore1::api::enums::*;
+/// # async fn dox() {
+/// use std::default::Default;
+/// use datastore1::{Datastore, 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 = Datastore::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().unwrap().https_or_http().enable_http1().build()), auth);
+/// // As the method needs a request, you would usually fill it with the desired information
+/// // into the respective structure. Some of the parts shown here might not be applicable !
+/// // Values shown here are possibly random and not representative !
+/// let mut req = GoogleDatastoreAdminV1Index::default();
+/// 
+/// // 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.projects().indexes_create(req, "projectId")
+///              .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 Datastore<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 Datastore<S> {}
+
+impl<'a, S> Datastore<S> {
+
+    pub fn new<A: 'static + client::GetToken>(client: hyper::Client<S, hyper::body::Body>, auth: A) -> Datastore<S> {
+        Datastore {
+            client,
+            auth: Box::new(auth),
+            _user_agent: "google-api-rust-client/5.0.5".to_string(),
+            _base_url: "https://datastore.googleapis.com/".to_string(),
+            _root_url: "https://datastore.googleapis.com/".to_string(),
+        }
+    }
+
+    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://datastore.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://datastore.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)
+    }
+}

gen/datastore1/src/api/method_builders.rs

@@ -0,0 +1,380 @@
+use super::*;
+/// A builder providing access to all methods supported on *project* resources.
+/// It is not used directly, but through the [`Datastore`] hub.
+///
+/// # Example
+///
+/// Instantiate a resource builder
+///
+/// ```test_harness,no_run
+/// extern crate hyper;
+/// extern crate hyper_rustls;
+/// extern crate google_datastore1 as datastore1;
+/// 
+/// # async fn dox() {
+/// use std::default::Default;
+/// use datastore1::{Datastore, oauth2, hyper, hyper_rustls, chrono, FieldMask};
+/// 
+/// let secret: oauth2::ApplicationSecret = Default::default();
+/// let auth = oauth2::InstalledFlowAuthenticator::builder(
+///         secret,
+///         oauth2::InstalledFlowReturnMethod::HTTPRedirect,
+///     ).build().await.unwrap();
+/// let mut hub = Datastore::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().unwrap().https_or_http().enable_http1().build()), auth);
+/// // Usually you wouldn't bind this to a variable, but keep calling *CallBuilders*
+/// // like `allocate_ids(...)`, `begin_transaction(...)`, `commit(...)`, `export(...)`, `import(...)`, `indexes_create(...)`, `indexes_delete(...)`, `indexes_get(...)`, `indexes_list(...)`, `lookup(...)`, `operations_cancel(...)`, `operations_delete(...)`, `operations_get(...)`, `operations_list(...)`, `reserve_ids(...)`, `rollback(...)`, `run_aggregation_query(...)` and `run_query(...)`
+/// // to build up your call.
+/// let rb = hub.projects();
+/// # }
+/// ```
+pub struct ProjectMethods<'a, S>
+    where S: 'a {
+
+   pub(super) hub: &'a Datastore<S>,
+}
+
+impl<'a, S> client::MethodsBuilder for ProjectMethods<'a, S> {}
+
+impl<'a, S> ProjectMethods<'a, S> {
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Creates the specified index. A newly created index's initial state is `CREATING`. On completion of the returned google.longrunning.Operation, the state will be `READY`. If the index already exists, the call will return an `ALREADY_EXISTS` status. During index creation, the process could result in an error, in which case the index will move to the `ERROR` state. The process can be recovered by fixing the data that caused the error, removing the index with delete, then re-creating the index with create. Indexes with a single property cannot be created.
+    /// 
+    /// # Arguments
+    ///
+    /// * `request` - No description provided.
+    /// * `projectId` - Project ID against which to make the request.
+    pub fn indexes_create(&self, request: GoogleDatastoreAdminV1Index, project_id: &str) -> ProjectIndexCreateCall<'a, S> {
+        ProjectIndexCreateCall {
+            hub: self.hub,
+            _request: request,
+            _project_id: project_id.to_string(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Deletes an existing index. An index can only be deleted if it is in a `READY` or `ERROR` state. On successful execution of the request, the index will be in a `DELETING` state. And on completion of the returned google.longrunning.Operation, the index will be removed. During index deletion, the process could result in an error, in which case the index will move to the `ERROR` state. The process can be recovered by fixing the data that caused the error, followed by calling delete again.
+    /// 
+    /// # Arguments
+    ///
+    /// * `projectId` - Project ID against which to make the request.
+    /// * `indexId` - The resource ID of the index to delete.
+    pub fn indexes_delete(&self, project_id: &str, index_id: &str) -> ProjectIndexDeleteCall<'a, S> {
+        ProjectIndexDeleteCall {
+            hub: self.hub,
+            _project_id: project_id.to_string(),
+            _index_id: index_id.to_string(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Gets an index.
+    /// 
+    /// # Arguments
+    ///
+    /// * `projectId` - Project ID against which to make the request.
+    /// * `indexId` - The resource ID of the index to get.
+    pub fn indexes_get(&self, project_id: &str, index_id: &str) -> ProjectIndexGetCall<'a, S> {
+        ProjectIndexGetCall {
+            hub: self.hub,
+            _project_id: project_id.to_string(),
+            _index_id: index_id.to_string(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Lists the indexes that match the specified filters. Datastore uses an eventually consistent query to fetch the list of indexes and may occasionally return stale results.
+    /// 
+    /// # Arguments
+    ///
+    /// * `projectId` - Project ID against which to make the request.
+    pub fn indexes_list(&self, project_id: &str) -> ProjectIndexListCall<'a, S> {
+        ProjectIndexListCall {
+            hub: self.hub,
+            _project_id: project_id.to_string(),
+            _page_token: Default::default(),
+            _page_size: Default::default(),
+            _filter: Default::default(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.
+    /// 
+    /// # Arguments
+    ///
+    /// * `name` - The name of the operation resource to be cancelled.
+    pub fn operations_cancel(&self, name: &str) -> ProjectOperationCancelCall<'a, S> {
+        ProjectOperationCancelCall {
+            hub: self.hub,
+            _name: name.to_string(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.
+    /// 
+    /// # Arguments
+    ///
+    /// * `name` - The name of the operation resource to be deleted.
+    pub fn operations_delete(&self, name: &str) -> ProjectOperationDeleteCall<'a, S> {
+        ProjectOperationDeleteCall {
+            hub: self.hub,
+            _name: name.to_string(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.
+    /// 
+    /// # Arguments
+    ///
+    /// * `name` - The name of the operation resource.
+    pub fn operations_get(&self, name: &str) -> ProjectOperationGetCall<'a, S> {
+        ProjectOperationGetCall {
+            hub: self.hub,
+            _name: name.to_string(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns `UNIMPLEMENTED`.
+    /// 
+    /// # Arguments
+    ///
+    /// * `name` - The name of the operation's parent resource.
+    pub fn operations_list(&self, name: &str) -> ProjectOperationListCall<'a, S> {
+        ProjectOperationListCall {
+            hub: self.hub,
+            _name: name.to_string(),
+            _page_token: Default::default(),
+            _page_size: Default::default(),
+            _filter: Default::default(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Allocates IDs for the given keys, which is useful for referencing an entity before it is inserted.
+    /// 
+    /// # Arguments
+    ///
+    /// * `request` - No description provided.
+    /// * `projectId` - Required. The ID of the project against which to make the request.
+    pub fn allocate_ids(&self, request: AllocateIdsRequest, project_id: &str) -> ProjectAllocateIdCall<'a, S> {
+        ProjectAllocateIdCall {
+            hub: self.hub,
+            _request: request,
+            _project_id: project_id.to_string(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Begins a new transaction.
+    /// 
+    /// # Arguments
+    ///
+    /// * `request` - No description provided.
+    /// * `projectId` - Required. The ID of the project against which to make the request.
+    pub fn begin_transaction(&self, request: BeginTransactionRequest, project_id: &str) -> ProjectBeginTransactionCall<'a, S> {
+        ProjectBeginTransactionCall {
+            hub: self.hub,
+            _request: request,
+            _project_id: project_id.to_string(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Commits a transaction, optionally creating, deleting or modifying some entities.
+    /// 
+    /// # Arguments
+    ///
+    /// * `request` - No description provided.
+    /// * `projectId` - Required. The ID of the project against which to make the request.
+    pub fn commit(&self, request: CommitRequest, project_id: &str) -> ProjectCommitCall<'a, S> {
+        ProjectCommitCall {
+            hub: self.hub,
+            _request: request,
+            _project_id: project_id.to_string(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Exports a copy of all or a subset of entities from Google Cloud Datastore to another storage system, such as Google Cloud Storage. Recent updates to entities may not be reflected in the export. The export occurs in the background and its progress can be monitored and managed via the Operation resource that is created. The output of an export may only be used once the associated operation is done. If an export operation is cancelled before completion it may leave partial data behind in Google Cloud Storage.
+    /// 
+    /// # Arguments
+    ///
+    /// * `request` - No description provided.
+    /// * `projectId` - Required. Project ID against which to make the request.
+    pub fn export(&self, request: GoogleDatastoreAdminV1ExportEntitiesRequest, project_id: &str) -> ProjectExportCall<'a, S> {
+        ProjectExportCall {
+            hub: self.hub,
+            _request: request,
+            _project_id: project_id.to_string(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Imports entities into Google Cloud Datastore. Existing entities with the same key are overwritten. The import occurs in the background and its progress can be monitored and managed via the Operation resource that is created. If an ImportEntities operation is cancelled, it is possible that a subset of the data has already been imported to Cloud Datastore.
+    /// 
+    /// # Arguments
+    ///
+    /// * `request` - No description provided.
+    /// * `projectId` - Required. Project ID against which to make the request.
+    pub fn import(&self, request: GoogleDatastoreAdminV1ImportEntitiesRequest, project_id: &str) -> ProjectImportCall<'a, S> {
+        ProjectImportCall {
+            hub: self.hub,
+            _request: request,
+            _project_id: project_id.to_string(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Looks up entities by key.
+    /// 
+    /// # Arguments
+    ///
+    /// * `request` - No description provided.
+    /// * `projectId` - Required. The ID of the project against which to make the request.
+    pub fn lookup(&self, request: LookupRequest, project_id: &str) -> ProjectLookupCall<'a, S> {
+        ProjectLookupCall {
+            hub: self.hub,
+            _request: request,
+            _project_id: project_id.to_string(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Prevents the supplied keys' IDs from being auto-allocated by Cloud Datastore.
+    /// 
+    /// # Arguments
+    ///
+    /// * `request` - No description provided.
+    /// * `projectId` - Required. The ID of the project against which to make the request.
+    pub fn reserve_ids(&self, request: ReserveIdsRequest, project_id: &str) -> ProjectReserveIdCall<'a, S> {
+        ProjectReserveIdCall {
+            hub: self.hub,
+            _request: request,
+            _project_id: project_id.to_string(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Rolls back a transaction.
+    /// 
+    /// # Arguments
+    ///
+    /// * `request` - No description provided.
+    /// * `projectId` - Required. The ID of the project against which to make the request.
+    pub fn rollback(&self, request: RollbackRequest, project_id: &str) -> ProjectRollbackCall<'a, S> {
+        ProjectRollbackCall {
+            hub: self.hub,
+            _request: request,
+            _project_id: project_id.to_string(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Runs an aggregation query.
+    /// 
+    /// # Arguments
+    ///
+    /// * `request` - No description provided.
+    /// * `projectId` - Required. The ID of the project against which to make the request.
+    pub fn run_aggregation_query(&self, request: RunAggregationQueryRequest, project_id: &str) -> ProjectRunAggregationQueryCall<'a, S> {
+        ProjectRunAggregationQueryCall {
+            hub: self.hub,
+            _request: request,
+            _project_id: project_id.to_string(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Queries for entities.
+    /// 
+    /// # Arguments
+    ///
+    /// * `request` - No description provided.
+    /// * `projectId` - Required. The ID of the project against which to make the request.
+    pub fn run_query(&self, request: RunQueryRequest, project_id: &str) -> ProjectRunQueryCall<'a, S> {
+        ProjectRunQueryCall {
+            hub: self.hub,
+            _request: request,
+            _project_id: project_id.to_string(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+}
+
+
+

gen/datastore1/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::*;

gen/datastore1/src/api/utilities.rs

@@ -0,0 +1,28 @@
+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 {
+    /// See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account.
+    CloudPlatform,
+
+    /// View and manage your Google Cloud Datastore data
+    Full,
+}
+
+impl AsRef<str> for Scope {
+    fn as_ref(&self) -> &str {
+        match *self {
+            Scope::CloudPlatform => "https://www.googleapis.com/auth/cloud-platform",
+            Scope::Full => "https://www.googleapis.com/auth/datastore",
+        }
+    }
+}
+
+impl Default for Scope {
+    fn default() -> Scope {
+        Scope::Full
+    }
+}
+

gen/datastore1/src/lib.rs

@@ -2,14 +2,14 @@
 // This file was generated automatically from 'src/generator/templates/api/lib.rs.mako'
 // DO NOT EDIT !
 
-//! This documentation was generated from *datastore* crate version *5.0.4+20240226*, where *20240226* is the exact revision of the *datastore:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v5.0.4*.
+//! This documentation was generated from *datastore* crate version *5.0.5+20240324*, where *20240324* is the exact revision of the *datastore:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v5.0.5*.
 //! 
 //! Everything else about the *datastore* *v1* API can be found at the
 //! [official documentation site](https://cloud.google.com/datastore/).
 //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/datastore1).
 //! # Features
 //! 
-//! Handle the following *Resources* with ease from the central [hub](Datastore) ... 
+//! Handle the following *Resources* with ease from the central [hub](Datastore) ...
 //! 
 //! * projects
 //!  * [*allocate ids*](api::ProjectAllocateIdCall), [*begin transaction*](api::ProjectBeginTransactionCall), [*commit*](api::ProjectCommitCall), [*export*](api::ProjectExportCall), [*import*](api::ProjectImportCall), [*indexes create*](api::ProjectIndexCreateCall), [*indexes delete*](api::ProjectIndexDeleteCall), [*indexes get*](api::ProjectIndexGetCall), [*indexes list*](api::ProjectIndexListCall), [*lookup*](api::ProjectLookupCall), [*operations cancel*](api::ProjectOperationCancelCall), [*operations delete*](api::ProjectOperationDeleteCall), [*operations get*](api::ProjectOperationGetCall), [*operations list*](api::ProjectOperationListCall), [*reserve ids*](api::ProjectReserveIdCall), [*rollback*](api::ProjectRollbackCall), [*run aggregation query*](api::ProjectRunAggregationQueryCall) and [*run query*](api::ProjectRunQueryCall)
@@ -54,8 +54,8 @@
 //! let r = hub.projects().import(...).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.
 //! 
@@ -80,23 +80,24 @@
 //! extern crate google_datastore1 as datastore1;
 //! use datastore1::api::GoogleDatastoreAdminV1Index;
 //! use datastore1::{Result, Error};
+//! use datastore1::api::enums::*;
 //! # async fn dox() {
 //! use std::default::Default;
 //! use datastore1::{Datastore, 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 = Datastore::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().build()), auth);
+//! let mut hub = Datastore::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().unwrap().https_or_http().enable_http1().build()), auth);
 //! // As the method needs a request, you would usually fill it with the desired information
 //! // into the respective structure. Some of the parts shown here might not be applicable !
 //! // Values shown here are possibly random and not representative !
@@ -130,10 +131,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
@@ -143,25 +144,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