// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[derive(Debug)]
pub(crate) struct Handle<
    C = aws_smithy_client::erase::DynConnector,
    M = aws_hyper::AwsMiddleware,
    R = aws_smithy_client::retry::Standard,
> {
    client: aws_smithy_client::Client<C, M, R>,
    conf: crate::Config,
}

/// An ergonomic service client for `AWSGrafanaControlPlane`.
///
/// This client allows ergonomic access to a `AWSGrafanaControlPlane`-shaped service.
/// Each method corresponds to an endpoint defined in the service's Smithy model,
/// and the request and response shapes are auto-generated from that same model.
///
/// # Using a Client
///
/// Once you have a client set up, you can access the service's endpoints
/// by calling the appropriate method on [`Client`]. Each such method
/// returns a request builder for that endpoint, with methods for setting
/// the various fields of the request. Once your request is complete, use
/// the `send` method to send the request. `send` returns a future, which
/// you then have to `.await` to get the service's response.
///
/// [builder pattern]: https://rust-lang.github.io/api-guidelines/type-safety.html#c-builder
/// [SigV4-signed requests]: https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html
#[derive(std::fmt::Debug)]
pub struct Client<
    C = aws_smithy_client::erase::DynConnector,
    M = aws_hyper::AwsMiddleware,
    R = aws_smithy_client::retry::Standard,
> {
    handle: std::sync::Arc<Handle<C, M, R>>,
}

impl<C, M, R> std::clone::Clone for Client<C, M, R> {
    fn clone(&self) -> Self {
        Self {
            handle: self.handle.clone(),
        }
    }
}

#[doc(inline)]
pub use aws_smithy_client::Builder;

impl<C, M, R> From<aws_smithy_client::Client<C, M, R>> for Client<C, M, R> {
    fn from(client: aws_smithy_client::Client<C, M, R>) -> Self {
        Self::with_config(client, crate::Config::builder().build())
    }
}

impl<C, M, R> Client<C, M, R> {
    /// Creates a client with the given service configuration.
    pub fn with_config(client: aws_smithy_client::Client<C, M, R>, conf: crate::Config) -> Self {
        Self {
            handle: std::sync::Arc::new(Handle { client, conf }),
        }
    }

    /// Returns the client's configuration.
    pub fn conf(&self) -> &crate::Config {
        &self.handle.conf
    }
}
impl<C, M, R> Client<C, M, R>
where
    C: aws_smithy_client::bounds::SmithyConnector,
    M: aws_smithy_client::bounds::SmithyMiddleware<C>,
    R: aws_smithy_client::retry::NewRequestPolicy,
{
    /// Constructs a fluent builder for the `AssociateLicense` operation.
    ///
    /// See [`AssociateLicense`](crate::client::fluent_builders::AssociateLicense) for more information about the
    /// operation and its arguments.
    pub fn associate_license(&self) -> fluent_builders::AssociateLicense<C, M, R> {
        fluent_builders::AssociateLicense::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `CreateWorkspace` operation.
    ///
    /// See [`CreateWorkspace`](crate::client::fluent_builders::CreateWorkspace) for more information about the
    /// operation and its arguments.
    pub fn create_workspace(&self) -> fluent_builders::CreateWorkspace<C, M, R> {
        fluent_builders::CreateWorkspace::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `DeleteWorkspace` operation.
    ///
    /// See [`DeleteWorkspace`](crate::client::fluent_builders::DeleteWorkspace) for more information about the
    /// operation and its arguments.
    pub fn delete_workspace(&self) -> fluent_builders::DeleteWorkspace<C, M, R> {
        fluent_builders::DeleteWorkspace::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `DescribeWorkspace` operation.
    ///
    /// See [`DescribeWorkspace`](crate::client::fluent_builders::DescribeWorkspace) for more information about the
    /// operation and its arguments.
    pub fn describe_workspace(&self) -> fluent_builders::DescribeWorkspace<C, M, R> {
        fluent_builders::DescribeWorkspace::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `DescribeWorkspaceAuthentication` operation.
    ///
    /// See [`DescribeWorkspaceAuthentication`](crate::client::fluent_builders::DescribeWorkspaceAuthentication) for more information about the
    /// operation and its arguments.
    pub fn describe_workspace_authentication(
        &self,
    ) -> fluent_builders::DescribeWorkspaceAuthentication<C, M, R> {
        fluent_builders::DescribeWorkspaceAuthentication::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `DisassociateLicense` operation.
    ///
    /// See [`DisassociateLicense`](crate::client::fluent_builders::DisassociateLicense) for more information about the
    /// operation and its arguments.
    pub fn disassociate_license(&self) -> fluent_builders::DisassociateLicense<C, M, R> {
        fluent_builders::DisassociateLicense::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ListPermissions` operation.
    ///
    /// See [`ListPermissions`](crate::client::fluent_builders::ListPermissions) for more information about the
    /// operation and its arguments.
    pub fn list_permissions(&self) -> fluent_builders::ListPermissions<C, M, R> {
        fluent_builders::ListPermissions::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ListWorkspaces` operation.
    ///
    /// See [`ListWorkspaces`](crate::client::fluent_builders::ListWorkspaces) for more information about the
    /// operation and its arguments.
    pub fn list_workspaces(&self) -> fluent_builders::ListWorkspaces<C, M, R> {
        fluent_builders::ListWorkspaces::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `UpdatePermissions` operation.
    ///
    /// See [`UpdatePermissions`](crate::client::fluent_builders::UpdatePermissions) for more information about the
    /// operation and its arguments.
    pub fn update_permissions(&self) -> fluent_builders::UpdatePermissions<C, M, R> {
        fluent_builders::UpdatePermissions::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `UpdateWorkspace` operation.
    ///
    /// See [`UpdateWorkspace`](crate::client::fluent_builders::UpdateWorkspace) for more information about the
    /// operation and its arguments.
    pub fn update_workspace(&self) -> fluent_builders::UpdateWorkspace<C, M, R> {
        fluent_builders::UpdateWorkspace::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `UpdateWorkspaceAuthentication` operation.
    ///
    /// See [`UpdateWorkspaceAuthentication`](crate::client::fluent_builders::UpdateWorkspaceAuthentication) for more information about the
    /// operation and its arguments.
    pub fn update_workspace_authentication(
        &self,
    ) -> fluent_builders::UpdateWorkspaceAuthentication<C, M, R> {
        fluent_builders::UpdateWorkspaceAuthentication::new(self.handle.clone())
    }
}
pub mod fluent_builders {
    //!
    //! Utilities to ergonomically construct a request to the service.
    //!
    //! Fluent builders are created through the [`Client`](crate::client::Client) by calling
    //! one if its operation methods. After parameters are set using the builder methods,
    //! the `send` method can be called to initiate the request.
    //!
    /// Fluent builder constructing a request to `AssociateLicense`.
    ///
    /// <p>Assigns a Grafana Enterprise license to a workspace. Upgrading to Grafana Enterprise
    /// incurs additional fees. For more information, see <a href="https://docs.aws.amazon.com/grafana/latest/userguide/upgrade-to-Grafana-Enterprise.html">Upgrade a workspace to
    /// Grafana Enterprise</a>.</p>
    #[derive(std::fmt::Debug)]
    pub struct AssociateLicense<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::associate_license_input::Builder,
    }
    impl<C, M, R> AssociateLicense<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `AssociateLicense`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::AssociateLicenseOutput,
            aws_smithy_http::result::SdkError<crate::error::AssociateLicenseError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::AssociateLicenseInputOperationOutputAlias,
                crate::output::AssociateLicenseOutput,
                crate::error::AssociateLicenseError,
                crate::input::AssociateLicenseInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The ID of the workspace to associate the license with.</p>
        pub fn workspace_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.workspace_id(inp);
            self
        }
        /// <p>The ID of the workspace to associate the license with.</p>
        pub fn set_workspace_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_workspace_id(input);
            self
        }
        /// <p>The type of license to associate with the workspace.</p>
        pub fn license_type(mut self, inp: crate::model::LicenseType) -> Self {
            self.inner = self.inner.license_type(inp);
            self
        }
        /// <p>The type of license to associate with the workspace.</p>
        pub fn set_license_type(
            mut self,
            input: std::option::Option<crate::model::LicenseType>,
        ) -> Self {
            self.inner = self.inner.set_license_type(input);
            self
        }
    }
    /// Fluent builder constructing a request to `CreateWorkspace`.
    ///
    /// <p>Creates a <i>workspace</i>. In a workspace, you can create Grafana
    /// dashboards and visualizations to analyze your metrics, logs, and traces. You don't have to
    /// build, package, or deploy any hardware to run the Grafana server.</p>
    /// <p>Don't use <code>CreateWorkspace</code> to modify an existing workspace. Instead,
    /// use <a href="https://docs.aws.amazon.com/grafana/latest/APIReference/API_UpdateWorkspace.html">UpdateWorkspace</a>.</p>
    #[derive(std::fmt::Debug)]
    pub struct CreateWorkspace<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::create_workspace_input::Builder,
    }
    impl<C, M, R> CreateWorkspace<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `CreateWorkspace`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::CreateWorkspaceOutput,
            aws_smithy_http::result::SdkError<crate::error::CreateWorkspaceError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::CreateWorkspaceInputOperationOutputAlias,
                crate::output::CreateWorkspaceOutput,
                crate::error::CreateWorkspaceError,
                crate::input::CreateWorkspaceInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>Specifies whether the workspace can access Amazon Web Services resources in this Amazon Web Services account only, or whether it can also access Amazon Web Services resources in
        /// other accounts in the same organization. If you specify <code>ORGANIZATION</code>, you must
        /// specify which organizational units the workspace can access in the
        /// <code>workspaceOrganizationalUnits</code> parameter.</p>
        pub fn account_access_type(mut self, inp: crate::model::AccountAccessType) -> Self {
            self.inner = self.inner.account_access_type(inp);
            self
        }
        /// <p>Specifies whether the workspace can access Amazon Web Services resources in this Amazon Web Services account only, or whether it can also access Amazon Web Services resources in
        /// other accounts in the same organization. If you specify <code>ORGANIZATION</code>, you must
        /// specify which organizational units the workspace can access in the
        /// <code>workspaceOrganizationalUnits</code> parameter.</p>
        pub fn set_account_access_type(
            mut self,
            input: std::option::Option<crate::model::AccountAccessType>,
        ) -> Self {
            self.inner = self.inner.set_account_access_type(input);
            self
        }
        /// <p>A unique, case-sensitive, user-provided identifier to ensure the idempotency of the request.</p>
        pub fn client_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.client_token(inp);
            self
        }
        /// <p>A unique, case-sensitive, user-provided identifier to ensure the idempotency of the request.</p>
        pub fn set_client_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_client_token(input);
            self
        }
        /// <p>The name of an IAM role that already exists to use with Organizations to access Amazon Web Services
        /// data sources and notification channels in other accounts in an organization.</p>
        pub fn organization_role_name(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.organization_role_name(inp);
            self
        }
        /// <p>The name of an IAM role that already exists to use with Organizations to access Amazon Web Services
        /// data sources and notification channels in other accounts in an organization.</p>
        pub fn set_organization_role_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_organization_role_name(input);
            self
        }
        /// <p>If you specify <code>Service Managed</code>, Amazon Managed Grafana automatically creates
        /// the IAM roles and provisions the permissions that the workspace needs to use
        /// Amazon Web Services data sources and notification channels.</p>
        /// <p>If you specify <code>CUSTOMER_MANAGED</code>, you will manage those roles and
        /// permissions yourself. If you are creating this workspace in a member account of an
        /// organization that is not a delegated administrator account, and you want the workspace to access data sources in other Amazon Web Services
        /// accounts in the organization, you must choose <code>CUSTOMER_MANAGED</code>.</p>
        /// <p>For more information, see <a href="https://docs.aws.amazon.com/grafana/latest/userguide/AMG-manage-permissions.html">Amazon Managed Grafana permissions and policies for
        /// Amazon Web Services data sources and notification channels</a>
        /// </p>
        pub fn permission_type(mut self, inp: crate::model::PermissionType) -> Self {
            self.inner = self.inner.permission_type(inp);
            self
        }
        /// <p>If you specify <code>Service Managed</code>, Amazon Managed Grafana automatically creates
        /// the IAM roles and provisions the permissions that the workspace needs to use
        /// Amazon Web Services data sources and notification channels.</p>
        /// <p>If you specify <code>CUSTOMER_MANAGED</code>, you will manage those roles and
        /// permissions yourself. If you are creating this workspace in a member account of an
        /// organization that is not a delegated administrator account, and you want the workspace to access data sources in other Amazon Web Services
        /// accounts in the organization, you must choose <code>CUSTOMER_MANAGED</code>.</p>
        /// <p>For more information, see <a href="https://docs.aws.amazon.com/grafana/latest/userguide/AMG-manage-permissions.html">Amazon Managed Grafana permissions and policies for
        /// Amazon Web Services data sources and notification channels</a>
        /// </p>
        pub fn set_permission_type(
            mut self,
            input: std::option::Option<crate::model::PermissionType>,
        ) -> Self {
            self.inner = self.inner.set_permission_type(input);
            self
        }
        /// <p>The name of the CloudFormation stack set to use to generate IAM roles
        /// to be used for this workspace.</p>
        pub fn stack_set_name(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.stack_set_name(inp);
            self
        }
        /// <p>The name of the CloudFormation stack set to use to generate IAM roles
        /// to be used for this workspace.</p>
        pub fn set_stack_set_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_stack_set_name(input);
            self
        }
        /// Appends an item to `workspaceDataSources`.
        ///
        /// To override the contents of this collection use [`set_workspace_data_sources`](Self::set_workspace_data_sources).
        ///
        /// <p>Specify the Amazon Web Services data sources that you want to be queried in this
        /// workspace. Specifying these data sources here enables Amazon Managed Grafana to create IAM roles and permissions that allow Amazon Managed Grafana to read data from these
        /// sources. You must still add them as data sources in the Grafana console in the
        /// workspace.</p>
        /// <p>If you don't specify a data source here, you can still add it as a data source in the
        /// workspace console later. However, you will then have to manually configure permissions for
        /// it.</p>
        pub fn workspace_data_sources(
            mut self,
            inp: impl Into<crate::model::DataSourceType>,
        ) -> Self {
            self.inner = self.inner.workspace_data_sources(inp);
            self
        }
        /// <p>Specify the Amazon Web Services data sources that you want to be queried in this
        /// workspace. Specifying these data sources here enables Amazon Managed Grafana to create IAM roles and permissions that allow Amazon Managed Grafana to read data from these
        /// sources. You must still add them as data sources in the Grafana console in the
        /// workspace.</p>
        /// <p>If you don't specify a data source here, you can still add it as a data source in the
        /// workspace console later. However, you will then have to manually configure permissions for
        /// it.</p>
        pub fn set_workspace_data_sources(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DataSourceType>>,
        ) -> Self {
            self.inner = self.inner.set_workspace_data_sources(input);
            self
        }
        /// <p>A description for the workspace. This is used only to help you identify this workspace.</p>
        pub fn workspace_description(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.workspace_description(inp);
            self
        }
        /// <p>A description for the workspace. This is used only to help you identify this workspace.</p>
        pub fn set_workspace_description(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_workspace_description(input);
            self
        }
        /// <p>The name for the workspace. It does not have to be unique.</p>
        pub fn workspace_name(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.workspace_name(inp);
            self
        }
        /// <p>The name for the workspace. It does not have to be unique.</p>
        pub fn set_workspace_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_workspace_name(input);
            self
        }
        /// Appends an item to `workspaceNotificationDestinations`.
        ///
        /// To override the contents of this collection use [`set_workspace_notification_destinations`](Self::set_workspace_notification_destinations).
        ///
        /// <p>Specify the Amazon Web Services notification channels that you plan to use in this workspace. Specifying these
        /// data sources here enables Amazon Managed Grafana to create IAM roles and permissions that allow
        /// Amazon Managed Grafana to use these channels.</p>
        pub fn workspace_notification_destinations(
            mut self,
            inp: impl Into<crate::model::NotificationDestinationType>,
        ) -> Self {
            self.inner = self.inner.workspace_notification_destinations(inp);
            self
        }
        /// <p>Specify the Amazon Web Services notification channels that you plan to use in this workspace. Specifying these
        /// data sources here enables Amazon Managed Grafana to create IAM roles and permissions that allow
        /// Amazon Managed Grafana to use these channels.</p>
        pub fn set_workspace_notification_destinations(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::NotificationDestinationType>>,
        ) -> Self {
            self.inner = self.inner.set_workspace_notification_destinations(input);
            self
        }
        /// Appends an item to `workspaceOrganizationalUnits`.
        ///
        /// To override the contents of this collection use [`set_workspace_organizational_units`](Self::set_workspace_organizational_units).
        ///
        /// <p>Specifies the organizational units that this workspace is allowed to use data sources
        /// from, if this workspace is in an account that is part of an organization.</p>
        pub fn workspace_organizational_units(
            mut self,
            inp: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.workspace_organizational_units(inp);
            self
        }
        /// <p>Specifies the organizational units that this workspace is allowed to use data sources
        /// from, if this workspace is in an account that is part of an organization.</p>
        pub fn set_workspace_organizational_units(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.inner = self.inner.set_workspace_organizational_units(input);
            self
        }
        /// <p>The workspace needs an IAM role that grants permissions to the Amazon Web Services resources that the
        /// workspace will view data from. If you already have a role that you want to use, specify it here. If you omit
        /// this field and you specify some Amazon Web Services resources in <code>workspaceDataSources</code> or
        /// <code>workspaceNotificationDestinations</code>, a new IAM role with the necessary permissions is
        /// automatically created.</p>
        pub fn workspace_role_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.workspace_role_arn(inp);
            self
        }
        /// <p>The workspace needs an IAM role that grants permissions to the Amazon Web Services resources that the
        /// workspace will view data from. If you already have a role that you want to use, specify it here. If you omit
        /// this field and you specify some Amazon Web Services resources in <code>workspaceDataSources</code> or
        /// <code>workspaceNotificationDestinations</code>, a new IAM role with the necessary permissions is
        /// automatically created.</p>
        pub fn set_workspace_role_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_workspace_role_arn(input);
            self
        }
        /// Appends an item to `authenticationProviders`.
        ///
        /// To override the contents of this collection use [`set_authentication_providers`](Self::set_authentication_providers).
        ///
        /// <p>Specifies whether this workspace uses SAML 2.0, Amazon Web Services Single Sign On, or both to authenticate
        /// users for using the Grafana console within a workspace. For more information,
        /// see <a href="https://docs.aws.amazon.com/grafana/latest/userguide/authentication-in-AMG.html">User authentication in
        /// Amazon Managed Grafana</a>.</p>
        pub fn authentication_providers(
            mut self,
            inp: impl Into<crate::model::AuthenticationProviderTypes>,
        ) -> Self {
            self.inner = self.inner.authentication_providers(inp);
            self
        }
        /// <p>Specifies whether this workspace uses SAML 2.0, Amazon Web Services Single Sign On, or both to authenticate
        /// users for using the Grafana console within a workspace. For more information,
        /// see <a href="https://docs.aws.amazon.com/grafana/latest/userguide/authentication-in-AMG.html">User authentication in
        /// Amazon Managed Grafana</a>.</p>
        pub fn set_authentication_providers(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::AuthenticationProviderTypes>>,
        ) -> Self {
            self.inner = self.inner.set_authentication_providers(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DeleteWorkspace`.
    ///
    /// <p>Deletes an Amazon Managed Grafana workspace.</p>
    #[derive(std::fmt::Debug)]
    pub struct DeleteWorkspace<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::delete_workspace_input::Builder,
    }
    impl<C, M, R> DeleteWorkspace<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `DeleteWorkspace`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::DeleteWorkspaceOutput,
            aws_smithy_http::result::SdkError<crate::error::DeleteWorkspaceError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::DeleteWorkspaceInputOperationOutputAlias,
                crate::output::DeleteWorkspaceOutput,
                crate::error::DeleteWorkspaceError,
                crate::input::DeleteWorkspaceInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The ID of the workspace to delete.</p>
        pub fn workspace_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.workspace_id(inp);
            self
        }
        /// <p>The ID of the workspace to delete.</p>
        pub fn set_workspace_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_workspace_id(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DescribeWorkspace`.
    ///
    /// <p>Displays information about one Amazon Managed Grafana workspace.</p>
    #[derive(std::fmt::Debug)]
    pub struct DescribeWorkspace<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::describe_workspace_input::Builder,
    }
    impl<C, M, R> DescribeWorkspace<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `DescribeWorkspace`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::DescribeWorkspaceOutput,
            aws_smithy_http::result::SdkError<crate::error::DescribeWorkspaceError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::DescribeWorkspaceInputOperationOutputAlias,
                crate::output::DescribeWorkspaceOutput,
                crate::error::DescribeWorkspaceError,
                crate::input::DescribeWorkspaceInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The ID of the workspace to display information about.</p>
        pub fn workspace_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.workspace_id(inp);
            self
        }
        /// <p>The ID of the workspace to display information about.</p>
        pub fn set_workspace_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_workspace_id(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DescribeWorkspaceAuthentication`.
    ///
    /// <p>Displays information about the authentication methods used in one Amazon Managed Grafana workspace.</p>
    #[derive(std::fmt::Debug)]
    pub struct DescribeWorkspaceAuthentication<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::describe_workspace_authentication_input::Builder,
    }
    impl<C, M, R> DescribeWorkspaceAuthentication<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `DescribeWorkspaceAuthentication`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::DescribeWorkspaceAuthenticationOutput,
            aws_smithy_http::result::SdkError<crate::error::DescribeWorkspaceAuthenticationError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::DescribeWorkspaceAuthenticationInputOperationOutputAlias,
                crate::output::DescribeWorkspaceAuthenticationOutput,
                crate::error::DescribeWorkspaceAuthenticationError,
                crate::input::DescribeWorkspaceAuthenticationInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The ID of the workspace to return authentication information about.</p>
        pub fn workspace_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.workspace_id(inp);
            self
        }
        /// <p>The ID of the workspace to return authentication information about.</p>
        pub fn set_workspace_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_workspace_id(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DisassociateLicense`.
    ///
    /// <p>Removes the Grafana Enterprise license from a workspace.</p>
    #[derive(std::fmt::Debug)]
    pub struct DisassociateLicense<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::disassociate_license_input::Builder,
    }
    impl<C, M, R> DisassociateLicense<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `DisassociateLicense`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::DisassociateLicenseOutput,
            aws_smithy_http::result::SdkError<crate::error::DisassociateLicenseError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::DisassociateLicenseInputOperationOutputAlias,
                crate::output::DisassociateLicenseOutput,
                crate::error::DisassociateLicenseError,
                crate::input::DisassociateLicenseInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The ID of the workspace to remove the Grafana Enterprise license from.</p>
        pub fn workspace_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.workspace_id(inp);
            self
        }
        /// <p>The ID of the workspace to remove the Grafana Enterprise license from.</p>
        pub fn set_workspace_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_workspace_id(input);
            self
        }
        /// <p>The type of license to remove from the workspace.</p>
        pub fn license_type(mut self, inp: crate::model::LicenseType) -> Self {
            self.inner = self.inner.license_type(inp);
            self
        }
        /// <p>The type of license to remove from the workspace.</p>
        pub fn set_license_type(
            mut self,
            input: std::option::Option<crate::model::LicenseType>,
        ) -> Self {
            self.inner = self.inner.set_license_type(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ListPermissions`.
    ///
    /// <p>Lists the users and groups who have the Grafana <code>Admin</code> and
    /// <code>Editor</code> roles in this workspace. If you use this
    /// operation without specifying <code>userId</code> or <code>groupId</code>, the operation returns
    /// the roles of all users
    /// and groups. If you specify a <code>userId</code> or a <code>groupId</code>, only the roles
    /// for that user or group are returned. If you do this, you can specify only one <code>userId</code> or
    /// one <code>groupId</code>.</p>
    #[derive(std::fmt::Debug)]
    pub struct ListPermissions<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::list_permissions_input::Builder,
    }
    impl<C, M, R> ListPermissions<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `ListPermissions`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::ListPermissionsOutput,
            aws_smithy_http::result::SdkError<crate::error::ListPermissionsError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListPermissionsInputOperationOutputAlias,
                crate::output::ListPermissionsOutput,
                crate::error::ListPermissionsError,
                crate::input::ListPermissionsInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The maximum number of results to include in the response.</p>
        pub fn max_results(mut self, inp: i32) -> Self {
            self.inner = self.inner.max_results(inp);
            self
        }
        /// <p>The maximum number of results to include in the response.</p>
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
        /// <p>The token to use when requesting the next set of results. You received this token from a previous
        /// <code>ListPermissions</code> operation.</p>
        pub fn next_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(inp);
            self
        }
        /// <p>The token to use when requesting the next set of results. You received this token from a previous
        /// <code>ListPermissions</code> operation.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_next_token(input);
            self
        }
        /// <p>(Optional) If you specify <code>SSO_USER</code>, then only the permissions of Amazon Web Services SSO users
        /// are returned. If you specify <code>SSO_GROUP</code>, only the permissions of Amazon Web Services SSO groups
        /// are returned.</p>
        pub fn user_type(mut self, inp: crate::model::UserType) -> Self {
            self.inner = self.inner.user_type(inp);
            self
        }
        /// <p>(Optional) If you specify <code>SSO_USER</code>, then only the permissions of Amazon Web Services SSO users
        /// are returned. If you specify <code>SSO_GROUP</code>, only the permissions of Amazon Web Services SSO groups
        /// are returned.</p>
        pub fn set_user_type(mut self, input: std::option::Option<crate::model::UserType>) -> Self {
            self.inner = self.inner.set_user_type(input);
            self
        }
        /// <p>(Optional) Limits the results to only the user that matches this ID.</p>
        pub fn user_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.user_id(inp);
            self
        }
        /// <p>(Optional) Limits the results to only the user that matches this ID.</p>
        pub fn set_user_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_user_id(input);
            self
        }
        /// <p>(Optional) Limits the results to only the group that matches this ID.</p>
        pub fn group_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.group_id(inp);
            self
        }
        /// <p>(Optional) Limits the results to only the group that matches this ID.</p>
        pub fn set_group_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_group_id(input);
            self
        }
        /// <p>The ID of the workspace to list permissions for. This parameter is required.</p>
        pub fn workspace_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.workspace_id(inp);
            self
        }
        /// <p>The ID of the workspace to list permissions for. This parameter is required.</p>
        pub fn set_workspace_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_workspace_id(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ListWorkspaces`.
    ///
    /// <p>Returns a list of Amazon Managed Grafana workspaces in the account, with some information
    /// about each workspace. For more complete information about one workspace, use <a href="https://docs.aws.amazon.com/AAMG/latest/APIReference/API_DescribeWorkspace.html">DescribeWorkspace</a>.</p>
    #[derive(std::fmt::Debug)]
    pub struct ListWorkspaces<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::list_workspaces_input::Builder,
    }
    impl<C, M, R> ListWorkspaces<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `ListWorkspaces`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::ListWorkspacesOutput,
            aws_smithy_http::result::SdkError<crate::error::ListWorkspacesError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListWorkspacesInputOperationOutputAlias,
                crate::output::ListWorkspacesOutput,
                crate::error::ListWorkspacesError,
                crate::input::ListWorkspacesInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The maximum number of workspaces to include in the results.</p>
        pub fn max_results(mut self, inp: i32) -> Self {
            self.inner = self.inner.max_results(inp);
            self
        }
        /// <p>The maximum number of workspaces to include in the results.</p>
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
        /// <p>The token for the next set of workspaces to return. (You receive this token from a
        /// previous <code>ListWorkspaces</code> operation.)</p>
        pub fn next_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(inp);
            self
        }
        /// <p>The token for the next set of workspaces to return. (You receive this token from a
        /// previous <code>ListWorkspaces</code> operation.)</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_next_token(input);
            self
        }
    }
    /// Fluent builder constructing a request to `UpdatePermissions`.
    ///
    /// <p>Updates which users in a workspace have the Grafana <code>Admin</code> or <code>Editor</code> roles.</p>
    #[derive(std::fmt::Debug)]
    pub struct UpdatePermissions<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::update_permissions_input::Builder,
    }
    impl<C, M, R> UpdatePermissions<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `UpdatePermissions`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::UpdatePermissionsOutput,
            aws_smithy_http::result::SdkError<crate::error::UpdatePermissionsError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::UpdatePermissionsInputOperationOutputAlias,
                crate::output::UpdatePermissionsOutput,
                crate::error::UpdatePermissionsError,
                crate::input::UpdatePermissionsInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// Appends an item to `updateInstructionBatch`.
        ///
        /// To override the contents of this collection use [`set_update_instruction_batch`](Self::set_update_instruction_batch).
        ///
        /// <p>An array of structures that contain the permission updates to make.</p>
        pub fn update_instruction_batch(
            mut self,
            inp: impl Into<crate::model::UpdateInstruction>,
        ) -> Self {
            self.inner = self.inner.update_instruction_batch(inp);
            self
        }
        /// <p>An array of structures that contain the permission updates to make.</p>
        pub fn set_update_instruction_batch(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::UpdateInstruction>>,
        ) -> Self {
            self.inner = self.inner.set_update_instruction_batch(input);
            self
        }
        /// <p>The ID of the workspace to update.</p>
        pub fn workspace_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.workspace_id(inp);
            self
        }
        /// <p>The ID of the workspace to update.</p>
        pub fn set_workspace_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_workspace_id(input);
            self
        }
    }
    /// Fluent builder constructing a request to `UpdateWorkspace`.
    ///
    /// <p>Modifies an existing Amazon Managed Grafana workspace. If you use this operation and omit any
    /// optional parameters, the existing values of those parameters are not changed.</p>
    /// <p>To modify the user authentication methods that the workspace uses, such as SAML or Amazon Web Services SSO,
    /// use <a href="https://docs.aws.amazon.com/grafana/latest/APIReference/API_UpdateWorkspaceAuthentication.html">UpdateWorkspaceAuthentication</a>.</p>
    /// <p>To modify which users in the workspace have the <code>Admin</code> and <code>Editor</code> Grafana roles,
    /// use <a href="https://docs.aws.amazon.com/grafana/latest/APIReference/API_UpdatePermissions.html">UpdatePermissions</a>.</p>
    #[derive(std::fmt::Debug)]
    pub struct UpdateWorkspace<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::update_workspace_input::Builder,
    }
    impl<C, M, R> UpdateWorkspace<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `UpdateWorkspace`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::UpdateWorkspaceOutput,
            aws_smithy_http::result::SdkError<crate::error::UpdateWorkspaceError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::UpdateWorkspaceInputOperationOutputAlias,
                crate::output::UpdateWorkspaceOutput,
                crate::error::UpdateWorkspaceError,
                crate::input::UpdateWorkspaceInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>Specifies whether the workspace can access Amazon Web Services resources in this Amazon Web Services account only, or whether it can also access Amazon Web Services resources in
        /// other accounts in the same organization. If you specify <code>ORGANIZATION</code>, you must
        /// specify which organizational units the workspace can access in the
        /// <code>workspaceOrganizationalUnits</code> parameter.</p>
        pub fn account_access_type(mut self, inp: crate::model::AccountAccessType) -> Self {
            self.inner = self.inner.account_access_type(inp);
            self
        }
        /// <p>Specifies whether the workspace can access Amazon Web Services resources in this Amazon Web Services account only, or whether it can also access Amazon Web Services resources in
        /// other accounts in the same organization. If you specify <code>ORGANIZATION</code>, you must
        /// specify which organizational units the workspace can access in the
        /// <code>workspaceOrganizationalUnits</code> parameter.</p>
        pub fn set_account_access_type(
            mut self,
            input: std::option::Option<crate::model::AccountAccessType>,
        ) -> Self {
            self.inner = self.inner.set_account_access_type(input);
            self
        }
        /// <p>The name of an IAM role that already exists to use to access resources through Organizations.</p>
        pub fn organization_role_name(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.organization_role_name(inp);
            self
        }
        /// <p>The name of an IAM role that already exists to use to access resources through Organizations.</p>
        pub fn set_organization_role_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_organization_role_name(input);
            self
        }
        /// <p>If you specify <code>Service Managed</code>, Amazon Managed Grafana automatically creates
        /// the IAM roles and provisions the permissions that the workspace needs to use
        /// Amazon Web Services data sources and notification channels.</p>
        /// <p>If you specify <code>CUSTOMER_MANAGED</code>, you will manage those roles and
        /// permissions yourself. If you are creating this workspace in a member account of an
        /// organization and that account is not a delegated administrator account, and you want the workspace to access data sources in other Amazon Web Services
        /// accounts in the organization, you must choose <code>CUSTOMER_MANAGED</code>.</p>
        /// <p>For more information, see <a href="https://docs.aws.amazon.com/grafana/latest/userguide/AMG-manage-permissions.html">Amazon Managed Grafana permissions and policies for
        /// Amazon Web Services data sources and notification channels</a>
        /// </p>
        pub fn permission_type(mut self, inp: crate::model::PermissionType) -> Self {
            self.inner = self.inner.permission_type(inp);
            self
        }
        /// <p>If you specify <code>Service Managed</code>, Amazon Managed Grafana automatically creates
        /// the IAM roles and provisions the permissions that the workspace needs to use
        /// Amazon Web Services data sources and notification channels.</p>
        /// <p>If you specify <code>CUSTOMER_MANAGED</code>, you will manage those roles and
        /// permissions yourself. If you are creating this workspace in a member account of an
        /// organization and that account is not a delegated administrator account, and you want the workspace to access data sources in other Amazon Web Services
        /// accounts in the organization, you must choose <code>CUSTOMER_MANAGED</code>.</p>
        /// <p>For more information, see <a href="https://docs.aws.amazon.com/grafana/latest/userguide/AMG-manage-permissions.html">Amazon Managed Grafana permissions and policies for
        /// Amazon Web Services data sources and notification channels</a>
        /// </p>
        pub fn set_permission_type(
            mut self,
            input: std::option::Option<crate::model::PermissionType>,
        ) -> Self {
            self.inner = self.inner.set_permission_type(input);
            self
        }
        /// <p>The name of the CloudFormation stack set to use to generate IAM roles
        /// to be used for this workspace.</p>
        pub fn stack_set_name(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.stack_set_name(inp);
            self
        }
        /// <p>The name of the CloudFormation stack set to use to generate IAM roles
        /// to be used for this workspace.</p>
        pub fn set_stack_set_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_stack_set_name(input);
            self
        }
        /// Appends an item to `workspaceDataSources`.
        ///
        /// To override the contents of this collection use [`set_workspace_data_sources`](Self::set_workspace_data_sources).
        ///
        /// <p>Specify the Amazon Web Services data sources that you want to be queried in this
        /// workspace. Specifying these data sources here enables Amazon Managed Grafana to create IAM roles and permissions that allow Amazon Managed Grafana to read data from these
        /// sources. You must still add them as data sources in the Grafana console in the
        /// workspace.</p>
        /// <p>If you don't specify a data source here, you can still add it as a data source later in
        /// the workspace console. However, you will then have to manually configure permissions for
        /// it.</p>
        pub fn workspace_data_sources(
            mut self,
            inp: impl Into<crate::model::DataSourceType>,
        ) -> Self {
            self.inner = self.inner.workspace_data_sources(inp);
            self
        }
        /// <p>Specify the Amazon Web Services data sources that you want to be queried in this
        /// workspace. Specifying these data sources here enables Amazon Managed Grafana to create IAM roles and permissions that allow Amazon Managed Grafana to read data from these
        /// sources. You must still add them as data sources in the Grafana console in the
        /// workspace.</p>
        /// <p>If you don't specify a data source here, you can still add it as a data source later in
        /// the workspace console. However, you will then have to manually configure permissions for
        /// it.</p>
        pub fn set_workspace_data_sources(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DataSourceType>>,
        ) -> Self {
            self.inner = self.inner.set_workspace_data_sources(input);
            self
        }
        /// <p>A description for the workspace. This is used only to help you identify this workspace.</p>
        pub fn workspace_description(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.workspace_description(inp);
            self
        }
        /// <p>A description for the workspace. This is used only to help you identify this workspace.</p>
        pub fn set_workspace_description(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_workspace_description(input);
            self
        }
        /// <p>The ID of the workspace to update.</p>
        pub fn workspace_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.workspace_id(inp);
            self
        }
        /// <p>The ID of the workspace to update.</p>
        pub fn set_workspace_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_workspace_id(input);
            self
        }
        /// <p>A new name for the workspace to update.</p>
        pub fn workspace_name(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.workspace_name(inp);
            self
        }
        /// <p>A new name for the workspace to update.</p>
        pub fn set_workspace_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_workspace_name(input);
            self
        }
        /// Appends an item to `workspaceNotificationDestinations`.
        ///
        /// To override the contents of this collection use [`set_workspace_notification_destinations`](Self::set_workspace_notification_destinations).
        ///
        /// <p>Specify the Amazon Web Services notification channels that you plan to use in this workspace. Specifying these
        /// data sources here enables Amazon Managed Grafana to create IAM roles and permissions that allow
        /// Amazon Managed Grafana to use these channels.</p>
        pub fn workspace_notification_destinations(
            mut self,
            inp: impl Into<crate::model::NotificationDestinationType>,
        ) -> Self {
            self.inner = self.inner.workspace_notification_destinations(inp);
            self
        }
        /// <p>Specify the Amazon Web Services notification channels that you plan to use in this workspace. Specifying these
        /// data sources here enables Amazon Managed Grafana to create IAM roles and permissions that allow
        /// Amazon Managed Grafana to use these channels.</p>
        pub fn set_workspace_notification_destinations(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::NotificationDestinationType>>,
        ) -> Self {
            self.inner = self.inner.set_workspace_notification_destinations(input);
            self
        }
        /// Appends an item to `workspaceOrganizationalUnits`.
        ///
        /// To override the contents of this collection use [`set_workspace_organizational_units`](Self::set_workspace_organizational_units).
        ///
        /// <p>Specifies the organizational units that this workspace is allowed to use data sources
        /// from, if this workspace is in an account that is part of an organization.</p>
        pub fn workspace_organizational_units(
            mut self,
            inp: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.workspace_organizational_units(inp);
            self
        }
        /// <p>Specifies the organizational units that this workspace is allowed to use data sources
        /// from, if this workspace is in an account that is part of an organization.</p>
        pub fn set_workspace_organizational_units(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.inner = self.inner.set_workspace_organizational_units(input);
            self
        }
        /// <p>The workspace needs an IAM role that grants permissions to the Amazon Web Services resources that the
        /// workspace will view data from. If you already have a role that you want to use, specify it here. If you omit
        /// this field and you specify some Amazon Web Services resources in <code>workspaceDataSources</code> or
        /// <code>workspaceNotificationDestinations</code>, a new IAM role with the necessary permissions is
        /// automatically created.</p>
        pub fn workspace_role_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.workspace_role_arn(inp);
            self
        }
        /// <p>The workspace needs an IAM role that grants permissions to the Amazon Web Services resources that the
        /// workspace will view data from. If you already have a role that you want to use, specify it here. If you omit
        /// this field and you specify some Amazon Web Services resources in <code>workspaceDataSources</code> or
        /// <code>workspaceNotificationDestinations</code>, a new IAM role with the necessary permissions is
        /// automatically created.</p>
        pub fn set_workspace_role_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_workspace_role_arn(input);
            self
        }
    }
    /// Fluent builder constructing a request to `UpdateWorkspaceAuthentication`.
    ///
    /// <p>Use this operation to define the identity provider (IdP) that this workspace
    /// authenticates users from, using SAML. You can also map SAML assertion attributes to
    /// workspace user information and define which groups in the assertion attribute are to have
    /// the <code>Admin</code> and <code>Editor</code> roles in the workspace.</p>
    #[derive(std::fmt::Debug)]
    pub struct UpdateWorkspaceAuthentication<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::update_workspace_authentication_input::Builder,
    }
    impl<C, M, R> UpdateWorkspaceAuthentication<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `UpdateWorkspaceAuthentication`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::UpdateWorkspaceAuthenticationOutput,
            aws_smithy_http::result::SdkError<crate::error::UpdateWorkspaceAuthenticationError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::UpdateWorkspaceAuthenticationInputOperationOutputAlias,
                crate::output::UpdateWorkspaceAuthenticationOutput,
                crate::error::UpdateWorkspaceAuthenticationError,
                crate::input::UpdateWorkspaceAuthenticationInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The ID of the workspace to update the authentication for.</p>
        pub fn workspace_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.workspace_id(inp);
            self
        }
        /// <p>The ID of the workspace to update the authentication for.</p>
        pub fn set_workspace_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_workspace_id(input);
            self
        }
        /// Appends an item to `authenticationProviders`.
        ///
        /// To override the contents of this collection use [`set_authentication_providers`](Self::set_authentication_providers).
        ///
        /// <p>Specifies whether this workspace uses SAML 2.0, Amazon Web Services Single Sign On, or both to authenticate
        /// users for using the Grafana console within a workspace. For more information,
        /// see <a href="https://docs.aws.amazon.com/grafana/latest/userguide/authentication-in-AMG.html">User authentication in
        /// Amazon Managed Grafana</a>.</p>
        pub fn authentication_providers(
            mut self,
            inp: impl Into<crate::model::AuthenticationProviderTypes>,
        ) -> Self {
            self.inner = self.inner.authentication_providers(inp);
            self
        }
        /// <p>Specifies whether this workspace uses SAML 2.0, Amazon Web Services Single Sign On, or both to authenticate
        /// users for using the Grafana console within a workspace. For more information,
        /// see <a href="https://docs.aws.amazon.com/grafana/latest/userguide/authentication-in-AMG.html">User authentication in
        /// Amazon Managed Grafana</a>.</p>
        pub fn set_authentication_providers(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::AuthenticationProviderTypes>>,
        ) -> Self {
            self.inner = self.inner.set_authentication_providers(input);
            self
        }
        /// <p>If the workspace uses SAML, use this structure to
        /// map SAML assertion attributes to workspace user information and
        /// define which groups in the assertion attribute are to have the <code>Admin</code> and <code>Editor</code> roles
        /// in the workspace.</p>
        pub fn saml_configuration(mut self, inp: crate::model::SamlConfiguration) -> Self {
            self.inner = self.inner.saml_configuration(inp);
            self
        }
        /// <p>If the workspace uses SAML, use this structure to
        /// map SAML assertion attributes to workspace user information and
        /// define which groups in the assertion attribute are to have the <code>Admin</code> and <code>Editor</code> roles
        /// in the workspace.</p>
        pub fn set_saml_configuration(
            mut self,
            input: std::option::Option<crate::model::SamlConfiguration>,
        ) -> Self {
            self.inner = self.inner.set_saml_configuration(input);
            self
        }
    }
}
impl<C> Client<C, aws_hyper::AwsMiddleware, aws_smithy_client::retry::Standard> {
    /// Creates a client with the given service config and connector override.
    pub fn from_conf_conn(conf: crate::Config, conn: C) -> Self {
        let retry_config = conf.retry_config.as_ref().cloned().unwrap_or_default();
        let client = aws_hyper::Client::new(conn).with_retry_config(retry_config.into());
        Self {
            handle: std::sync::Arc::new(Handle { client, conf }),
        }
    }
}
impl
    Client<
        aws_smithy_client::erase::DynConnector,
        aws_hyper::AwsMiddleware,
        aws_smithy_client::retry::Standard,
    >
{
    /// Creates a new client from a shared config.
    #[cfg(any(feature = "rustls", feature = "native-tls"))]
    pub fn new(config: &aws_types::config::Config) -> Self {
        Self::from_conf(config.into())
    }

    /// Creates a new client from the service [`Config`](crate::Config).
    #[cfg(any(feature = "rustls", feature = "native-tls"))]
    pub fn from_conf(conf: crate::Config) -> Self {
        let retry_config = conf.retry_config.as_ref().cloned().unwrap_or_default();
        let client = aws_hyper::Client::https().with_retry_config(retry_config.into());
        Self {
            handle: std::sync::Arc::new(Handle { client, conf }),
        }
    }
}