OMGeeky/google-apis-rs
1
0
Fork 0
mirror of https://github.com/OMGeeky/google-apis-rs.git synced 2026-02-23 15:49:49 +01:00
Code Issues Packages Projects Releases Wiki Activity

remove generated libs

Browse Source
This commit is contained in:
OMGeeky
2024-05-12 22:15:06 +02:00
parent 85133fa452 55222f3d00
commit 988ebe882e
4862 changed files with 0 additions and 6416267 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15051
gen/managedidentities1/src/api/call_builders.rs
View File

File diff suppressed because it is too large Load Diff

113
gen/managedidentities1/src/api/hub.rs
View File

@@ -1,113 +0,0 @@
use super::*;
/// Central instance to access all ManagedServiceForMicrosoftActiveDirectoryConsumerAPI related resource activities
///
/// # Examples
///
/// Instantiate a new hub
///
/// ```test_harness,no_run
/// extern crate hyper;
/// extern crate hyper_rustls;
/// extern crate google_managedidentities1 as managedidentities1;
/// use managedidentities1::api::Backup;
/// use managedidentities1::{Result, Error};
/// # async fn dox() {
/// use std::default::Default;
/// use managedidentities1::{ManagedServiceForMicrosoftActiveDirectoryConsumerAPI, 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 = ManagedServiceForMicrosoftActiveDirectoryConsumerAPI::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().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 = Backup::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().locations_global_domains_backups_create(req, "parent")
/// .backup_id("At")
/// .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 ManagedServiceForMicrosoftActiveDirectoryConsumerAPI<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 ManagedServiceForMicrosoftActiveDirectoryConsumerAPI<S> {}
impl<'a, S> ManagedServiceForMicrosoftActiveDirectoryConsumerAPI<S> {
pub fn new<A: 'static + client::GetToken>(client: hyper::Client<S, hyper::body::Body>, auth: A) -> ManagedServiceForMicrosoftActiveDirectoryConsumerAPI<S> {
ManagedServiceForMicrosoftActiveDirectoryConsumerAPI {
client,
auth: Box::new(auth),
_user_agent: "google-api-rust-client/5.0.3".to_string(),
_base_url: "https://managedidentities.googleapis.com/".to_string(),
_root_url: "https://managedidentities.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.3`.
///
/// 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://managedidentities.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://managedidentities.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)
}
}

813
gen/managedidentities1/src/api/method_builders.rs
View File

@@ -1,813 +0,0 @@
use super::*;
/// A builder providing access to all methods supported on *project* resources.
/// It is not used directly, but through the [`ManagedServiceForMicrosoftActiveDirectoryConsumerAPI`] hub.
///
/// # Example
///
/// Instantiate a resource builder
///
/// ```test_harness,no_run
/// extern crate hyper;
/// extern crate hyper_rustls;
/// extern crate google_managedidentities1 as managedidentities1;
///
/// # async fn dox() {
/// use std::default::Default;
/// use managedidentities1::{ManagedServiceForMicrosoftActiveDirectoryConsumerAPI, 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 = ManagedServiceForMicrosoftActiveDirectoryConsumerAPI::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().build()), auth);
/// // Usually you wouldn't bind this to a variable, but keep calling *CallBuilders*
/// // like `locations_get(...)`, `locations_global_domains_attach_trust(...)`, `locations_global_domains_backups_create(...)`, `locations_global_domains_backups_delete(...)`, `locations_global_domains_backups_get(...)`, `locations_global_domains_backups_get_iam_policy(...)`, `locations_global_domains_backups_list(...)`, `locations_global_domains_backups_patch(...)`, `locations_global_domains_backups_set_iam_policy(...)`, `locations_global_domains_backups_test_iam_permissions(...)`, `locations_global_domains_create(...)`, `locations_global_domains_delete(...)`, `locations_global_domains_detach_trust(...)`, `locations_global_domains_extend_schema(...)`, `locations_global_domains_get(...)`, `locations_global_domains_get_iam_policy(...)`, `locations_global_domains_get_ldapssettings(...)`, `locations_global_domains_list(...)`, `locations_global_domains_patch(...)`, `locations_global_domains_reconfigure_trust(...)`, `locations_global_domains_reset_admin_password(...)`, `locations_global_domains_restore(...)`, `locations_global_domains_set_iam_policy(...)`, `locations_global_domains_sql_integrations_get(...)`, `locations_global_domains_sql_integrations_list(...)`, `locations_global_domains_test_iam_permissions(...)`, `locations_global_domains_update_ldapssettings(...)`, `locations_global_domains_validate_trust(...)`, `locations_global_operations_cancel(...)`, `locations_global_operations_delete(...)`, `locations_global_operations_get(...)`, `locations_global_operations_list(...)`, `locations_global_peerings_create(...)`, `locations_global_peerings_delete(...)`, `locations_global_peerings_get(...)`, `locations_global_peerings_get_iam_policy(...)`, `locations_global_peerings_list(...)`, `locations_global_peerings_patch(...)`, `locations_global_peerings_set_iam_policy(...)`, `locations_global_peerings_test_iam_permissions(...)` and `locations_list(...)`
/// // to build up your call.
/// let rb = hub.projects();
/// # }
/// ```
pub struct ProjectMethods<'a, S>
where S: 'a {
pub(super) hub: &'a ManagedServiceForMicrosoftActiveDirectoryConsumerAPI<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 a Backup for a domain.
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `parent` - Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`
pub fn locations_global_domains_backups_create(&self, request: Backup, parent: &str) -> ProjectLocationGlobalDomainBackupCreateCall<'a, S> {
ProjectLocationGlobalDomainBackupCreateCall {
hub: self.hub,
_request: request,
_parent: parent.to_string(),
_backup_id: Default::default(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Deletes identified Backup.
///
/// # Arguments
///
/// * `name` - Required. The backup resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}/backups/{backup_id}`
pub fn locations_global_domains_backups_delete(&self, name: &str) -> ProjectLocationGlobalDomainBackupDeleteCall<'a, S> {
ProjectLocationGlobalDomainBackupDeleteCall {
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 details of a single Backup.
///
/// # Arguments
///
/// * `name` - Required. The backup resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}/backups/{backup_id}`
pub fn locations_global_domains_backups_get(&self, name: &str) -> ProjectLocationGlobalDomainBackupGetCall<'a, S> {
ProjectLocationGlobalDomainBackupGetCall {
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 access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.
///
/// # Arguments
///
/// * `resource` - REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
pub fn locations_global_domains_backups_get_iam_policy(&self, resource: &str) -> ProjectLocationGlobalDomainBackupGetIamPolicyCall<'a, S> {
ProjectLocationGlobalDomainBackupGetIamPolicyCall {
hub: self.hub,
_resource: resource.to_string(),
_options_requested_policy_version: Default::default(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Lists Backup in a given project.
///
/// # Arguments
///
/// * `parent` - Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`
pub fn locations_global_domains_backups_list(&self, parent: &str) -> ProjectLocationGlobalDomainBackupListCall<'a, S> {
ProjectLocationGlobalDomainBackupListCall {
hub: self.hub,
_parent: parent.to_string(),
_page_token: Default::default(),
_page_size: Default::default(),
_order_by: 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:
///
/// Updates the labels for specified Backup.
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `name` - Output only. The unique name of the Backup in the form of `projects/{project_id}/locations/global/domains/{domain_name}/backups/{name}`
pub fn locations_global_domains_backups_patch(&self, request: Backup, name: &str) -> ProjectLocationGlobalDomainBackupPatchCall<'a, S> {
ProjectLocationGlobalDomainBackupPatchCall {
hub: self.hub,
_request: request,
_name: name.to_string(),
_update_mask: Default::default(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `resource` - REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
pub fn locations_global_domains_backups_set_iam_policy(&self, request: SetIamPolicyRequest, resource: &str) -> ProjectLocationGlobalDomainBackupSetIamPolicyCall<'a, S> {
ProjectLocationGlobalDomainBackupSetIamPolicyCall {
hub: self.hub,
_request: request,
_resource: resource.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may "fail open" without warning.
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `resource` - REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
pub fn locations_global_domains_backups_test_iam_permissions(&self, request: TestIamPermissionsRequest, resource: &str) -> ProjectLocationGlobalDomainBackupTestIamPermissionCall<'a, S> {
ProjectLocationGlobalDomainBackupTestIamPermissionCall {
hub: self.hub,
_request: request,
_resource: resource.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Gets details of a single sqlIntegration.
///
/// # Arguments
///
/// * `name` - Required. SQLIntegration resource name using the form: `projects/{project_id}/locations/global/domains/{domain}/sqlIntegrations/{name}`
pub fn locations_global_domains_sql_integrations_get(&self, name: &str) -> ProjectLocationGlobalDomainSqlIntegrationGetCall<'a, S> {
ProjectLocationGlobalDomainSqlIntegrationGetCall {
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 SqlIntegrations in a given domain.
///
/// # Arguments
///
/// * `parent` - Required. The resource name of the SqlIntegrations using the form: `projects/{project_id}/locations/global/domains/*`
pub fn locations_global_domains_sql_integrations_list(&self, parent: &str) -> ProjectLocationGlobalDomainSqlIntegrationListCall<'a, S> {
ProjectLocationGlobalDomainSqlIntegrationListCall {
hub: self.hub,
_parent: parent.to_string(),
_page_token: Default::default(),
_page_size: Default::default(),
_order_by: 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:
///
/// Adds an AD trust to a domain.
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `name` - Required. The resource domain name, project name and location using the form: `projects/{project_id}/locations/global/domains/{domain_name}`
pub fn locations_global_domains_attach_trust(&self, request: AttachTrustRequest, name: &str) -> ProjectLocationGlobalDomainAttachTrustCall<'a, S> {
ProjectLocationGlobalDomainAttachTrustCall {
hub: self.hub,
_request: request,
_name: name.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Creates a Microsoft AD domain.
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `parent` - Required. The resource project name and location using the form: `projects/{project_id}/locations/global`
pub fn locations_global_domains_create(&self, request: Domain, parent: &str) -> ProjectLocationGlobalDomainCreateCall<'a, S> {
ProjectLocationGlobalDomainCreateCall {
hub: self.hub,
_request: request,
_parent: parent.to_string(),
_domain_name: Default::default(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Deletes a domain.
///
/// # Arguments
///
/// * `name` - Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`
pub fn locations_global_domains_delete(&self, name: &str) -> ProjectLocationGlobalDomainDeleteCall<'a, S> {
ProjectLocationGlobalDomainDeleteCall {
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:
///
/// Removes an AD trust.
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `name` - Required. The resource domain name, project name, and location using the form: `projects/{project_id}/locations/global/domains/{domain_name}`
pub fn locations_global_domains_detach_trust(&self, request: DetachTrustRequest, name: &str) -> ProjectLocationGlobalDomainDetachTrustCall<'a, S> {
ProjectLocationGlobalDomainDetachTrustCall {
hub: self.hub,
_request: request,
_name: name.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Extend Schema for Domain
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `domain` - Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`
pub fn locations_global_domains_extend_schema(&self, request: ExtendSchemaRequest, domain: &str) -> ProjectLocationGlobalDomainExtendSchemaCall<'a, S> {
ProjectLocationGlobalDomainExtendSchemaCall {
hub: self.hub,
_request: request,
_domain: domain.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Gets information about a domain.
///
/// # Arguments
///
/// * `name` - Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`
pub fn locations_global_domains_get(&self, name: &str) -> ProjectLocationGlobalDomainGetCall<'a, S> {
ProjectLocationGlobalDomainGetCall {
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 access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.
///
/// # Arguments
///
/// * `resource` - REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
pub fn locations_global_domains_get_iam_policy(&self, resource: &str) -> ProjectLocationGlobalDomainGetIamPolicyCall<'a, S> {
ProjectLocationGlobalDomainGetIamPolicyCall {
hub: self.hub,
_resource: resource.to_string(),
_options_requested_policy_version: Default::default(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Gets the domain ldaps settings.
///
/// # Arguments
///
/// * `name` - Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`
pub fn locations_global_domains_get_ldapssettings(&self, name: &str) -> ProjectLocationGlobalDomainGetLdapssettingCall<'a, S> {
ProjectLocationGlobalDomainGetLdapssettingCall {
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 domains in a project.
///
/// # Arguments
///
/// * `parent` - Required. The resource name of the domain location using the form: `projects/{project_id}/locations/global`
pub fn locations_global_domains_list(&self, parent: &str) -> ProjectLocationGlobalDomainListCall<'a, S> {
ProjectLocationGlobalDomainListCall {
hub: self.hub,
_parent: parent.to_string(),
_page_token: Default::default(),
_page_size: Default::default(),
_order_by: 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:
///
/// Updates the metadata and configuration of a domain.
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `name` - Required. The unique name of the domain using the form: `projects/{project_id}/locations/global/domains/{domain_name}`.
pub fn locations_global_domains_patch(&self, request: Domain, name: &str) -> ProjectLocationGlobalDomainPatchCall<'a, S> {
ProjectLocationGlobalDomainPatchCall {
hub: self.hub,
_request: request,
_name: name.to_string(),
_update_mask: Default::default(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Updates the DNS conditional forwarder.
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `name` - Required. The resource domain name, project name and location using the form: `projects/{project_id}/locations/global/domains/{domain_name}`
pub fn locations_global_domains_reconfigure_trust(&self, request: ReconfigureTrustRequest, name: &str) -> ProjectLocationGlobalDomainReconfigureTrustCall<'a, S> {
ProjectLocationGlobalDomainReconfigureTrustCall {
hub: self.hub,
_request: request,
_name: name.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Resets a domain's administrator password.
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `name` - Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`
pub fn locations_global_domains_reset_admin_password(&self, request: ResetAdminPasswordRequest, name: &str) -> ProjectLocationGlobalDomainResetAdminPasswordCall<'a, S> {
ProjectLocationGlobalDomainResetAdminPasswordCall {
hub: self.hub,
_request: request,
_name: name.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// RestoreDomain restores domain backup mentioned in the RestoreDomainRequest
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `name` - Required. Resource name for the domain to which the backup belongs
pub fn locations_global_domains_restore(&self, request: RestoreDomainRequest, name: &str) -> ProjectLocationGlobalDomainRestoreCall<'a, S> {
ProjectLocationGlobalDomainRestoreCall {
hub: self.hub,
_request: request,
_name: name.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `resource` - REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
pub fn locations_global_domains_set_iam_policy(&self, request: SetIamPolicyRequest, resource: &str) -> ProjectLocationGlobalDomainSetIamPolicyCall<'a, S> {
ProjectLocationGlobalDomainSetIamPolicyCall {
hub: self.hub,
_request: request,
_resource: resource.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may "fail open" without warning.
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `resource` - REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
pub fn locations_global_domains_test_iam_permissions(&self, request: TestIamPermissionsRequest, resource: &str) -> ProjectLocationGlobalDomainTestIamPermissionCall<'a, S> {
ProjectLocationGlobalDomainTestIamPermissionCall {
hub: self.hub,
_request: request,
_resource: resource.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Patches a single ldaps settings.
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `name` - The resource name of the LDAPS settings. Uses the form: `projects/{project}/locations/{location}/domains/{domain}`.
pub fn locations_global_domains_update_ldapssettings(&self, request: LDAPSSettings, name: &str) -> ProjectLocationGlobalDomainUpdateLdapssettingCall<'a, S> {
ProjectLocationGlobalDomainUpdateLdapssettingCall {
hub: self.hub,
_request: request,
_name: name.to_string(),
_update_mask: Default::default(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Validates a trust state, that the target domain is reachable, and that the target domain is able to accept incoming trust requests.
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `name` - Required. The resource domain name, project name, and location using the form: `projects/{project_id}/locations/global/domains/{domain_name}`
pub fn locations_global_domains_validate_trust(&self, request: ValidateTrustRequest, name: &str) -> ProjectLocationGlobalDomainValidateTrustCall<'a, S> {
ProjectLocationGlobalDomainValidateTrustCall {
hub: self.hub,
_request: request,
_name: name.to_string(),
_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
///
/// * `request` - No description provided.
/// * `name` - The name of the operation resource to be cancelled.
pub fn locations_global_operations_cancel(&self, request: CancelOperationRequest, name: &str) -> ProjectLocationGlobalOperationCancelCall<'a, S> {
ProjectLocationGlobalOperationCancelCall {
hub: self.hub,
_request: request,
_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 locations_global_operations_delete(&self, name: &str) -> ProjectLocationGlobalOperationDeleteCall<'a, S> {
ProjectLocationGlobalOperationDeleteCall {
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 locations_global_operations_get(&self, name: &str) -> ProjectLocationGlobalOperationGetCall<'a, S> {
ProjectLocationGlobalOperationGetCall {
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`. NOTE: the `name` binding allows API services to override the binding to use different resource name schemes, such as `users/*/operations`. To override the binding, API services can add a binding such as `"/v1/{name=users/*}/operations"` to their service configuration. For backwards compatibility, the default name includes the operations collection id, however overriding users must ensure the name binding is the parent resource, without the operations collection id.
///
/// # Arguments
///
/// * `name` - The name of the operation's parent resource.
pub fn locations_global_operations_list(&self, name: &str) -> ProjectLocationGlobalOperationListCall<'a, S> {
ProjectLocationGlobalOperationListCall {
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:
///
/// Creates a Peering for Managed AD instance.
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `parent` - Required. Resource project name and location using the form: `projects/{project_id}/locations/global`
pub fn locations_global_peerings_create(&self, request: Peering, parent: &str) -> ProjectLocationGlobalPeeringCreateCall<'a, S> {
ProjectLocationGlobalPeeringCreateCall {
hub: self.hub,
_request: request,
_parent: parent.to_string(),
_peering_id: Default::default(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Deletes identified Peering.
///
/// # Arguments
///
/// * `name` - Required. Peering resource name using the form: `projects/{project_id}/locations/global/peerings/{peering_id}`
pub fn locations_global_peerings_delete(&self, name: &str) -> ProjectLocationGlobalPeeringDeleteCall<'a, S> {
ProjectLocationGlobalPeeringDeleteCall {
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 details of a single Peering.
///
/// # Arguments
///
/// * `name` - Required. Peering resource name using the form: `projects/{project_id}/locations/global/peerings/{peering_id}`
pub fn locations_global_peerings_get(&self, name: &str) -> ProjectLocationGlobalPeeringGetCall<'a, S> {
ProjectLocationGlobalPeeringGetCall {
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 access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.
///
/// # Arguments
///
/// * `resource` - REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
pub fn locations_global_peerings_get_iam_policy(&self, resource: &str) -> ProjectLocationGlobalPeeringGetIamPolicyCall<'a, S> {
ProjectLocationGlobalPeeringGetIamPolicyCall {
hub: self.hub,
_resource: resource.to_string(),
_options_requested_policy_version: Default::default(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Lists Peerings in a given project.
///
/// # Arguments
///
/// * `parent` - Required. The resource name of the peering location using the form: `projects/{project_id}/locations/global`
pub fn locations_global_peerings_list(&self, parent: &str) -> ProjectLocationGlobalPeeringListCall<'a, S> {
ProjectLocationGlobalPeeringListCall {
hub: self.hub,
_parent: parent.to_string(),
_page_token: Default::default(),
_page_size: Default::default(),
_order_by: 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:
///
/// Updates the labels for specified Peering.
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `name` - Output only. Unique name of the peering in this scope including projects and location using the form: `projects/{project_id}/locations/global/peerings/{peering_id}`.
pub fn locations_global_peerings_patch(&self, request: Peering, name: &str) -> ProjectLocationGlobalPeeringPatchCall<'a, S> {
ProjectLocationGlobalPeeringPatchCall {
hub: self.hub,
_request: request,
_name: name.to_string(),
_update_mask: Default::default(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `resource` - REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
pub fn locations_global_peerings_set_iam_policy(&self, request: SetIamPolicyRequest, resource: &str) -> ProjectLocationGlobalPeeringSetIamPolicyCall<'a, S> {
ProjectLocationGlobalPeeringSetIamPolicyCall {
hub: self.hub,
_request: request,
_resource: resource.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may "fail open" without warning.
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `resource` - REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
pub fn locations_global_peerings_test_iam_permissions(&self, request: TestIamPermissionsRequest, resource: &str) -> ProjectLocationGlobalPeeringTestIamPermissionCall<'a, S> {
ProjectLocationGlobalPeeringTestIamPermissionCall {
hub: self.hub,
_request: request,
_resource: resource.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Gets information about a location.
///
/// # Arguments
///
/// * `name` - Resource name for the location.
pub fn locations_get(&self, name: &str) -> ProjectLocationGetCall<'a, S> {
ProjectLocationGetCall {
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 information about the supported locations for this service.
///
/// # Arguments
///
/// * `name` - The resource that owns the locations collection, if applicable.
pub fn locations_list(&self, name: &str) -> ProjectLocationListCall<'a, S> {
ProjectLocationListCall {
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(),
}
}
}

35
gen/managedidentities1/src/api/mod.rs
View File

@@ -1,35 +0,0 @@
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::*;
mod enums;
pub use enums::*;

901
gen/managedidentities1/src/api/schemas.rs
View File

@@ -1,901 +0,0 @@
use super::*;
/// Request message for AttachTrust
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global domains attach trust projects](ProjectLocationGlobalDomainAttachTrustCall) (request)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct AttachTrustRequest {
/// Required. The domain trust resource.
pub trust: Option<Trust>,
}
impl client::RequestValue for AttachTrustRequest {}
/// Represents a Managed Microsoft Identities backup.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global domains backups create projects](ProjectLocationGlobalDomainBackupCreateCall) (request)
/// * [locations global domains backups get projects](ProjectLocationGlobalDomainBackupGetCall) (response)
/// * [locations global domains backups patch projects](ProjectLocationGlobalDomainBackupPatchCall) (request)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Backup {
/// Output only. The time the backups was created.
#[serde(rename="createTime")]
pub create_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
/// Optional. Resource labels to represent user provided metadata.
pub labels: Option<HashMap<String, String>>,
/// Output only. The unique name of the Backup in the form of `projects/{project_id}/locations/global/domains/{domain_name}/backups/{name}`
pub name: Option<String>,
/// Output only. The current state of the backup.
pub state: Option<BackupStateEnum>,
/// Output only. Additional information about the current status of this backup, if available.
#[serde(rename="statusMessage")]
pub status_message: Option<String>,
/// Output only. Indicates whether it’s an on-demand backup or scheduled.
#[serde(rename="type")]
pub type_: Option<BackupTypeEnum>,
/// Output only. Last update time.
#[serde(rename="updateTime")]
pub update_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
}
impl client::RequestValue for Backup {}
impl client::ResponseResult for Backup {}
/// Associates `members`, or principals, with a `role`.
///
/// This type is not used in any activity, and only used as *part* of another schema.
///
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Binding {
/// The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
pub condition: Option<Expr>,
/// Specifies the principals requesting access for a Google Cloud resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. Does not include identities that come from external identity providers (IdPs) through identity federation. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a Google service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `serviceAccount:{projectid}.svc.id.goog[{namespace}/{kubernetes-sa}]`: An identifier for a [Kubernetes service account](https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts). For example, `my-project.svc.id.goog[my-namespace/my-kubernetes-sa]`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`.
pub members: Option<Vec<String>>,
/// Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
pub role: Option<String>,
}
impl client::Part for Binding {}
/// The request message for Operations.CancelOperation.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global operations cancel projects](ProjectLocationGlobalOperationCancelCall) (request)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct CancelOperationRequest { _never_set: Option<bool> }
impl client::RequestValue for CancelOperationRequest {}
/// Certificate used to configure LDAPS.
///
/// This type is not used in any activity, and only used as *part* of another schema.
///
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Certificate {
/// The certificate expire time.
#[serde(rename="expireTime")]
pub expire_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
/// The issuer of this certificate.
#[serde(rename="issuingCertificate")]
pub issuing_certificate: Option<Option<Box<Certificate>>>,
/// The certificate subject.
pub subject: Option<String>,
/// The additional hostnames for the domain.
#[serde(rename="subjectAlternativeName")]
pub subject_alternative_name: Option<Vec<String>>,
/// The certificate thumbprint which uniquely identifies the certificate.
pub thumbprint: Option<String>,
}
impl client::Part for Certificate {}
/// Request message for DetachTrust
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global domains detach trust projects](ProjectLocationGlobalDomainDetachTrustCall) (request)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct DetachTrustRequest {
/// Required. The domain trust resource to removed.
pub trust: Option<Trust>,
}
impl client::RequestValue for DetachTrustRequest {}
/// Represents a managed Microsoft Active Directory domain. If the domain is being changed, it will be placed into the UPDATING state, which indicates that the resource is being reconciled. At this point, Get will reflect an intermediate state.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global domains create projects](ProjectLocationGlobalDomainCreateCall) (request)
/// * [locations global domains get projects](ProjectLocationGlobalDomainGetCall) (response)
/// * [locations global domains patch projects](ProjectLocationGlobalDomainPatchCall) (request)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Domain {
/// Optional. The name of delegated administrator account used to perform Active Directory operations. If not specified, `setupadmin` will be used.
pub admin: Option<String>,
/// Optional. Configuration for audit logs. True if audit logs are enabled, else false. Default is audit logs disabled.
#[serde(rename="auditLogsEnabled")]
pub audit_logs_enabled: Option<bool>,
/// Optional. The full names of the Google Compute Engine [networks](https://cloud.google.com/compute/docs/networks-and-firewalls#networks) the domain instance is connected to. Networks can be added using UpdateDomain. The domain is only available on networks listed in `authorized_networks`. If CIDR subnets overlap between networks, domain creation will fail.
#[serde(rename="authorizedNetworks")]
pub authorized_networks: Option<Vec<String>>,
/// Output only. The time the instance was created.
#[serde(rename="createTime")]
pub create_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
/// Output only. The fully-qualified domain name of the exposed domain used by clients to connect to the service. Similar to what would be chosen for an Active Directory set up on an internal network.
pub fqdn: Option<String>,
/// Optional. Resource labels that can contain user-provided metadata.
pub labels: Option<HashMap<String, String>>,
/// Required. Locations where domain needs to be provisioned. regions e.g. us-west1 or us-east4 Service supports up to 4 locations at once. Each location will use a /26 block.
pub locations: Option<Vec<String>>,
/// Required. The unique name of the domain using the form: `projects/{project_id}/locations/global/domains/{domain_name}`.
pub name: Option<String>,
/// Required. The CIDR range of internal addresses that are reserved for this domain. Reserved networks must be /24 or larger. Ranges must be unique and non-overlapping with existing subnets in [Domain].[authorized_networks].
#[serde(rename="reservedIpRange")]
pub reserved_ip_range: Option<String>,
/// Output only. The current state of this domain.
pub state: Option<DomainStateEnum>,
/// Output only. Additional information about the current status of this domain, if available.
#[serde(rename="statusMessage")]
pub status_message: Option<String>,
/// Output only. The current trusts associated with the domain.
pub trusts: Option<Vec<Trust>>,
/// Output only. The last update time.
#[serde(rename="updateTime")]
pub update_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
}
impl client::RequestValue for Domain {}
impl client::ResponseResult for Domain {}
/// A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global operations cancel projects](ProjectLocationGlobalOperationCancelCall) (response)
/// * [locations global operations delete projects](ProjectLocationGlobalOperationDeleteCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Empty { _never_set: Option<bool> }
impl client::ResponseResult for Empty {}
/// Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: "Summary size limit" description: "Determines if a summary is less than 100 chars" expression: "document.summary.size() < 100" Example (Equality): title: "Requestor is owner" description: "Determines if requestor is the document owner" expression: "document.owner == request.auth.claims.email" Example (Logic): title: "Public documents" description: "Determine whether the document should be publicly visible" expression: "document.type != 'private' && document.type != 'internal'" Example (Data Manipulation): title: "Notification string" description: "Create a notification string with a timestamp." expression: "'New message received at ' + string(document.create_time)" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.
///
/// This type is not used in any activity, and only used as *part* of another schema.
///
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Expr {
/// Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
pub description: Option<String>,
/// Textual representation of an expression in Common Expression Language syntax.
pub expression: Option<String>,
/// Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.
pub location: Option<String>,
/// Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.
pub title: Option<String>,
}
impl client::Part for Expr {}
/// ExtendSchemaRequest is the request message for ExtendSchema method.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global domains extend schema projects](ProjectLocationGlobalDomainExtendSchemaCall) (request)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ExtendSchemaRequest {
/// Required. Description for Schema Change.
pub description: Option<String>,
/// File uploaded as a byte stream input.
#[serde(rename="fileContents")]
#[serde_as(as = "Option<::client::serde::urlsafe_base64::Wrapper>")]
pub file_contents: Option<Vec<u8>>,
/// File stored in Cloud Storage bucket and represented in the form projects/{project_id}/buckets/{bucket_name}/objects/{object_name} File should be in the same project as the domain.
#[serde(rename="gcsPath")]
pub gcs_path: Option<String>,
}
impl client::RequestValue for ExtendSchemaRequest {}
/// LDAPSSettings represents the ldaps settings for domain resource. LDAP is the Lightweight Directory Access Protocol, defined in https://tools.ietf.org/html/rfc4511. The settings object configures LDAP over SSL/TLS, whether it is over port 636 or the StartTLS operation. If LDAPSSettings is being changed, it will be placed into the UPDATING state, which indicates that the resource is being reconciled. At this point, Get will reflect an intermediate state.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global domains get ldapssettings projects](ProjectLocationGlobalDomainGetLdapssettingCall) (response)
/// * [locations global domains update ldapssettings projects](ProjectLocationGlobalDomainUpdateLdapssettingCall) (request)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct LDAPSSettings {
/// Output only. The certificate used to configure LDAPS. Certificates can be chained with a maximum length of 15.
pub certificate: Option<Certificate>,
/// Input only. The password used to encrypt the uploaded PFX certificate.
#[serde(rename="certificatePassword")]
pub certificate_password: Option<String>,
/// Input only. The uploaded PKCS12-formatted certificate to configure LDAPS with. It will enable the domain controllers in this domain to accept LDAPS connections (either LDAP over SSL/TLS or the StartTLS operation). A valid certificate chain must form a valid x.509 certificate chain (or be comprised of a single self-signed certificate. It must be encrypted with either: 1) PBES2 + PBKDF2 + AES256 encryption and SHA256 PRF; or 2) pbeWithSHA1And3-KeyTripleDES-CBC Private key must be included for the leaf / single self-signed certificate. Note: For a fqdn your-example-domain.com, the wildcard fqdn is *.your-example-domain.com. Specifically the leaf certificate must have: - Either a blank subject or a subject with CN matching the wildcard fqdn. - Exactly two SANs - the fqdn and wildcard fqdn. - Encipherment and digital key signature key usages. - Server authentication extended key usage (OID=1.3.6.1.5.5.7.3.1) - Private key must be in one of the following formats: RSA, ECDSA, ED25519. - Private key must have appropriate key length: 2048 for RSA, 256 for ECDSA - Signature algorithm of the leaf certificate cannot be MD2, MD5 or SHA1.
#[serde(rename="certificatePfx")]
#[serde_as(as = "Option<::client::serde::urlsafe_base64::Wrapper>")]
pub certificate_pfx: Option<Vec<u8>>,
/// The resource name of the LDAPS settings. Uses the form: `projects/{project}/locations/{location}/domains/{domain}`.
pub name: Option<String>,
/// Output only. The current state of this LDAPS settings.
pub state: Option<LDAPSSettingStateEnum>,
/// Output only. Last update time.
#[serde(rename="updateTime")]
pub update_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
}
impl client::RequestValue for LDAPSSettings {}
impl client::ResponseResult for LDAPSSettings {}
/// ListBackupsResponse is the response message for ListBackups method.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global domains backups list projects](ProjectLocationGlobalDomainBackupListCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ListBackupsResponse {
/// A list of Cloud AD backups in the domain.
pub backups: Option<Vec<Backup>>,
/// Token to retrieve the next page of results, or empty if there are no more results in the list.
#[serde(rename="nextPageToken")]
pub next_page_token: Option<String>,
/// Locations that could not be reached.
pub unreachable: Option<Vec<String>>,
}
impl client::ResponseResult for ListBackupsResponse {}
/// Response message for ListDomains
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global domains list projects](ProjectLocationGlobalDomainListCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ListDomainsResponse {
/// A list of Managed Identities Service domains in the project.
pub domains: Option<Vec<Domain>>,
/// A token to retrieve the next page of results, or empty if there are no more results in the list.
#[serde(rename="nextPageToken")]
pub next_page_token: Option<String>,
/// A list of locations that could not be reached.
pub unreachable: Option<Vec<String>>,
}
impl client::ResponseResult for ListDomainsResponse {}
/// The response message for Locations.ListLocations.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations list projects](ProjectLocationListCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ListLocationsResponse {
/// A list of locations that matches the specified filter in the request.
pub locations: Option<Vec<Location>>,
/// The standard List next-page token.
#[serde(rename="nextPageToken")]
pub next_page_token: Option<String>,
}
impl client::ResponseResult for ListLocationsResponse {}
/// The response message for Operations.ListOperations.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global operations list projects](ProjectLocationGlobalOperationListCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ListOperationsResponse {
/// The standard List next-page token.
#[serde(rename="nextPageToken")]
pub next_page_token: Option<String>,
/// A list of operations that matches the specified filter in the request.
pub operations: Option<Vec<Operation>>,
}
impl client::ResponseResult for ListOperationsResponse {}
/// ListPeeringsResponse is the response message for ListPeerings method.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global peerings list projects](ProjectLocationGlobalPeeringListCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ListPeeringsResponse {
/// Token to retrieve the next page of results, or empty if there are no more results in the list.
#[serde(rename="nextPageToken")]
pub next_page_token: Option<String>,
/// A list of Managed Identities Service Peerings in the project.
pub peerings: Option<Vec<Peering>>,
/// Locations that could not be reached.
pub unreachable: Option<Vec<String>>,
}
impl client::ResponseResult for ListPeeringsResponse {}
/// ListSqlIntegrationsResponse is the response message for ListSqlIntegrations method.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global domains sql integrations list projects](ProjectLocationGlobalDomainSqlIntegrationListCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ListSqlIntegrationsResponse {
/// Token to retrieve the next page of results, or empty if there are no more results in the list.
#[serde(rename="nextPageToken")]
pub next_page_token: Option<String>,
/// A list of SQLIntegrations of a domain.
#[serde(rename="sqlIntegrations")]
pub sql_integrations: Option<Vec<SqlIntegration>>,
/// A list of locations that could not be reached.
pub unreachable: Option<Vec<String>>,
}
impl client::ResponseResult for ListSqlIntegrationsResponse {}
/// A resource that represents Google Cloud Platform location.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations get projects](ProjectLocationGetCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Location {
/// The friendly name for this location, typically a nearby city name. For example, "Tokyo".
#[serde(rename="displayName")]
pub display_name: Option<String>,
/// Cross-service attributes for the location. For example {"cloud.googleapis.com/region": "us-east1"}
pub labels: Option<HashMap<String, String>>,
/// The canonical id for this location. For example: `"us-east1"`.
#[serde(rename="locationId")]
pub location_id: Option<String>,
/// Service-specific metadata. For example the available capacity at the given location.
pub metadata: Option<HashMap<String, json::Value>>,
/// Resource name for the location, which may vary between implementations. For example: `"projects/example-project/locations/us-east1"`
pub name: Option<String>,
}
impl client::ResponseResult for Location {}
/// This resource represents a long-running operation that is the result of a network API call.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global domains backups create projects](ProjectLocationGlobalDomainBackupCreateCall) (response)
/// * [locations global domains backups delete projects](ProjectLocationGlobalDomainBackupDeleteCall) (response)
/// * [locations global domains backups patch projects](ProjectLocationGlobalDomainBackupPatchCall) (response)
/// * [locations global domains attach trust projects](ProjectLocationGlobalDomainAttachTrustCall) (response)
/// * [locations global domains create projects](ProjectLocationGlobalDomainCreateCall) (response)
/// * [locations global domains delete projects](ProjectLocationGlobalDomainDeleteCall) (response)
/// * [locations global domains detach trust projects](ProjectLocationGlobalDomainDetachTrustCall) (response)
/// * [locations global domains extend schema projects](ProjectLocationGlobalDomainExtendSchemaCall) (response)
/// * [locations global domains patch projects](ProjectLocationGlobalDomainPatchCall) (response)
/// * [locations global domains reconfigure trust projects](ProjectLocationGlobalDomainReconfigureTrustCall) (response)
/// * [locations global domains restore projects](ProjectLocationGlobalDomainRestoreCall) (response)
/// * [locations global domains update ldapssettings projects](ProjectLocationGlobalDomainUpdateLdapssettingCall) (response)
/// * [locations global domains validate trust projects](ProjectLocationGlobalDomainValidateTrustCall) (response)
/// * [locations global operations get projects](ProjectLocationGlobalOperationGetCall) (response)
/// * [locations global peerings create projects](ProjectLocationGlobalPeeringCreateCall) (response)
/// * [locations global peerings delete projects](ProjectLocationGlobalPeeringDeleteCall) (response)
/// * [locations global peerings patch projects](ProjectLocationGlobalPeeringPatchCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Operation {
/// If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.
pub done: Option<bool>,
/// The error result of the operation in case of failure or cancellation.
pub error: Option<Status>,
/// Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.
pub metadata: Option<HashMap<String, json::Value>>,
/// The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.
pub name: Option<String>,
/// The normal response of the operation in case of success. If the original method returns no data on success, such as `Delete`, the response is `google.protobuf.Empty`. If the original method is standard `Get`/`Create`/`Update`, the response should be the resource. For other methods, the response should have the type `XxxResponse`, where `Xxx` is the original method name. For example, if the original method name is `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.
pub response: Option<HashMap<String, json::Value>>,
}
impl client::ResponseResult for Operation {}
/// Represents a Managed Service for Microsoft Active Directory Peering.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global peerings create projects](ProjectLocationGlobalPeeringCreateCall) (request)
/// * [locations global peerings get projects](ProjectLocationGlobalPeeringGetCall) (response)
/// * [locations global peerings patch projects](ProjectLocationGlobalPeeringPatchCall) (request)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Peering {
/// Required. The full names of the Google Compute Engine [networks](https://cloud.google.com/compute/docs/networks-and-firewalls#networks) to which the instance is connected. Caller needs to make sure that CIDR subnets do not overlap between networks, else peering creation will fail.
#[serde(rename="authorizedNetwork")]
pub authorized_network: Option<String>,
/// Output only. The time the instance was created.
#[serde(rename="createTime")]
pub create_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
/// Required. Full domain resource path for the Managed AD Domain involved in peering. The resource path should be in the form: `projects/{project_id}/locations/global/domains/{domain_name}`
#[serde(rename="domainResource")]
pub domain_resource: Option<String>,
/// Optional. Resource labels to represent user-provided metadata.
pub labels: Option<HashMap<String, String>>,
/// Output only. Unique name of the peering in this scope including projects and location using the form: `projects/{project_id}/locations/global/peerings/{peering_id}`.
pub name: Option<String>,
/// Output only. The current state of this Peering.
pub state: Option<PeeringStateEnum>,
/// Output only. Additional information about the current status of this peering, if available.
#[serde(rename="statusMessage")]
pub status_message: Option<String>,
/// Output only. Last update time.
#[serde(rename="updateTime")]
pub update_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
}
impl client::RequestValue for Peering {}
impl client::ResponseResult for Peering {}
/// An Identity and Access Management (IAM) policy, which specifies access controls for Google Cloud resources. A `Policy` is a collection of `bindings`. A `binding` binds one or more `members`, or principals, to a single `role`. Principals can be user accounts, service accounts, Google groups, and domains (such as G Suite). A `role` is a named list of permissions; each `role` can be an IAM predefined role or a user-created custom role. For some types of Google Cloud resources, a `binding` can also specify a `condition`, which is a logical expression that allows access to a resource only if the expression evaluates to `true`. A condition can add constraints based on attributes of the request, the resource, or both. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies). **JSON example:** { “bindings”: \[ { “role”: “roles/resourcemanager.organizationAdmin”, “members”: \[ “user:mike@example.com”, “group:admins@example.com”, “domain:google.com”, “serviceAccount:my-project-id@appspot.gserviceaccount.com” \] }, { “role”: “roles/resourcemanager.organizationViewer”, “members”: \[ “user:eve@example.com” \], “condition”: { “title”: “expirable access”, “description”: “Does not grant access after Sep 2020”, “expression”: “request.time \< timestamp(‘2020-10-01T00:00:00.000Z’)”, } } \], “etag”: “BwWWja0YfJA=”, “version”: 3 } **YAML example:** bindings: - members: - user:mike@example.com - group:admins@example.com - domain:google.com - serviceAccount:my-project-id@appspot.gserviceaccount.com role: roles/resourcemanager.organizationAdmin - members: - user:eve@example.com role: roles/resourcemanager.organizationViewer condition: title: expirable access description: Does not grant access after Sep 2020 expression: request.time \< timestamp(‘2020-10-01T00:00:00.000Z’) etag: BwWWja0YfJA= version: 3 For a description of IAM and its features, see the [IAM documentation](https://cloud.google.com/iam/docs/).
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global domains backups get iam policy projects](ProjectLocationGlobalDomainBackupGetIamPolicyCall) (response)
/// * [locations global domains backups set iam policy projects](ProjectLocationGlobalDomainBackupSetIamPolicyCall) (response)
/// * [locations global domains get iam policy projects](ProjectLocationGlobalDomainGetIamPolicyCall) (response)
/// * [locations global domains set iam policy projects](ProjectLocationGlobalDomainSetIamPolicyCall) (response)
/// * [locations global peerings get iam policy projects](ProjectLocationGlobalPeeringGetIamPolicyCall) (response)
/// * [locations global peerings set iam policy projects](ProjectLocationGlobalPeeringSetIamPolicyCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Policy {
/// Associates a list of `members`, or principals, with a `role`. Optionally, may specify a `condition` that determines how and when the `bindings` are applied. Each of the `bindings` must contain at least one principal. The `bindings` in a `Policy` can refer to up to 1,500 principals; up to 250 of these principals can be Google groups. Each occurrence of a principal counts towards these limits. For example, if the `bindings` grant 50 different roles to `user:alice@example.com`, and not to any other principal, then you can add another 1,450 principals to the `bindings` in the `Policy`.
pub bindings: Option<Vec<Binding>>,
/// `etag` is used for optimistic concurrency control as a way to help prevent simultaneous updates of a policy from overwriting each other. It is strongly suggested that systems make use of the `etag` in the read-modify-write cycle to perform policy updates in order to avoid race conditions: An `etag` is returned in the response to `getIamPolicy`, and systems are expected to put that etag in the request to `setIamPolicy` to ensure that their change will be applied to the same version of the policy. **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost.
#[serde_as(as = "Option<::client::serde::urlsafe_base64::Wrapper>")]
pub etag: Option<Vec<u8>>,
/// Specifies the format of the policy. Valid values are `0`, `1`, and `3`. Requests that specify an invalid value are rejected. Any operation that affects conditional role bindings must specify version `3`. This requirement applies to the following operations: * Getting a policy that includes a conditional role binding * Adding a conditional role binding to a policy * Changing a conditional role binding in a policy * Removing any role binding, with or without a condition, from a policy that includes conditions **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost. If a policy does not include any conditions, operations on that policy may specify any valid version or leave the field unset. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
pub version: Option<i32>,
}
impl client::ResponseResult for Policy {}
/// Request message for ReconfigureTrust
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global domains reconfigure trust projects](ProjectLocationGlobalDomainReconfigureTrustCall) (request)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ReconfigureTrustRequest {
/// Required. The target DNS server IP addresses to resolve the remote domain involved in the trust.
#[serde(rename="targetDnsIpAddresses")]
pub target_dns_ip_addresses: Option<Vec<String>>,
/// Required. The fully-qualified target domain name which will be in trust with current domain.
#[serde(rename="targetDomainName")]
pub target_domain_name: Option<String>,
}
impl client::RequestValue for ReconfigureTrustRequest {}
/// Request message for ResetAdminPassword
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global domains reset admin password projects](ProjectLocationGlobalDomainResetAdminPasswordCall) (request)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ResetAdminPasswordRequest { _never_set: Option<bool> }
impl client::RequestValue for ResetAdminPasswordRequest {}
/// Response message for ResetAdminPassword
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global domains reset admin password projects](ProjectLocationGlobalDomainResetAdminPasswordCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ResetAdminPasswordResponse {
/// A random password. See admin for more information.
pub password: Option<String>,
}
impl client::ResponseResult for ResetAdminPasswordResponse {}
/// RestoreDomainRequest is the request received by RestoreDomain rpc
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global domains restore projects](ProjectLocationGlobalDomainRestoreCall) (request)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct RestoreDomainRequest {
/// Required. ID of the backup to be restored
#[serde(rename="backupId")]
pub backup_id: Option<String>,
}
impl client::RequestValue for RestoreDomainRequest {}
/// Request message for `SetIamPolicy` method.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global domains backups set iam policy projects](ProjectLocationGlobalDomainBackupSetIamPolicyCall) (request)
/// * [locations global domains set iam policy projects](ProjectLocationGlobalDomainSetIamPolicyCall) (request)
/// * [locations global peerings set iam policy projects](ProjectLocationGlobalPeeringSetIamPolicyCall) (request)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct SetIamPolicyRequest {
/// REQUIRED: The complete policy to be applied to the `resource`. The size of the policy is limited to a few 10s of KB. An empty policy is a valid policy but certain Google Cloud services (such as Projects) might reject them.
pub policy: Option<Policy>,
}
impl client::RequestValue for SetIamPolicyRequest {}
/// Represents the SQL instance integrated with Managed AD.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global domains sql integrations get projects](ProjectLocationGlobalDomainSqlIntegrationGetCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct SqlIntegration {
/// Output only. The time the SQL integration was created.
#[serde(rename="createTime")]
pub create_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
/// The unique name of the SQL integration in the form of `projects/{project_id}/locations/global/domains/{domain_name}/sqlIntegrations/{sql_integration}`
pub name: Option<String>,
/// The full resource name of an integrated SQL instance
#[serde(rename="sqlInstance")]
pub sql_instance: Option<String>,
/// Output only. The current state of the SQL integration.
pub state: Option<SqlIntegrationStateEnum>,
/// Output only. The time the SQL integration was updated.
#[serde(rename="updateTime")]
pub update_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
}
impl client::ResponseResult for SqlIntegration {}
/// The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).
///
/// This type is not used in any activity, and only used as *part* of another schema.
///
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Status {
/// The status code, which should be an enum value of google.rpc.Code.
pub code: Option<i32>,
/// A list of messages that carry the error details. There is a common set of message types for APIs to use.
pub details: Option<Vec<HashMap<String, json::Value>>>,
/// A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.
pub message: Option<String>,
}
impl client::Part for Status {}
/// Request message for `TestIamPermissions` method.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global domains backups test iam permissions projects](ProjectLocationGlobalDomainBackupTestIamPermissionCall) (request)
/// * [locations global domains test iam permissions projects](ProjectLocationGlobalDomainTestIamPermissionCall) (request)
/// * [locations global peerings test iam permissions projects](ProjectLocationGlobalPeeringTestIamPermissionCall) (request)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct TestIamPermissionsRequest {
/// The set of permissions to check for the `resource`. Permissions with wildcards (such as `*` or `storage.*`) are not allowed. For more information see [IAM Overview](https://cloud.google.com/iam/docs/overview#permissions).
pub permissions: Option<Vec<String>>,
}
impl client::RequestValue for TestIamPermissionsRequest {}
/// Response message for `TestIamPermissions` method.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global domains backups test iam permissions projects](ProjectLocationGlobalDomainBackupTestIamPermissionCall) (response)
/// * [locations global domains test iam permissions projects](ProjectLocationGlobalDomainTestIamPermissionCall) (response)
/// * [locations global peerings test iam permissions projects](ProjectLocationGlobalPeeringTestIamPermissionCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct TestIamPermissionsResponse {
/// A subset of `TestPermissionsRequest.permissions` that the caller is allowed.
pub permissions: Option<Vec<String>>,
}
impl client::ResponseResult for TestIamPermissionsResponse {}
/// Represents a relationship between two domains. This allows a controller in one domain to authenticate a user in another domain. If the trust is being changed, it will be placed into the UPDATING state, which indicates that the resource is being reconciled. At this point, Get will reflect an intermediate state.
///
/// This type is not used in any activity, and only used as *part* of another schema.
///
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Trust {
/// Output only. The time the instance was created.
#[serde(rename="createTime")]
pub create_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
/// Output only. The last heartbeat time when the trust was known to be connected.
#[serde(rename="lastTrustHeartbeatTime")]
pub last_trust_heartbeat_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
/// Optional. The trust authentication type, which decides whether the trusted side has forest/domain wide access or selective access to an approved set of resources.
#[serde(rename="selectiveAuthentication")]
pub selective_authentication: Option<bool>,
/// Output only. The current state of the trust.
pub state: Option<TrustStateEnum>,
/// Output only. Additional information about the current state of the trust, if available.
#[serde(rename="stateDescription")]
pub state_description: Option<String>,
/// Required. The target DNS server IP addresses which can resolve the remote domain involved in the trust.
#[serde(rename="targetDnsIpAddresses")]
pub target_dns_ip_addresses: Option<Vec<String>>,
/// Required. The fully qualified target domain name which will be in trust with the current domain.
#[serde(rename="targetDomainName")]
pub target_domain_name: Option<String>,
/// Required. The trust direction, which decides if the current domain is trusted, trusting, or both.
#[serde(rename="trustDirection")]
pub trust_direction: Option<TrustTrustDirectionEnum>,
/// Required. The trust secret used for the handshake with the target domain. This will not be stored.
#[serde(rename="trustHandshakeSecret")]
pub trust_handshake_secret: Option<String>,
/// Required. The type of trust represented by the trust resource.
#[serde(rename="trustType")]
pub trust_type: Option<TrustTrustTypeEnum>,
/// Output only. The last update time.
#[serde(rename="updateTime")]
pub update_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
}
impl client::Part for Trust {}
/// Request message for ValidateTrust
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [locations global domains validate trust projects](ProjectLocationGlobalDomainValidateTrustCall) (request)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ValidateTrustRequest {
/// Required. The domain trust to validate trust state for.
pub trust: Option<Trust>,
}
impl client::RequestValue for ValidateTrustRequest {}

24
gen/managedidentities1/src/api/utilities.rs
View File

@@ -1,24 +0,0 @@
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,
}
impl AsRef<str> for Scope {
fn as_ref(&self) -> &str {
match *self {
Scope::CloudPlatform => "https://www.googleapis.com/auth/cloud-platform",
}
}
}
impl Default for Scope {
fn default() -> Scope {
Scope::CloudPlatform
}
}

222
gen/managedidentities1/src/lib.rs
View File

@@ -1,222 +0,0 @@
// DO NOT EDIT !
// This file was generated automatically from 'src/generator/templates/api/lib.rs.mako'
// DO NOT EDIT !
//! This documentation was generated from *Managed Service for Microsoft Active Directory Consumer API* crate version *5.0.4+20240112*, where *20240112* is the exact revision of the *managedidentities:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v5.0.4*.
//!
//! Everything else about the *Managed Service for Microsoft Active Directory Consumer API* *v1* API can be found at the
//! [official documentation site](https://cloud.google.com/managed-microsoft-ad/).
//! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/managedidentities1).
//! # Features
//!
//! Handle the following *Resources* with ease from the central [hub](ManagedServiceForMicrosoftActiveDirectoryConsumerAPI) ...
//!
//! * projects
//! * [*locations get*](api::ProjectLocationGetCall), [*locations global domains attach trust*](api::ProjectLocationGlobalDomainAttachTrustCall), [*locations global domains backups create*](api::ProjectLocationGlobalDomainBackupCreateCall), [*locations global domains backups delete*](api::ProjectLocationGlobalDomainBackupDeleteCall), [*locations global domains backups get*](api::ProjectLocationGlobalDomainBackupGetCall), [*locations global domains backups get iam policy*](api::ProjectLocationGlobalDomainBackupGetIamPolicyCall), [*locations global domains backups list*](api::ProjectLocationGlobalDomainBackupListCall), [*locations global domains backups patch*](api::ProjectLocationGlobalDomainBackupPatchCall), [*locations global domains backups set iam policy*](api::ProjectLocationGlobalDomainBackupSetIamPolicyCall), [*locations global domains backups test iam permissions*](api::ProjectLocationGlobalDomainBackupTestIamPermissionCall), [*locations global domains check migration permission*](api::ProjectLocationGlobalDomainCheckMigrationPermissionCall), [*locations global domains create*](api::ProjectLocationGlobalDomainCreateCall), [*locations global domains delete*](api::ProjectLocationGlobalDomainDeleteCall), [*locations global domains detach trust*](api::ProjectLocationGlobalDomainDetachTrustCall), [*locations global domains disable migration*](api::ProjectLocationGlobalDomainDisableMigrationCall), [*locations global domains domain join machine*](api::ProjectLocationGlobalDomainDomainJoinMachineCall), [*locations global domains enable migration*](api::ProjectLocationGlobalDomainEnableMigrationCall), [*locations global domains extend schema*](api::ProjectLocationGlobalDomainExtendSchemaCall), [*locations global domains get*](api::ProjectLocationGlobalDomainGetCall), [*locations global domains get iam policy*](api::ProjectLocationGlobalDomainGetIamPolicyCall), [*locations global domains get ldapssettings*](api::ProjectLocationGlobalDomainGetLdapssettingCall), [*locations global domains list*](api::ProjectLocationGlobalDomainListCall), [*locations global domains patch*](api::ProjectLocationGlobalDomainPatchCall), [*locations global domains reconfigure trust*](api::ProjectLocationGlobalDomainReconfigureTrustCall), [*locations global domains reset admin password*](api::ProjectLocationGlobalDomainResetAdminPasswordCall), [*locations global domains restore*](api::ProjectLocationGlobalDomainRestoreCall), [*locations global domains set iam policy*](api::ProjectLocationGlobalDomainSetIamPolicyCall), [*locations global domains sql integrations get*](api::ProjectLocationGlobalDomainSqlIntegrationGetCall), [*locations global domains sql integrations list*](api::ProjectLocationGlobalDomainSqlIntegrationListCall), [*locations global domains test iam permissions*](api::ProjectLocationGlobalDomainTestIamPermissionCall), [*locations global domains update ldapssettings*](api::ProjectLocationGlobalDomainUpdateLdapssettingCall), [*locations global domains validate trust*](api::ProjectLocationGlobalDomainValidateTrustCall), [*locations global operations cancel*](api::ProjectLocationGlobalOperationCancelCall), [*locations global operations delete*](api::ProjectLocationGlobalOperationDeleteCall), [*locations global operations get*](api::ProjectLocationGlobalOperationGetCall), [*locations global operations list*](api::ProjectLocationGlobalOperationListCall), [*locations global peerings create*](api::ProjectLocationGlobalPeeringCreateCall), [*locations global peerings delete*](api::ProjectLocationGlobalPeeringDeleteCall), [*locations global peerings get*](api::ProjectLocationGlobalPeeringGetCall), [*locations global peerings get iam policy*](api::ProjectLocationGlobalPeeringGetIamPolicyCall), [*locations global peerings list*](api::ProjectLocationGlobalPeeringListCall), [*locations global peerings patch*](api::ProjectLocationGlobalPeeringPatchCall), [*locations global peerings set iam policy*](api::ProjectLocationGlobalPeeringSetIamPolicyCall), [*locations global peerings test iam permissions*](api::ProjectLocationGlobalPeeringTestIamPermissionCall) and [*locations list*](api::ProjectLocationListCall)
//!
//!
//!
//!
//! Not what you are looking for ? Find all other Google APIs in their Rust [documentation index](http://byron.github.io/google-apis-rs).
//!
//! # Structure of this Library
//!
//! The API is structured into the following primary items:
//!
//! * **[Hub](ManagedServiceForMicrosoftActiveDirectoryConsumerAPI)**
//! * a central object to maintain state and allow accessing all *Activities*
//! * creates [*Method Builders*](client::MethodsBuilder) which in turn
//! allow access to individual [*Call Builders*](client::CallBuilder)
//! * **[Resources](client::Resource)**
//! * primary types that you can apply *Activities* to
//! * a collection of properties and *Parts*
//! * **[Parts](client::Part)**
//! * a collection of properties
//! * never directly used in *Activities*
//! * **[Activities](client::CallBuilder)**
//! * operations to apply to *Resources*
//!
//! All *structures* are marked with applicable traits to further categorize them and ease browsing.
//!
//! Generally speaking, you can invoke *Activities* like this:
//!
//! ```Rust,ignore
//! let r = hub.resource().activity(...).doit().await
//! ```
//!
//! Or specifically ...
//!
//! ```ignore
//! let r = hub.projects().locations_global_domains_backups_create(...).doit().await
//! let r = hub.projects().locations_global_domains_backups_delete(...).doit().await
//! let r = hub.projects().locations_global_domains_backups_patch(...).doit().await
//! let r = hub.projects().locations_global_domains_attach_trust(...).doit().await
//! let r = hub.projects().locations_global_domains_create(...).doit().await
//! let r = hub.projects().locations_global_domains_delete(...).doit().await
//! let r = hub.projects().locations_global_domains_detach_trust(...).doit().await
//! let r = hub.projects().locations_global_domains_disable_migration(...).doit().await
//! let r = hub.projects().locations_global_domains_enable_migration(...).doit().await
//! let r = hub.projects().locations_global_domains_extend_schema(...).doit().await
//! let r = hub.projects().locations_global_domains_patch(...).doit().await
//! let r = hub.projects().locations_global_domains_reconfigure_trust(...).doit().await
//! let r = hub.projects().locations_global_domains_restore(...).doit().await
//! let r = hub.projects().locations_global_domains_update_ldapssettings(...).doit().await
//! let r = hub.projects().locations_global_domains_validate_trust(...).doit().await
//! let r = hub.projects().locations_global_operations_get(...).doit().await
//! let r = hub.projects().locations_global_peerings_create(...).doit().await
//! let r = hub.projects().locations_global_peerings_delete(...).doit().await
//! let r = hub.projects().locations_global_peerings_patch(...).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
//! 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.
//!
//! # Usage
//!
//! ## Setting up your Project
//!
//! To use this library, you would put the following lines into your `Cargo.toml` file:
//!
//! ```toml
//! [dependencies]
//! google-managedidentities1 = "*"
//! serde = "^1.0"
//! serde_json = "^1.0"
//! ```
//!
//! ## A complete example
//!
//! ```test_harness,no_run
//! extern crate hyper;
//! extern crate hyper_rustls;
//! extern crate google_managedidentities1 as managedidentities1;
//! use managedidentities1::api::Backup;
//! use managedidentities1::{Result, Error};
//! # async fn dox() {
//! use std::default::Default;
//! use managedidentities1::{ManagedServiceForMicrosoftActiveDirectoryConsumerAPI, 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 = ManagedServiceForMicrosoftActiveDirectoryConsumerAPI::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().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 = Backup::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().locations_global_domains_backups_create(req, "parent")
//! .backup_id("ipsum")
//! .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),
//! }
//! # }
//! ```
//! ## 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
//! [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
//! makes the system potentially resilient to all kinds of errors.
//!
//! ## Uploads and Downloads
//! If a method supports downloads, the response body, which is part of the [Result](client::Result), should be
//! read by you to obtain the media.
//! If such a method also supports a [Response Result](client::ResponseResult), it will return that by default.
//! 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
//! `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
//! 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
//! are valid.
//! 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
//!
//! Using [method builders](client::CallBuilder), you are able to prepare an action call by repeatedly calling it's methods.
//! These will always take a single argument, for which the following statements are true.
//!
//! * [PODs][wiki-pod] are handed by copy
//! * strings are passed as `&str`
//! * [request values](client::RequestValue) are moved
//!
//! Arguments will always be copied or cloned into the builder, to make them independent of their original life times.
//!
//! [wiki-pod]: http://en.wikipedia.org/wiki/Plain_old_data_structure
//! [builder-pattern]: http://en.wikipedia.org/wiki/Builder_pattern
//! [google-go-api]: https://github.com/google/google-api-go-client
//!
//!
// Unused attributes happen thanks to defined, but unused structures
// We don't warn about this, as depending on the API, some data structures or facilities are never used.
// Instead of pre-determining this, we just disable the lint. It's manually tuned to not have any
// unused imports in fully featured APIs. Same with unused_mut ... .
#![allow(unused_imports, unused_mut, dead_code)]
// DO NOT EDIT !
// This file was generated automatically from 'src/generator/templates/api/lib.rs.mako'
// DO NOT EDIT !
// Re-export the hyper and hyper_rustls crate, they are required to build the hub
pub use hyper;
pub use hyper_rustls;
pub extern crate google_apis_common as client;
pub use client::chrono;
pub mod api;
// Re-export the hub type and some basic client structs
pub use api::ManagedServiceForMicrosoftActiveDirectoryConsumerAPI;
pub use client::{Result, Error, Delegate, FieldMask};
// Re-export the yup_oauth2 crate, that is required to call some methods of the hub and the client
#[cfg(feature = "yup-oauth2")]
pub use client::oauth2;