aws-sdk-simspaceweaver 0.2.0

AWS SDK for AWS SimSpace Weaver
Documentation
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[derive(Debug)]
pub(crate) struct Handle {
    pub(crate) client: aws_smithy_client::Client<
        aws_smithy_client::erase::DynConnector,
        aws_smithy_client::erase::DynMiddleware<aws_smithy_client::erase::DynConnector>,
    >,
    pub(crate) conf: crate::Config,
}

/// Client for AWS SimSpace Weaver
///
/// Client for invoking operations on AWS SimSpace Weaver. Each operation on AWS SimSpace Weaver is a method on this
/// this struct. `.send()` MUST be invoked on the generated operations to dispatch the request to the service.
///
/// # Examples
/// **Constructing a client and invoking an operation**
/// ```rust,no_run
/// # async fn docs() {
///     // create a shared configuration. This can be used & shared between multiple service clients.
///     let shared_config = aws_config::load_from_env().await;
///     let client = aws_sdk_simspaceweaver::Client::new(&shared_config);
///     // invoke an operation
///     /* let rsp = client
///         .<operation_name>().
///         .<param>("some value")
///         .send().await; */
/// # }
/// ```
/// **Constructing a client with custom configuration**
/// ```rust,no_run
/// use aws_config::retry::RetryConfig;
/// # async fn docs() {
/// let shared_config = aws_config::load_from_env().await;
/// let config = aws_sdk_simspaceweaver::config::Builder::from(&shared_config)
///   .retry_config(RetryConfig::disabled())
///   .build();
/// let client = aws_sdk_simspaceweaver::Client::from_conf(config);
/// # }
#[derive(std::fmt::Debug)]
pub struct Client {
    handle: std::sync::Arc<Handle>,
}

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

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

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

impl Client {
    /// Creates a client with the given service configuration.
    pub fn with_config(
        client: aws_smithy_client::Client<
            aws_smithy_client::erase::DynConnector,
            aws_smithy_client::erase::DynMiddleware<aws_smithy_client::erase::DynConnector>,
        >,
        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 Client {
    /// Constructs a fluent builder for the [`DeleteApp`](crate::client::fluent_builders::DeleteApp) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`simulation(impl Into<String>)`](crate::client::fluent_builders::DeleteApp::simulation) / [`set_simulation(Option<String>)`](crate::client::fluent_builders::DeleteApp::set_simulation): <p>The name of the simulation of the app.</p>
    ///   - [`domain(impl Into<String>)`](crate::client::fluent_builders::DeleteApp::domain) / [`set_domain(Option<String>)`](crate::client::fluent_builders::DeleteApp::set_domain): <p>The name of the domain of the app.</p>
    ///   - [`app(impl Into<String>)`](crate::client::fluent_builders::DeleteApp::app) / [`set_app(Option<String>)`](crate::client::fluent_builders::DeleteApp::set_app): <p>The name of the app.</p>
    /// - On success, responds with [`DeleteAppOutput`](crate::output::DeleteAppOutput)

    /// - On failure, responds with [`SdkError<DeleteAppError>`](crate::error::DeleteAppError)
    pub fn delete_app(&self) -> fluent_builders::DeleteApp {
        fluent_builders::DeleteApp::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`DeleteSimulation`](crate::client::fluent_builders::DeleteSimulation) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`simulation(impl Into<String>)`](crate::client::fluent_builders::DeleteSimulation::simulation) / [`set_simulation(Option<String>)`](crate::client::fluent_builders::DeleteSimulation::set_simulation): <p>The name of the simulation.</p>
    /// - On success, responds with [`DeleteSimulationOutput`](crate::output::DeleteSimulationOutput)

    /// - On failure, responds with [`SdkError<DeleteSimulationError>`](crate::error::DeleteSimulationError)
    pub fn delete_simulation(&self) -> fluent_builders::DeleteSimulation {
        fluent_builders::DeleteSimulation::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`DescribeApp`](crate::client::fluent_builders::DescribeApp) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`simulation(impl Into<String>)`](crate::client::fluent_builders::DescribeApp::simulation) / [`set_simulation(Option<String>)`](crate::client::fluent_builders::DescribeApp::set_simulation): <p>The name of the simulation of the app.</p>
    ///   - [`domain(impl Into<String>)`](crate::client::fluent_builders::DescribeApp::domain) / [`set_domain(Option<String>)`](crate::client::fluent_builders::DescribeApp::set_domain): <p>The name of the domain of the app.</p>
    ///   - [`app(impl Into<String>)`](crate::client::fluent_builders::DescribeApp::app) / [`set_app(Option<String>)`](crate::client::fluent_builders::DescribeApp::set_app): <p>The name of the app.</p>
    /// - On success, responds with [`DescribeAppOutput`](crate::output::DescribeAppOutput) with field(s):
    ///   - [`name(Option<String>)`](crate::output::DescribeAppOutput::name): <p>The name of the app.</p>
    ///   - [`simulation(Option<String>)`](crate::output::DescribeAppOutput::simulation): <p>The name of the simulation of the app.</p>
    ///   - [`domain(Option<String>)`](crate::output::DescribeAppOutput::domain): <p>The name of the domain of the app.</p>
    ///   - [`status(Option<SimulationAppStatus>)`](crate::output::DescribeAppOutput::status): <p>The current lifecycle state of the custom app.</p>
    ///   - [`target_status(Option<SimulationAppTargetStatus>)`](crate::output::DescribeAppOutput::target_status): <p>The desired lifecycle state of the custom app.</p>
    ///   - [`launch_overrides(Option<LaunchOverrides>)`](crate::output::DescribeAppOutput::launch_overrides): <p>Options that apply when the app starts. These optiAons override default behavior.</p>
    ///   - [`description(Option<String>)`](crate::output::DescribeAppOutput::description): <p>The description of the app.</p>
    ///   - [`endpoint_info(Option<SimulationAppEndpointInfo>)`](crate::output::DescribeAppOutput::endpoint_info): <p>Information about the network endpoint for the custom app. You can use the endpoint to connect to the custom app.</p>
    /// - On failure, responds with [`SdkError<DescribeAppError>`](crate::error::DescribeAppError)
    pub fn describe_app(&self) -> fluent_builders::DescribeApp {
        fluent_builders::DescribeApp::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`DescribeSimulation`](crate::client::fluent_builders::DescribeSimulation) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`simulation(impl Into<String>)`](crate::client::fluent_builders::DescribeSimulation::simulation) / [`set_simulation(Option<String>)`](crate::client::fluent_builders::DescribeSimulation::set_simulation): <p>The name of the simulation.</p>
    /// - On success, responds with [`DescribeSimulationOutput`](crate::output::DescribeSimulationOutput) with field(s):
    ///   - [`name(Option<String>)`](crate::output::DescribeSimulationOutput::name): <p>The name of the simulation.</p>
    ///   - [`execution_id(Option<String>)`](crate::output::DescribeSimulationOutput::execution_id): <p>A universally unique identifier (UUID) for this simulation.</p>
    ///   - [`arn(Option<String>)`](crate::output::DescribeSimulationOutput::arn): <p>The Amazon Resource Name (ARN) of the simulation. For more information about ARNs, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon Resource Names (ARNs)</a> in the <i>Amazon Web Services General Reference</i>.</p>
    ///   - [`description(Option<String>)`](crate::output::DescribeSimulationOutput::description): <p>The description of the simulation.</p>
    ///   - [`role_arn(Option<String>)`](crate::output::DescribeSimulationOutput::role_arn): <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that the simulation assumes to perform actions. For more information about ARNs, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon Resource Names (ARNs)</a> in the <i>Amazon Web Services General Reference</i>. For more information about IAM roles, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html">IAM roles</a> in the <i>Identity and Access Management User Guide</i>.</p>
    ///   - [`creation_time(Option<DateTime>)`](crate::output::DescribeSimulationOutput::creation_time): <p>The time when the simulation was created, expressed as the number of seconds and milliseconds in UTC since the Unix epoch (0:0:0.000, January 1, 1970).</p>
    ///   - [`status(Option<SimulationStatus>)`](crate::output::DescribeSimulationOutput::status): <p>The current lifecycle state of the simulation.</p>
    ///   - [`target_status(Option<SimulationTargetStatus>)`](crate::output::DescribeSimulationOutput::target_status): <p>The desired lifecycle state of the simulation.</p>
    ///   - [`schema_s3_location(Option<S3Location>)`](crate::output::DescribeSimulationOutput::schema_s3_location): <p>The location of the simulation schema in Amazon Simple Storage Service (Amazon S3). For more information about Amazon S3, see the <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html"> <i>Amazon Simple Storage Service User Guide</i> </a>.</p>
    ///   - [`schema_error(Option<String>)`](crate::output::DescribeSimulationOutput::schema_error): <p>An error message that SimSpace Weaver returns only if there is a problem with the simulation schema.</p>
    ///   - [`logging_configuration(Option<LoggingConfiguration>)`](crate::output::DescribeSimulationOutput::logging_configuration): <p>Settings that control how SimSpace Weaver handles your simulation log data.</p>
    ///   - [`live_simulation_state(Option<LiveSimulationState>)`](crate::output::DescribeSimulationOutput::live_simulation_state): <p>A collection of additional state information, such as domain and clock configuration.</p>
    ///   - [`maximum_duration(Option<String>)`](crate::output::DescribeSimulationOutput::maximum_duration): <p>The maximum running time of the simulation, specified as a number of months (m or M), hours (h or H), or days (d or D). The simulation stops when it reaches this limit.</p>
    /// - On failure, responds with [`SdkError<DescribeSimulationError>`](crate::error::DescribeSimulationError)
    pub fn describe_simulation(&self) -> fluent_builders::DescribeSimulation {
        fluent_builders::DescribeSimulation::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`ListApps`](crate::client::fluent_builders::ListApps) operation.
    /// This operation supports pagination; See [`into_paginator()`](crate::client::fluent_builders::ListApps::into_paginator).
    ///
    /// - The fluent builder is configurable:
    ///   - [`simulation(impl Into<String>)`](crate::client::fluent_builders::ListApps::simulation) / [`set_simulation(Option<String>)`](crate::client::fluent_builders::ListApps::set_simulation): <p>The name of the simulation that you want to list apps for.</p>
    ///   - [`domain(impl Into<String>)`](crate::client::fluent_builders::ListApps::domain) / [`set_domain(Option<String>)`](crate::client::fluent_builders::ListApps::set_domain): <p>The name of the domain that you want to list apps for.</p>
    ///   - [`max_results(i32)`](crate::client::fluent_builders::ListApps::max_results) / [`set_max_results(Option<i32>)`](crate::client::fluent_builders::ListApps::set_max_results): <p>The maximum number of apps to list.</p>
    ///   - [`next_token(impl Into<String>)`](crate::client::fluent_builders::ListApps::next_token) / [`set_next_token(Option<String>)`](crate::client::fluent_builders::ListApps::set_next_token): <p>If SimSpace Weaver returns <code>nextToken</code>, there are more results available. The value of <code>nextToken</code> is a unique pagination token for each page. To retrieve the next page, call the operation again using the returned token. Keep all other arguments unchanged. If no results remain, <code>nextToken</code> is set to <code>null</code>. Each pagination token expires after 24 hours. If you provide a token that isn't valid, you receive an <i>HTTP 400 ValidationException</i> error.</p>
    /// - On success, responds with [`ListAppsOutput`](crate::output::ListAppsOutput) with field(s):
    ///   - [`apps(Option<Vec<SimulationAppMetadata>>)`](crate::output::ListAppsOutput::apps): <p>The list of apps for the given simulation and domain.</p>
    ///   - [`next_token(Option<String>)`](crate::output::ListAppsOutput::next_token): <p>If SimSpace Weaver returns <code>nextToken</code>, there are more results available. The value of <code>nextToken</code> is a unique pagination token for each page. To retrieve the next page, call the operation again using the returned token. Keep all other arguments unchanged. If no results remain, <code>nextToken</code> is set to <code>null</code>. Each pagination token expires after 24 hours. If you provide a token that isn't valid, you receive an <i>HTTP 400 ValidationException</i> error.</p>
    /// - On failure, responds with [`SdkError<ListAppsError>`](crate::error::ListAppsError)
    pub fn list_apps(&self) -> fluent_builders::ListApps {
        fluent_builders::ListApps::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`ListSimulations`](crate::client::fluent_builders::ListSimulations) operation.
    /// This operation supports pagination; See [`into_paginator()`](crate::client::fluent_builders::ListSimulations::into_paginator).
    ///
    /// - The fluent builder is configurable:
    ///   - [`max_results(i32)`](crate::client::fluent_builders::ListSimulations::max_results) / [`set_max_results(Option<i32>)`](crate::client::fluent_builders::ListSimulations::set_max_results): <p>The maximum number of simulations to list.</p>
    ///   - [`next_token(impl Into<String>)`](crate::client::fluent_builders::ListSimulations::next_token) / [`set_next_token(Option<String>)`](crate::client::fluent_builders::ListSimulations::set_next_token): <p>If SimSpace Weaver returns <code>nextToken</code>, there are more results available. The value of <code>nextToken</code> is a unique pagination token for each page. To retrieve the next page, call the operation again using the returned token. Keep all other arguments unchanged. If no results remain, <code>nextToken</code> is set to <code>null</code>. Each pagination token expires after 24 hours. If you provide a token that isn't valid, you receive an <i>HTTP 400 ValidationException</i> error.</p>
    /// - On success, responds with [`ListSimulationsOutput`](crate::output::ListSimulationsOutput) with field(s):
    ///   - [`simulations(Option<Vec<SimulationMetadata>>)`](crate::output::ListSimulationsOutput::simulations): <p>The list of simulations.</p>
    ///   - [`next_token(Option<String>)`](crate::output::ListSimulationsOutput::next_token): <p>If SimSpace Weaver returns <code>nextToken</code>, there are more results available. The value of <code>nextToken</code> is a unique pagination token for each page. To retrieve the next page, call the operation again using the returned token. Keep all other arguments unchanged. If no results remain, <code>nextToken</code> is set to <code>null</code>. Each pagination token expires after 24 hours. If you provide a token that isn't valid, you receive an <i>HTTP 400 ValidationException</i> error.</p>
    /// - On failure, responds with [`SdkError<ListSimulationsError>`](crate::error::ListSimulationsError)
    pub fn list_simulations(&self) -> fluent_builders::ListSimulations {
        fluent_builders::ListSimulations::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`ListTagsForResource`](crate::client::fluent_builders::ListTagsForResource) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`resource_arn(impl Into<String>)`](crate::client::fluent_builders::ListTagsForResource::resource_arn) / [`set_resource_arn(Option<String>)`](crate::client::fluent_builders::ListTagsForResource::set_resource_arn): <p>The Amazon Resource Name (ARN) of the resource. For more information about ARNs, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon Resource Names (ARNs)</a> in the <i>Amazon Web Services General Reference</i>.</p>
    /// - On success, responds with [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput) with field(s):
    ///   - [`tags(Option<HashMap<String, String>>)`](crate::output::ListTagsForResourceOutput::tags): <p>The list of tags for the resource.</p>
    /// - On failure, responds with [`SdkError<ListTagsForResourceError>`](crate::error::ListTagsForResourceError)
    pub fn list_tags_for_resource(&self) -> fluent_builders::ListTagsForResource {
        fluent_builders::ListTagsForResource::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`StartApp`](crate::client::fluent_builders::StartApp) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`client_token(impl Into<String>)`](crate::client::fluent_builders::StartApp::client_token) / [`set_client_token(Option<String>)`](crate::client::fluent_builders::StartApp::set_client_token): <p>A value that you provide to ensure that repeated calls to this API operation using the same parameters complete only once. A <code>ClientToken</code> is also known as an <i>idempotency token</i>. A <code>ClientToken</code> expires after 24 hours.</p>
    ///   - [`simulation(impl Into<String>)`](crate::client::fluent_builders::StartApp::simulation) / [`set_simulation(Option<String>)`](crate::client::fluent_builders::StartApp::set_simulation): <p>The name of the simulation of the app.</p>
    ///   - [`domain(impl Into<String>)`](crate::client::fluent_builders::StartApp::domain) / [`set_domain(Option<String>)`](crate::client::fluent_builders::StartApp::set_domain): <p>The name of the domain of the app.</p>
    ///   - [`name(impl Into<String>)`](crate::client::fluent_builders::StartApp::name) / [`set_name(Option<String>)`](crate::client::fluent_builders::StartApp::set_name): <p>The name of the app.</p>
    ///   - [`description(impl Into<String>)`](crate::client::fluent_builders::StartApp::description) / [`set_description(Option<String>)`](crate::client::fluent_builders::StartApp::set_description): <p>The description of the app.</p>
    ///   - [`launch_overrides(LaunchOverrides)`](crate::client::fluent_builders::StartApp::launch_overrides) / [`set_launch_overrides(Option<LaunchOverrides>)`](crate::client::fluent_builders::StartApp::set_launch_overrides): <p>Options that apply when the app starts. These optiAons override default behavior.</p>
    /// - On success, responds with [`StartAppOutput`](crate::output::StartAppOutput) with field(s):
    ///   - [`name(Option<String>)`](crate::output::StartAppOutput::name): <p>The name of the app.</p>
    ///   - [`domain(Option<String>)`](crate::output::StartAppOutput::domain): <p>The name of the domain of the app.</p>
    ///   - [`simulation(Option<String>)`](crate::output::StartAppOutput::simulation): <p>The name of the simulation of the app.</p>
    /// - On failure, responds with [`SdkError<StartAppError>`](crate::error::StartAppError)
    pub fn start_app(&self) -> fluent_builders::StartApp {
        fluent_builders::StartApp::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`StartClock`](crate::client::fluent_builders::StartClock) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`simulation(impl Into<String>)`](crate::client::fluent_builders::StartClock::simulation) / [`set_simulation(Option<String>)`](crate::client::fluent_builders::StartClock::set_simulation): <p>The name of the simulation.</p>
    /// - On success, responds with [`StartClockOutput`](crate::output::StartClockOutput)

    /// - On failure, responds with [`SdkError<StartClockError>`](crate::error::StartClockError)
    pub fn start_clock(&self) -> fluent_builders::StartClock {
        fluent_builders::StartClock::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`StartSimulation`](crate::client::fluent_builders::StartSimulation) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`client_token(impl Into<String>)`](crate::client::fluent_builders::StartSimulation::client_token) / [`set_client_token(Option<String>)`](crate::client::fluent_builders::StartSimulation::set_client_token): <p>A value that you provide to ensure that repeated calls to this API operation using the same parameters complete only once. A <code>ClientToken</code> is also known as an <i>idempotency token</i>. A <code>ClientToken</code> expires after 24 hours.</p>
    ///   - [`name(impl Into<String>)`](crate::client::fluent_builders::StartSimulation::name) / [`set_name(Option<String>)`](crate::client::fluent_builders::StartSimulation::set_name): <p>The name of the simulation.</p>
    ///   - [`description(impl Into<String>)`](crate::client::fluent_builders::StartSimulation::description) / [`set_description(Option<String>)`](crate::client::fluent_builders::StartSimulation::set_description): <p>The description of the simulation.</p>
    ///   - [`role_arn(impl Into<String>)`](crate::client::fluent_builders::StartSimulation::role_arn) / [`set_role_arn(Option<String>)`](crate::client::fluent_builders::StartSimulation::set_role_arn): <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that the simulation assumes to perform actions. For more information about ARNs, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon Resource Names (ARNs)</a> in the <i>Amazon Web Services General Reference</i>. For more information about IAM roles, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html">IAM roles</a> in the <i>Identity and Access Management User Guide</i>.</p>
    ///   - [`schema_s3_location(S3Location)`](crate::client::fluent_builders::StartSimulation::schema_s3_location) / [`set_schema_s3_location(Option<S3Location>)`](crate::client::fluent_builders::StartSimulation::set_schema_s3_location): <p>The location of the simulation schema in Amazon Simple Storage Service (Amazon S3). For more information about Amazon S3, see the <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html"> <i>Amazon Simple Storage Service User Guide</i> </a>.</p>
    ///   - [`maximum_duration(impl Into<String>)`](crate::client::fluent_builders::StartSimulation::maximum_duration) / [`set_maximum_duration(Option<String>)`](crate::client::fluent_builders::StartSimulation::set_maximum_duration): <p>The maximum running time of the simulation, specified as a number of months (m or M), hours (h or H), or days (d or D). The simulation stops when it reaches this limit.</p>
    ///   - [`tags(HashMap<String, String>)`](crate::client::fluent_builders::StartSimulation::tags) / [`set_tags(Option<HashMap<String, String>>)`](crate::client::fluent_builders::StartSimulation::set_tags): <p>A list of tags for the simulation. For more information about tags, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging Amazon Web Services resources</a> in the <i>Amazon Web Services General Reference</i>.</p>
    /// - On success, responds with [`StartSimulationOutput`](crate::output::StartSimulationOutput) with field(s):
    ///   - [`arn(Option<String>)`](crate::output::StartSimulationOutput::arn): <p>The Amazon Resource Name (ARN) of the simulation. For more information about ARNs, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon Resource Names (ARNs)</a> in the <i>Amazon Web Services General Reference</i>.</p>
    ///   - [`execution_id(Option<String>)`](crate::output::StartSimulationOutput::execution_id): <p>A universally unique identifier (UUID) for this simulation.</p>
    ///   - [`creation_time(Option<DateTime>)`](crate::output::StartSimulationOutput::creation_time): <p>The time when the simulation was created, expressed as the number of seconds and milliseconds in UTC since the Unix epoch (0:0:0.000, January 1, 1970).</p>
    /// - On failure, responds with [`SdkError<StartSimulationError>`](crate::error::StartSimulationError)
    pub fn start_simulation(&self) -> fluent_builders::StartSimulation {
        fluent_builders::StartSimulation::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`StopApp`](crate::client::fluent_builders::StopApp) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`simulation(impl Into<String>)`](crate::client::fluent_builders::StopApp::simulation) / [`set_simulation(Option<String>)`](crate::client::fluent_builders::StopApp::set_simulation): <p>The name of the simulation of the app.</p>
    ///   - [`domain(impl Into<String>)`](crate::client::fluent_builders::StopApp::domain) / [`set_domain(Option<String>)`](crate::client::fluent_builders::StopApp::set_domain): <p>The name of the domain of the app.</p>
    ///   - [`app(impl Into<String>)`](crate::client::fluent_builders::StopApp::app) / [`set_app(Option<String>)`](crate::client::fluent_builders::StopApp::set_app): <p>The name of the app.</p>
    /// - On success, responds with [`StopAppOutput`](crate::output::StopAppOutput)

    /// - On failure, responds with [`SdkError<StopAppError>`](crate::error::StopAppError)
    pub fn stop_app(&self) -> fluent_builders::StopApp {
        fluent_builders::StopApp::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`StopClock`](crate::client::fluent_builders::StopClock) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`simulation(impl Into<String>)`](crate::client::fluent_builders::StopClock::simulation) / [`set_simulation(Option<String>)`](crate::client::fluent_builders::StopClock::set_simulation): <p>The name of the simulation.</p>
    /// - On success, responds with [`StopClockOutput`](crate::output::StopClockOutput)

    /// - On failure, responds with [`SdkError<StopClockError>`](crate::error::StopClockError)
    pub fn stop_clock(&self) -> fluent_builders::StopClock {
        fluent_builders::StopClock::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`StopSimulation`](crate::client::fluent_builders::StopSimulation) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`simulation(impl Into<String>)`](crate::client::fluent_builders::StopSimulation::simulation) / [`set_simulation(Option<String>)`](crate::client::fluent_builders::StopSimulation::set_simulation): <p>The name of the simulation.</p>
    /// - On success, responds with [`StopSimulationOutput`](crate::output::StopSimulationOutput)

    /// - On failure, responds with [`SdkError<StopSimulationError>`](crate::error::StopSimulationError)
    pub fn stop_simulation(&self) -> fluent_builders::StopSimulation {
        fluent_builders::StopSimulation::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`TagResource`](crate::client::fluent_builders::TagResource) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`resource_arn(impl Into<String>)`](crate::client::fluent_builders::TagResource::resource_arn) / [`set_resource_arn(Option<String>)`](crate::client::fluent_builders::TagResource::set_resource_arn): <p>The Amazon Resource Name (ARN) of the resource that you want to add tags to. For more information about ARNs, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon Resource Names (ARNs)</a> in the <i>Amazon Web Services General Reference</i>.</p>
    ///   - [`tags(HashMap<String, String>)`](crate::client::fluent_builders::TagResource::tags) / [`set_tags(Option<HashMap<String, String>>)`](crate::client::fluent_builders::TagResource::set_tags): <p>A list of tags to apply to the resource.</p>
    /// - On success, responds with [`TagResourceOutput`](crate::output::TagResourceOutput)

    /// - On failure, responds with [`SdkError<TagResourceError>`](crate::error::TagResourceError)
    pub fn tag_resource(&self) -> fluent_builders::TagResource {
        fluent_builders::TagResource::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`UntagResource`](crate::client::fluent_builders::UntagResource) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`resource_arn(impl Into<String>)`](crate::client::fluent_builders::UntagResource::resource_arn) / [`set_resource_arn(Option<String>)`](crate::client::fluent_builders::UntagResource::set_resource_arn): <p>The Amazon Resource Name (ARN) of the resource that you want to remove tags from. For more information about ARNs, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon Resource Names (ARNs)</a> in the <i>Amazon Web Services General Reference</i>.</p>
    ///   - [`tag_keys(Vec<String>)`](crate::client::fluent_builders::UntagResource::tag_keys) / [`set_tag_keys(Option<Vec<String>>)`](crate::client::fluent_builders::UntagResource::set_tag_keys): <p>A list of tag keys to remove from the resource.</p>
    /// - On success, responds with [`UntagResourceOutput`](crate::output::UntagResourceOutput)

    /// - On failure, responds with [`SdkError<UntagResourceError>`](crate::error::UntagResourceError)
    pub fn untag_resource(&self) -> fluent_builders::UntagResource {
        fluent_builders::UntagResource::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 `DeleteApp`.
    ///
    /// <p>Deletes the instance of the given custom app.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct DeleteApp {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::delete_app_input::Builder,
    }
    impl DeleteApp {
        /// Creates a new `DeleteApp`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::DeleteApp,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::DeleteAppError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// 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::DeleteAppOutput,
            aws_smithy_http::result::SdkError<crate::error::DeleteAppError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The name of the simulation of the app.</p>
        pub fn simulation(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.simulation(input.into());
            self
        }
        /// <p>The name of the simulation of the app.</p>
        pub fn set_simulation(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_simulation(input);
            self
        }
        /// <p>The name of the domain of the app.</p>
        pub fn domain(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.domain(input.into());
            self
        }
        /// <p>The name of the domain of the app.</p>
        pub fn set_domain(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_domain(input);
            self
        }
        /// <p>The name of the app.</p>
        pub fn app(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.app(input.into());
            self
        }
        /// <p>The name of the app.</p>
        pub fn set_app(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_app(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DeleteSimulation`.
    ///
    /// <p>Deletes all SimSpace Weaver resources assigned to the given simulation.</p> <note>
    /// <p>Your simulation uses resources in other Amazon Web Services services. This API operation doesn't delete resources in other Amazon Web Services services.</p>
    /// </note>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct DeleteSimulation {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::delete_simulation_input::Builder,
    }
    impl DeleteSimulation {
        /// Creates a new `DeleteSimulation`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::DeleteSimulation,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::DeleteSimulationError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// 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::DeleteSimulationOutput,
            aws_smithy_http::result::SdkError<crate::error::DeleteSimulationError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The name of the simulation.</p>
        pub fn simulation(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.simulation(input.into());
            self
        }
        /// <p>The name of the simulation.</p>
        pub fn set_simulation(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_simulation(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DescribeApp`.
    ///
    /// <p>Returns the state of the given custom app.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct DescribeApp {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::describe_app_input::Builder,
    }
    impl DescribeApp {
        /// Creates a new `DescribeApp`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::DescribeApp,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::DescribeAppError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// 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::DescribeAppOutput,
            aws_smithy_http::result::SdkError<crate::error::DescribeAppError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The name of the simulation of the app.</p>
        pub fn simulation(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.simulation(input.into());
            self
        }
        /// <p>The name of the simulation of the app.</p>
        pub fn set_simulation(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_simulation(input);
            self
        }
        /// <p>The name of the domain of the app.</p>
        pub fn domain(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.domain(input.into());
            self
        }
        /// <p>The name of the domain of the app.</p>
        pub fn set_domain(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_domain(input);
            self
        }
        /// <p>The name of the app.</p>
        pub fn app(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.app(input.into());
            self
        }
        /// <p>The name of the app.</p>
        pub fn set_app(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_app(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DescribeSimulation`.
    ///
    /// <p>Returns the current state of the given simulation.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct DescribeSimulation {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::describe_simulation_input::Builder,
    }
    impl DescribeSimulation {
        /// Creates a new `DescribeSimulation`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::DescribeSimulation,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::DescribeSimulationError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// 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::DescribeSimulationOutput,
            aws_smithy_http::result::SdkError<crate::error::DescribeSimulationError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The name of the simulation.</p>
        pub fn simulation(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.simulation(input.into());
            self
        }
        /// <p>The name of the simulation.</p>
        pub fn set_simulation(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_simulation(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ListApps`.
    ///
    /// <p>Lists all custom apps or service apps for the given simulation and domain.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct ListApps {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::list_apps_input::Builder,
    }
    impl ListApps {
        /// Creates a new `ListApps`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::ListApps,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::ListAppsError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// 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::ListAppsOutput,
            aws_smithy_http::result::SdkError<crate::error::ListAppsError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// Create a paginator for this request
        ///
        /// Paginators are used by calling [`send().await`](crate::paginator::ListAppsPaginator::send) which returns a [`Stream`](tokio_stream::Stream).
        pub fn into_paginator(self) -> crate::paginator::ListAppsPaginator {
            crate::paginator::ListAppsPaginator::new(self.handle, self.inner)
        }
        /// <p>The name of the simulation that you want to list apps for.</p>
        pub fn simulation(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.simulation(input.into());
            self
        }
        /// <p>The name of the simulation that you want to list apps for.</p>
        pub fn set_simulation(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_simulation(input);
            self
        }
        /// <p>The name of the domain that you want to list apps for.</p>
        pub fn domain(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.domain(input.into());
            self
        }
        /// <p>The name of the domain that you want to list apps for.</p>
        pub fn set_domain(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_domain(input);
            self
        }
        /// <p>The maximum number of apps to list.</p>
        pub fn max_results(mut self, input: i32) -> Self {
            self.inner = self.inner.max_results(input);
            self
        }
        /// <p>The maximum number of apps to list.</p>
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
        /// <p>If SimSpace Weaver returns <code>nextToken</code>, there are more results available. The value of <code>nextToken</code> is a unique pagination token for each page. To retrieve the next page, call the operation again using the returned token. Keep all other arguments unchanged. If no results remain, <code>nextToken</code> is set to <code>null</code>. Each pagination token expires after 24 hours. If you provide a token that isn't valid, you receive an <i>HTTP 400 ValidationException</i> error.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(input.into());
            self
        }
        /// <p>If SimSpace Weaver returns <code>nextToken</code>, there are more results available. The value of <code>nextToken</code> is a unique pagination token for each page. To retrieve the next page, call the operation again using the returned token. Keep all other arguments unchanged. If no results remain, <code>nextToken</code> is set to <code>null</code>. Each pagination token expires after 24 hours. If you provide a token that isn't valid, you receive an <i>HTTP 400 ValidationException</i> error.</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 `ListSimulations`.
    ///
    /// <p>Lists the SimSpace Weaver simulations in the Amazon Web Services account used to make the API call.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct ListSimulations {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::list_simulations_input::Builder,
    }
    impl ListSimulations {
        /// Creates a new `ListSimulations`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::ListSimulations,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::ListSimulationsError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// 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::ListSimulationsOutput,
            aws_smithy_http::result::SdkError<crate::error::ListSimulationsError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// Create a paginator for this request
        ///
        /// Paginators are used by calling [`send().await`](crate::paginator::ListSimulationsPaginator::send) which returns a [`Stream`](tokio_stream::Stream).
        pub fn into_paginator(self) -> crate::paginator::ListSimulationsPaginator {
            crate::paginator::ListSimulationsPaginator::new(self.handle, self.inner)
        }
        /// <p>The maximum number of simulations to list.</p>
        pub fn max_results(mut self, input: i32) -> Self {
            self.inner = self.inner.max_results(input);
            self
        }
        /// <p>The maximum number of simulations to list.</p>
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
        /// <p>If SimSpace Weaver returns <code>nextToken</code>, there are more results available. The value of <code>nextToken</code> is a unique pagination token for each page. To retrieve the next page, call the operation again using the returned token. Keep all other arguments unchanged. If no results remain, <code>nextToken</code> is set to <code>null</code>. Each pagination token expires after 24 hours. If you provide a token that isn't valid, you receive an <i>HTTP 400 ValidationException</i> error.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(input.into());
            self
        }
        /// <p>If SimSpace Weaver returns <code>nextToken</code>, there are more results available. The value of <code>nextToken</code> is a unique pagination token for each page. To retrieve the next page, call the operation again using the returned token. Keep all other arguments unchanged. If no results remain, <code>nextToken</code> is set to <code>null</code>. Each pagination token expires after 24 hours. If you provide a token that isn't valid, you receive an <i>HTTP 400 ValidationException</i> error.</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 `ListTagsForResource`.
    ///
    /// <p>Lists all tags on a SimSpace Weaver resource.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct ListTagsForResource {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::list_tags_for_resource_input::Builder,
    }
    impl ListTagsForResource {
        /// Creates a new `ListTagsForResource`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::ListTagsForResource,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::ListTagsForResourceError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// 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::ListTagsForResourceOutput,
            aws_smithy_http::result::SdkError<crate::error::ListTagsForResourceError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The Amazon Resource Name (ARN) of the resource. For more information about ARNs, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon Resource Names (ARNs)</a> in the <i>Amazon Web Services General Reference</i>.</p>
        pub fn resource_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.resource_arn(input.into());
            self
        }
        /// <p>The Amazon Resource Name (ARN) of the resource. For more information about ARNs, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon Resource Names (ARNs)</a> in the <i>Amazon Web Services General Reference</i>.</p>
        pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_resource_arn(input);
            self
        }
    }
    /// Fluent builder constructing a request to `StartApp`.
    ///
    /// <p>Starts a custom app with the configuration specified in the simulation schema.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct StartApp {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::start_app_input::Builder,
    }
    impl StartApp {
        /// Creates a new `StartApp`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::StartApp,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::StartAppError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// 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::StartAppOutput,
            aws_smithy_http::result::SdkError<crate::error::StartAppError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>A value that you provide to ensure that repeated calls to this API operation using the same parameters complete only once. A <code>ClientToken</code> is also known as an <i>idempotency token</i>. A <code>ClientToken</code> expires after 24 hours.</p>
        pub fn client_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.client_token(input.into());
            self
        }
        /// <p>A value that you provide to ensure that repeated calls to this API operation using the same parameters complete only once. A <code>ClientToken</code> is also known as an <i>idempotency token</i>. A <code>ClientToken</code> expires after 24 hours.</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 the simulation of the app.</p>
        pub fn simulation(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.simulation(input.into());
            self
        }
        /// <p>The name of the simulation of the app.</p>
        pub fn set_simulation(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_simulation(input);
            self
        }
        /// <p>The name of the domain of the app.</p>
        pub fn domain(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.domain(input.into());
            self
        }
        /// <p>The name of the domain of the app.</p>
        pub fn set_domain(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_domain(input);
            self
        }
        /// <p>The name of the app.</p>
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.name(input.into());
            self
        }
        /// <p>The name of the app.</p>
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_name(input);
            self
        }
        /// <p>The description of the app.</p>
        pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.description(input.into());
            self
        }
        /// <p>The description of the app.</p>
        pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_description(input);
            self
        }
        /// <p>Options that apply when the app starts. These optiAons override default behavior.</p>
        pub fn launch_overrides(mut self, input: crate::model::LaunchOverrides) -> Self {
            self.inner = self.inner.launch_overrides(input);
            self
        }
        /// <p>Options that apply when the app starts. These optiAons override default behavior.</p>
        pub fn set_launch_overrides(
            mut self,
            input: std::option::Option<crate::model::LaunchOverrides>,
        ) -> Self {
            self.inner = self.inner.set_launch_overrides(input);
            self
        }
    }
    /// Fluent builder constructing a request to `StartClock`.
    ///
    /// <p>Starts the simulation clock.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct StartClock {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::start_clock_input::Builder,
    }
    impl StartClock {
        /// Creates a new `StartClock`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::StartClock,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::StartClockError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// 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::StartClockOutput,
            aws_smithy_http::result::SdkError<crate::error::StartClockError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The name of the simulation.</p>
        pub fn simulation(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.simulation(input.into());
            self
        }
        /// <p>The name of the simulation.</p>
        pub fn set_simulation(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_simulation(input);
            self
        }
    }
    /// Fluent builder constructing a request to `StartSimulation`.
    ///
    /// <p>Starts a simulation with the given name and schema.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct StartSimulation {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::start_simulation_input::Builder,
    }
    impl StartSimulation {
        /// Creates a new `StartSimulation`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::StartSimulation,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::StartSimulationError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// 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::StartSimulationOutput,
            aws_smithy_http::result::SdkError<crate::error::StartSimulationError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>A value that you provide to ensure that repeated calls to this API operation using the same parameters complete only once. A <code>ClientToken</code> is also known as an <i>idempotency token</i>. A <code>ClientToken</code> expires after 24 hours.</p>
        pub fn client_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.client_token(input.into());
            self
        }
        /// <p>A value that you provide to ensure that repeated calls to this API operation using the same parameters complete only once. A <code>ClientToken</code> is also known as an <i>idempotency token</i>. A <code>ClientToken</code> expires after 24 hours.</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 the simulation.</p>
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.name(input.into());
            self
        }
        /// <p>The name of the simulation.</p>
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_name(input);
            self
        }
        /// <p>The description of the simulation.</p>
        pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.description(input.into());
            self
        }
        /// <p>The description of the simulation.</p>
        pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_description(input);
            self
        }
        /// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that the simulation assumes to perform actions. For more information about ARNs, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon Resource Names (ARNs)</a> in the <i>Amazon Web Services General Reference</i>. For more information about IAM roles, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html">IAM roles</a> in the <i>Identity and Access Management User Guide</i>.</p>
        pub fn role_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.role_arn(input.into());
            self
        }
        /// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that the simulation assumes to perform actions. For more information about ARNs, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon Resource Names (ARNs)</a> in the <i>Amazon Web Services General Reference</i>. For more information about IAM roles, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html">IAM roles</a> in the <i>Identity and Access Management User Guide</i>.</p>
        pub fn set_role_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_role_arn(input);
            self
        }
        /// <p>The location of the simulation schema in Amazon Simple Storage Service (Amazon S3). For more information about Amazon S3, see the <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html"> <i>Amazon Simple Storage Service User Guide</i> </a>.</p>
        pub fn schema_s3_location(mut self, input: crate::model::S3Location) -> Self {
            self.inner = self.inner.schema_s3_location(input);
            self
        }
        /// <p>The location of the simulation schema in Amazon Simple Storage Service (Amazon S3). For more information about Amazon S3, see the <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html"> <i>Amazon Simple Storage Service User Guide</i> </a>.</p>
        pub fn set_schema_s3_location(
            mut self,
            input: std::option::Option<crate::model::S3Location>,
        ) -> Self {
            self.inner = self.inner.set_schema_s3_location(input);
            self
        }
        /// <p>The maximum running time of the simulation, specified as a number of months (m or M), hours (h or H), or days (d or D). The simulation stops when it reaches this limit.</p>
        pub fn maximum_duration(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.maximum_duration(input.into());
            self
        }
        /// <p>The maximum running time of the simulation, specified as a number of months (m or M), hours (h or H), or days (d or D). The simulation stops when it reaches this limit.</p>
        pub fn set_maximum_duration(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_maximum_duration(input);
            self
        }
        /// Adds a key-value pair to `Tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>A list of tags for the simulation. For more information about tags, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging Amazon Web Services resources</a> in the <i>Amazon Web Services General Reference</i>.</p>
        pub fn tags(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.tags(k.into(), v.into());
            self
        }
        /// <p>A list of tags for the simulation. For more information about tags, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging Amazon Web Services resources</a> in the <i>Amazon Web Services General Reference</i>.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.inner = self.inner.set_tags(input);
            self
        }
    }
    /// Fluent builder constructing a request to `StopApp`.
    ///
    /// <p>Stops the given custom app and shuts down all of its allocated compute resources.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct StopApp {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::stop_app_input::Builder,
    }
    impl StopApp {
        /// Creates a new `StopApp`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::StopApp,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::StopAppError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// 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::StopAppOutput,
            aws_smithy_http::result::SdkError<crate::error::StopAppError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The name of the simulation of the app.</p>
        pub fn simulation(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.simulation(input.into());
            self
        }
        /// <p>The name of the simulation of the app.</p>
        pub fn set_simulation(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_simulation(input);
            self
        }
        /// <p>The name of the domain of the app.</p>
        pub fn domain(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.domain(input.into());
            self
        }
        /// <p>The name of the domain of the app.</p>
        pub fn set_domain(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_domain(input);
            self
        }
        /// <p>The name of the app.</p>
        pub fn app(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.app(input.into());
            self
        }
        /// <p>The name of the app.</p>
        pub fn set_app(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_app(input);
            self
        }
    }
    /// Fluent builder constructing a request to `StopClock`.
    ///
    /// <p>Stops the simulation clock.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct StopClock {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::stop_clock_input::Builder,
    }
    impl StopClock {
        /// Creates a new `StopClock`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::StopClock,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::StopClockError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// 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::StopClockOutput,
            aws_smithy_http::result::SdkError<crate::error::StopClockError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The name of the simulation.</p>
        pub fn simulation(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.simulation(input.into());
            self
        }
        /// <p>The name of the simulation.</p>
        pub fn set_simulation(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_simulation(input);
            self
        }
    }
    /// Fluent builder constructing a request to `StopSimulation`.
    ///
    /// <p>Stops the given simulation.</p> <important>
    /// <p>You can't restart a simulation after you stop it. If you need to restart a simulation, you must stop it, delete it, and start a new instance of it.</p>
    /// </important>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct StopSimulation {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::stop_simulation_input::Builder,
    }
    impl StopSimulation {
        /// Creates a new `StopSimulation`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::StopSimulation,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::StopSimulationError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// 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::StopSimulationOutput,
            aws_smithy_http::result::SdkError<crate::error::StopSimulationError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The name of the simulation.</p>
        pub fn simulation(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.simulation(input.into());
            self
        }
        /// <p>The name of the simulation.</p>
        pub fn set_simulation(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_simulation(input);
            self
        }
    }
    /// Fluent builder constructing a request to `TagResource`.
    ///
    /// <p>Adds tags to a SimSpace Weaver resource. For more information about tags, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging Amazon Web Services resources</a> in the <i>Amazon Web Services General Reference</i>.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct TagResource {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::tag_resource_input::Builder,
    }
    impl TagResource {
        /// Creates a new `TagResource`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::TagResource,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::TagResourceError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// 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::TagResourceOutput,
            aws_smithy_http::result::SdkError<crate::error::TagResourceError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The Amazon Resource Name (ARN) of the resource that you want to add tags to. For more information about ARNs, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon Resource Names (ARNs)</a> in the <i>Amazon Web Services General Reference</i>.</p>
        pub fn resource_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.resource_arn(input.into());
            self
        }
        /// <p>The Amazon Resource Name (ARN) of the resource that you want to add tags to. For more information about ARNs, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon Resource Names (ARNs)</a> in the <i>Amazon Web Services General Reference</i>.</p>
        pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_resource_arn(input);
            self
        }
        /// Adds a key-value pair to `Tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>A list of tags to apply to the resource.</p>
        pub fn tags(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.tags(k.into(), v.into());
            self
        }
        /// <p>A list of tags to apply to the resource.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.inner = self.inner.set_tags(input);
            self
        }
    }
    /// Fluent builder constructing a request to `UntagResource`.
    ///
    /// <p>Removes tags from a SimSpace Weaver resource. For more information about tags, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging Amazon Web Services resources</a> in the <i>Amazon Web Services General Reference</i>.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct UntagResource {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::untag_resource_input::Builder,
    }
    impl UntagResource {
        /// Creates a new `UntagResource`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::UntagResource,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::UntagResourceError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// 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::UntagResourceOutput,
            aws_smithy_http::result::SdkError<crate::error::UntagResourceError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The Amazon Resource Name (ARN) of the resource that you want to remove tags from. For more information about ARNs, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon Resource Names (ARNs)</a> in the <i>Amazon Web Services General Reference</i>.</p>
        pub fn resource_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.resource_arn(input.into());
            self
        }
        /// <p>The Amazon Resource Name (ARN) of the resource that you want to remove tags from. For more information about ARNs, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon Resource Names (ARNs)</a> in the <i>Amazon Web Services General Reference</i>.</p>
        pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_resource_arn(input);
            self
        }
        /// Appends an item to `TagKeys`.
        ///
        /// To override the contents of this collection use [`set_tag_keys`](Self::set_tag_keys).
        ///
        /// <p>A list of tag keys to remove from the resource.</p>
        pub fn tag_keys(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.tag_keys(input.into());
            self
        }
        /// <p>A list of tag keys to remove from the resource.</p>
        pub fn set_tag_keys(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.inner = self.inner.set_tag_keys(input);
            self
        }
    }
}

impl Client {
    /// Creates a new client from an [SDK Config](aws_types::sdk_config::SdkConfig).
    ///
    /// # Panics
    ///
    /// - This method will panic if the `sdk_config` is missing an async sleep implementation. If you experience this panic, set
    ///     the `sleep_impl` on the Config passed into this function to fix it.
    /// - This method will panic if the `sdk_config` is missing an HTTP connector. If you experience this panic, set the
    ///     `http_connector` on the Config passed into this function to fix it.
    pub fn new(sdk_config: &aws_types::sdk_config::SdkConfig) -> Self {
        Self::from_conf(sdk_config.into())
    }

    /// Creates a new client from the service [`Config`](crate::Config).
    ///
    /// # Panics
    ///
    /// - This method will panic if the `conf` is missing an async sleep implementation. If you experience this panic, set
    ///     the `sleep_impl` on the Config passed into this function to fix it.
    /// - This method will panic if the `conf` is missing an HTTP connector. If you experience this panic, set the
    ///     `http_connector` on the Config passed into this function to fix it.
    pub fn from_conf(conf: crate::Config) -> Self {
        let retry_config = conf
            .retry_config()
            .cloned()
            .unwrap_or_else(aws_smithy_types::retry::RetryConfig::disabled);
        let timeout_config = conf
            .timeout_config()
            .cloned()
            .unwrap_or_else(aws_smithy_types::timeout::TimeoutConfig::disabled);
        let sleep_impl = conf.sleep_impl();
        if (retry_config.has_retry() || timeout_config.has_timeouts()) && sleep_impl.is_none() {
            panic!("An async sleep implementation is required for retries or timeouts to work. \
                                    Set the `sleep_impl` on the Config passed into this function to fix this panic.");
        }

        let connector = conf.http_connector().and_then(|c| {
            let timeout_config = conf
                .timeout_config()
                .cloned()
                .unwrap_or_else(aws_smithy_types::timeout::TimeoutConfig::disabled);
            let connector_settings =
                aws_smithy_client::http_connector::ConnectorSettings::from_timeout_config(
                    &timeout_config,
                );
            c.connector(&connector_settings, conf.sleep_impl())
        });

        let builder = aws_smithy_client::Builder::new();

        let builder = match connector {
            // Use provided connector
            Some(c) => builder.connector(c),
            None => {
                #[cfg(any(feature = "rustls", feature = "native-tls"))]
                {
                    // Use default connector based on enabled features
                    builder.dyn_https_connector(
                        aws_smithy_client::http_connector::ConnectorSettings::from_timeout_config(
                            &timeout_config,
                        ),
                    )
                }
                #[cfg(not(any(feature = "rustls", feature = "native-tls")))]
                {
                    panic!("No HTTP connector was available. Enable the `rustls` or `native-tls` crate feature or set a connector to fix this.");
                }
            }
        };
        let mut builder = builder
            .middleware(aws_smithy_client::erase::DynMiddleware::new(
                crate::middleware::DefaultMiddleware::new(),
            ))
            .retry_config(retry_config.into())
            .operation_timeout_config(timeout_config.into());
        builder.set_sleep_impl(sleep_impl);
        let client = builder.build();

        Self {
            handle: std::sync::Arc::new(Handle { client, conf }),
        }
    }
}