operation.rs

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/// Operation shape for `AddTagsToOnPremisesInstances`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`add_tags_to_on_premises_instances`](crate::client::Client::add_tags_to_on_premises_instances).
///
/// See [`crate::client::fluent_builders::AddTagsToOnPremisesInstances`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct AddTagsToOnPremisesInstances {
    _private: (),
}
impl AddTagsToOnPremisesInstances {
    /// Creates a new builder-style object to manufacture [`AddTagsToOnPremisesInstancesInput`](crate::input::AddTagsToOnPremisesInstancesInput)
    pub fn builder() -> crate::input::add_tags_to_on_premises_instances_input::Builder {
        crate::input::add_tags_to_on_premises_instances_input::Builder::default()
    }
    /// Creates a new `AddTagsToOnPremisesInstances` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for AddTagsToOnPremisesInstances {
    type Output = std::result::Result<
        crate::output::AddTagsToOnPremisesInstancesOutput,
        crate::error::AddTagsToOnPremisesInstancesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_add_tags_to_on_premises_instances_error(response)
        } else {
            crate::operation_deser::parse_add_tags_to_on_premises_instances_response(response)
        }
    }
}

/// Operation shape for `BatchGetApplicationRevisions`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`batch_get_application_revisions`](crate::client::Client::batch_get_application_revisions).
///
/// See [`crate::client::fluent_builders::BatchGetApplicationRevisions`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct BatchGetApplicationRevisions {
    _private: (),
}
impl BatchGetApplicationRevisions {
    /// Creates a new builder-style object to manufacture [`BatchGetApplicationRevisionsInput`](crate::input::BatchGetApplicationRevisionsInput)
    pub fn builder() -> crate::input::batch_get_application_revisions_input::Builder {
        crate::input::batch_get_application_revisions_input::Builder::default()
    }
    /// Creates a new `BatchGetApplicationRevisions` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for BatchGetApplicationRevisions {
    type Output = std::result::Result<
        crate::output::BatchGetApplicationRevisionsOutput,
        crate::error::BatchGetApplicationRevisionsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_batch_get_application_revisions_error(response)
        } else {
            crate::operation_deser::parse_batch_get_application_revisions_response(response)
        }
    }
}

/// Operation shape for `BatchGetApplications`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`batch_get_applications`](crate::client::Client::batch_get_applications).
///
/// See [`crate::client::fluent_builders::BatchGetApplications`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct BatchGetApplications {
    _private: (),
}
impl BatchGetApplications {
    /// Creates a new builder-style object to manufacture [`BatchGetApplicationsInput`](crate::input::BatchGetApplicationsInput)
    pub fn builder() -> crate::input::batch_get_applications_input::Builder {
        crate::input::batch_get_applications_input::Builder::default()
    }
    /// Creates a new `BatchGetApplications` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for BatchGetApplications {
    type Output = std::result::Result<
        crate::output::BatchGetApplicationsOutput,
        crate::error::BatchGetApplicationsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_batch_get_applications_error(response)
        } else {
            crate::operation_deser::parse_batch_get_applications_response(response)
        }
    }
}

/// Operation shape for `BatchGetDeploymentGroups`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`batch_get_deployment_groups`](crate::client::Client::batch_get_deployment_groups).
///
/// See [`crate::client::fluent_builders::BatchGetDeploymentGroups`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct BatchGetDeploymentGroups {
    _private: (),
}
impl BatchGetDeploymentGroups {
    /// Creates a new builder-style object to manufacture [`BatchGetDeploymentGroupsInput`](crate::input::BatchGetDeploymentGroupsInput)
    pub fn builder() -> crate::input::batch_get_deployment_groups_input::Builder {
        crate::input::batch_get_deployment_groups_input::Builder::default()
    }
    /// Creates a new `BatchGetDeploymentGroups` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for BatchGetDeploymentGroups {
    type Output = std::result::Result<
        crate::output::BatchGetDeploymentGroupsOutput,
        crate::error::BatchGetDeploymentGroupsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_batch_get_deployment_groups_error(response)
        } else {
            crate::operation_deser::parse_batch_get_deployment_groups_response(response)
        }
    }
}

/// Operation shape for `BatchGetDeploymentInstances`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`batch_get_deployment_instances`](crate::client::Client::batch_get_deployment_instances).
///
/// See [`crate::client::fluent_builders::BatchGetDeploymentInstances`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct BatchGetDeploymentInstances {
    _private: (),
}
impl BatchGetDeploymentInstances {
    /// Creates a new builder-style object to manufacture [`BatchGetDeploymentInstancesInput`](crate::input::BatchGetDeploymentInstancesInput)
    pub fn builder() -> crate::input::batch_get_deployment_instances_input::Builder {
        crate::input::batch_get_deployment_instances_input::Builder::default()
    }
    /// Creates a new `BatchGetDeploymentInstances` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for BatchGetDeploymentInstances {
    type Output = std::result::Result<
        crate::output::BatchGetDeploymentInstancesOutput,
        crate::error::BatchGetDeploymentInstancesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_batch_get_deployment_instances_error(response)
        } else {
            crate::operation_deser::parse_batch_get_deployment_instances_response(response)
        }
    }
}

/// Operation shape for `BatchGetDeployments`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`batch_get_deployments`](crate::client::Client::batch_get_deployments).
///
/// See [`crate::client::fluent_builders::BatchGetDeployments`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct BatchGetDeployments {
    _private: (),
}
impl BatchGetDeployments {
    /// Creates a new builder-style object to manufacture [`BatchGetDeploymentsInput`](crate::input::BatchGetDeploymentsInput)
    pub fn builder() -> crate::input::batch_get_deployments_input::Builder {
        crate::input::batch_get_deployments_input::Builder::default()
    }
    /// Creates a new `BatchGetDeployments` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for BatchGetDeployments {
    type Output = std::result::Result<
        crate::output::BatchGetDeploymentsOutput,
        crate::error::BatchGetDeploymentsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_batch_get_deployments_error(response)
        } else {
            crate::operation_deser::parse_batch_get_deployments_response(response)
        }
    }
}

/// Operation shape for `BatchGetDeploymentTargets`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`batch_get_deployment_targets`](crate::client::Client::batch_get_deployment_targets).
///
/// See [`crate::client::fluent_builders::BatchGetDeploymentTargets`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct BatchGetDeploymentTargets {
    _private: (),
}
impl BatchGetDeploymentTargets {
    /// Creates a new builder-style object to manufacture [`BatchGetDeploymentTargetsInput`](crate::input::BatchGetDeploymentTargetsInput)
    pub fn builder() -> crate::input::batch_get_deployment_targets_input::Builder {
        crate::input::batch_get_deployment_targets_input::Builder::default()
    }
    /// Creates a new `BatchGetDeploymentTargets` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for BatchGetDeploymentTargets {
    type Output = std::result::Result<
        crate::output::BatchGetDeploymentTargetsOutput,
        crate::error::BatchGetDeploymentTargetsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_batch_get_deployment_targets_error(response)
        } else {
            crate::operation_deser::parse_batch_get_deployment_targets_response(response)
        }
    }
}

/// Operation shape for `BatchGetOnPremisesInstances`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`batch_get_on_premises_instances`](crate::client::Client::batch_get_on_premises_instances).
///
/// See [`crate::client::fluent_builders::BatchGetOnPremisesInstances`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct BatchGetOnPremisesInstances {
    _private: (),
}
impl BatchGetOnPremisesInstances {
    /// Creates a new builder-style object to manufacture [`BatchGetOnPremisesInstancesInput`](crate::input::BatchGetOnPremisesInstancesInput)
    pub fn builder() -> crate::input::batch_get_on_premises_instances_input::Builder {
        crate::input::batch_get_on_premises_instances_input::Builder::default()
    }
    /// Creates a new `BatchGetOnPremisesInstances` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for BatchGetOnPremisesInstances {
    type Output = std::result::Result<
        crate::output::BatchGetOnPremisesInstancesOutput,
        crate::error::BatchGetOnPremisesInstancesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_batch_get_on_premises_instances_error(response)
        } else {
            crate::operation_deser::parse_batch_get_on_premises_instances_response(response)
        }
    }
}

/// Operation shape for `ContinueDeployment`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`continue_deployment`](crate::client::Client::continue_deployment).
///
/// See [`crate::client::fluent_builders::ContinueDeployment`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ContinueDeployment {
    _private: (),
}
impl ContinueDeployment {
    /// Creates a new builder-style object to manufacture [`ContinueDeploymentInput`](crate::input::ContinueDeploymentInput)
    pub fn builder() -> crate::input::continue_deployment_input::Builder {
        crate::input::continue_deployment_input::Builder::default()
    }
    /// Creates a new `ContinueDeployment` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ContinueDeployment {
    type Output = std::result::Result<
        crate::output::ContinueDeploymentOutput,
        crate::error::ContinueDeploymentError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_continue_deployment_error(response)
        } else {
            crate::operation_deser::parse_continue_deployment_response(response)
        }
    }
}

/// Operation shape for `CreateApplication`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_application`](crate::client::Client::create_application).
///
/// See [`crate::client::fluent_builders::CreateApplication`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateApplication {
    _private: (),
}
impl CreateApplication {
    /// Creates a new builder-style object to manufacture [`CreateApplicationInput`](crate::input::CreateApplicationInput)
    pub fn builder() -> crate::input::create_application_input::Builder {
        crate::input::create_application_input::Builder::default()
    }
    /// Creates a new `CreateApplication` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateApplication {
    type Output = std::result::Result<
        crate::output::CreateApplicationOutput,
        crate::error::CreateApplicationError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_application_error(response)
        } else {
            crate::operation_deser::parse_create_application_response(response)
        }
    }
}

/// Operation shape for `CreateDeployment`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_deployment`](crate::client::Client::create_deployment).
///
/// See [`crate::client::fluent_builders::CreateDeployment`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateDeployment {
    _private: (),
}
impl CreateDeployment {
    /// Creates a new builder-style object to manufacture [`CreateDeploymentInput`](crate::input::CreateDeploymentInput)
    pub fn builder() -> crate::input::create_deployment_input::Builder {
        crate::input::create_deployment_input::Builder::default()
    }
    /// Creates a new `CreateDeployment` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateDeployment {
    type Output = std::result::Result<
        crate::output::CreateDeploymentOutput,
        crate::error::CreateDeploymentError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_deployment_error(response)
        } else {
            crate::operation_deser::parse_create_deployment_response(response)
        }
    }
}

/// Operation shape for `CreateDeploymentConfig`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_deployment_config`](crate::client::Client::create_deployment_config).
///
/// See [`crate::client::fluent_builders::CreateDeploymentConfig`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateDeploymentConfig {
    _private: (),
}
impl CreateDeploymentConfig {
    /// Creates a new builder-style object to manufacture [`CreateDeploymentConfigInput`](crate::input::CreateDeploymentConfigInput)
    pub fn builder() -> crate::input::create_deployment_config_input::Builder {
        crate::input::create_deployment_config_input::Builder::default()
    }
    /// Creates a new `CreateDeploymentConfig` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateDeploymentConfig {
    type Output = std::result::Result<
        crate::output::CreateDeploymentConfigOutput,
        crate::error::CreateDeploymentConfigError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_deployment_config_error(response)
        } else {
            crate::operation_deser::parse_create_deployment_config_response(response)
        }
    }
}

/// Operation shape for `CreateDeploymentGroup`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_deployment_group`](crate::client::Client::create_deployment_group).
///
/// See [`crate::client::fluent_builders::CreateDeploymentGroup`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateDeploymentGroup {
    _private: (),
}
impl CreateDeploymentGroup {
    /// Creates a new builder-style object to manufacture [`CreateDeploymentGroupInput`](crate::input::CreateDeploymentGroupInput)
    pub fn builder() -> crate::input::create_deployment_group_input::Builder {
        crate::input::create_deployment_group_input::Builder::default()
    }
    /// Creates a new `CreateDeploymentGroup` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateDeploymentGroup {
    type Output = std::result::Result<
        crate::output::CreateDeploymentGroupOutput,
        crate::error::CreateDeploymentGroupError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_deployment_group_error(response)
        } else {
            crate::operation_deser::parse_create_deployment_group_response(response)
        }
    }
}

/// Operation shape for `DeleteApplication`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_application`](crate::client::Client::delete_application).
///
/// See [`crate::client::fluent_builders::DeleteApplication`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteApplication {
    _private: (),
}
impl DeleteApplication {
    /// Creates a new builder-style object to manufacture [`DeleteApplicationInput`](crate::input::DeleteApplicationInput)
    pub fn builder() -> crate::input::delete_application_input::Builder {
        crate::input::delete_application_input::Builder::default()
    }
    /// Creates a new `DeleteApplication` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteApplication {
    type Output = std::result::Result<
        crate::output::DeleteApplicationOutput,
        crate::error::DeleteApplicationError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_application_error(response)
        } else {
            crate::operation_deser::parse_delete_application_response(response)
        }
    }
}

/// Operation shape for `DeleteDeploymentConfig`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_deployment_config`](crate::client::Client::delete_deployment_config).
///
/// See [`crate::client::fluent_builders::DeleteDeploymentConfig`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteDeploymentConfig {
    _private: (),
}
impl DeleteDeploymentConfig {
    /// Creates a new builder-style object to manufacture [`DeleteDeploymentConfigInput`](crate::input::DeleteDeploymentConfigInput)
    pub fn builder() -> crate::input::delete_deployment_config_input::Builder {
        crate::input::delete_deployment_config_input::Builder::default()
    }
    /// Creates a new `DeleteDeploymentConfig` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteDeploymentConfig {
    type Output = std::result::Result<
        crate::output::DeleteDeploymentConfigOutput,
        crate::error::DeleteDeploymentConfigError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_deployment_config_error(response)
        } else {
            crate::operation_deser::parse_delete_deployment_config_response(response)
        }
    }
}

/// Operation shape for `DeleteDeploymentGroup`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_deployment_group`](crate::client::Client::delete_deployment_group).
///
/// See [`crate::client::fluent_builders::DeleteDeploymentGroup`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteDeploymentGroup {
    _private: (),
}
impl DeleteDeploymentGroup {
    /// Creates a new builder-style object to manufacture [`DeleteDeploymentGroupInput`](crate::input::DeleteDeploymentGroupInput)
    pub fn builder() -> crate::input::delete_deployment_group_input::Builder {
        crate::input::delete_deployment_group_input::Builder::default()
    }
    /// Creates a new `DeleteDeploymentGroup` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteDeploymentGroup {
    type Output = std::result::Result<
        crate::output::DeleteDeploymentGroupOutput,
        crate::error::DeleteDeploymentGroupError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_deployment_group_error(response)
        } else {
            crate::operation_deser::parse_delete_deployment_group_response(response)
        }
    }
}

/// Operation shape for `DeleteGitHubAccountToken`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_git_hub_account_token`](crate::client::Client::delete_git_hub_account_token).
///
/// See [`crate::client::fluent_builders::DeleteGitHubAccountToken`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteGitHubAccountToken {
    _private: (),
}
impl DeleteGitHubAccountToken {
    /// Creates a new builder-style object to manufacture [`DeleteGitHubAccountTokenInput`](crate::input::DeleteGitHubAccountTokenInput)
    pub fn builder() -> crate::input::delete_git_hub_account_token_input::Builder {
        crate::input::delete_git_hub_account_token_input::Builder::default()
    }
    /// Creates a new `DeleteGitHubAccountToken` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteGitHubAccountToken {
    type Output = std::result::Result<
        crate::output::DeleteGitHubAccountTokenOutput,
        crate::error::DeleteGitHubAccountTokenError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_git_hub_account_token_error(response)
        } else {
            crate::operation_deser::parse_delete_git_hub_account_token_response(response)
        }
    }
}

/// Operation shape for `DeleteResourcesByExternalId`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_resources_by_external_id`](crate::client::Client::delete_resources_by_external_id).
///
/// See [`crate::client::fluent_builders::DeleteResourcesByExternalId`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteResourcesByExternalId {
    _private: (),
}
impl DeleteResourcesByExternalId {
    /// Creates a new builder-style object to manufacture [`DeleteResourcesByExternalIdInput`](crate::input::DeleteResourcesByExternalIdInput)
    pub fn builder() -> crate::input::delete_resources_by_external_id_input::Builder {
        crate::input::delete_resources_by_external_id_input::Builder::default()
    }
    /// Creates a new `DeleteResourcesByExternalId` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteResourcesByExternalId {
    type Output = std::result::Result<
        crate::output::DeleteResourcesByExternalIdOutput,
        crate::error::DeleteResourcesByExternalIdError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_resources_by_external_id_error(response)
        } else {
            crate::operation_deser::parse_delete_resources_by_external_id_response(response)
        }
    }
}

/// Operation shape for `DeregisterOnPremisesInstance`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`deregister_on_premises_instance`](crate::client::Client::deregister_on_premises_instance).
///
/// See [`crate::client::fluent_builders::DeregisterOnPremisesInstance`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeregisterOnPremisesInstance {
    _private: (),
}
impl DeregisterOnPremisesInstance {
    /// Creates a new builder-style object to manufacture [`DeregisterOnPremisesInstanceInput`](crate::input::DeregisterOnPremisesInstanceInput)
    pub fn builder() -> crate::input::deregister_on_premises_instance_input::Builder {
        crate::input::deregister_on_premises_instance_input::Builder::default()
    }
    /// Creates a new `DeregisterOnPremisesInstance` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeregisterOnPremisesInstance {
    type Output = std::result::Result<
        crate::output::DeregisterOnPremisesInstanceOutput,
        crate::error::DeregisterOnPremisesInstanceError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_deregister_on_premises_instance_error(response)
        } else {
            crate::operation_deser::parse_deregister_on_premises_instance_response(response)
        }
    }
}

/// Operation shape for `GetApplication`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_application`](crate::client::Client::get_application).
///
/// See [`crate::client::fluent_builders::GetApplication`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetApplication {
    _private: (),
}
impl GetApplication {
    /// Creates a new builder-style object to manufacture [`GetApplicationInput`](crate::input::GetApplicationInput)
    pub fn builder() -> crate::input::get_application_input::Builder {
        crate::input::get_application_input::Builder::default()
    }
    /// Creates a new `GetApplication` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetApplication {
    type Output =
        std::result::Result<crate::output::GetApplicationOutput, crate::error::GetApplicationError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_application_error(response)
        } else {
            crate::operation_deser::parse_get_application_response(response)
        }
    }
}

/// Operation shape for `GetApplicationRevision`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_application_revision`](crate::client::Client::get_application_revision).
///
/// See [`crate::client::fluent_builders::GetApplicationRevision`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetApplicationRevision {
    _private: (),
}
impl GetApplicationRevision {
    /// Creates a new builder-style object to manufacture [`GetApplicationRevisionInput`](crate::input::GetApplicationRevisionInput)
    pub fn builder() -> crate::input::get_application_revision_input::Builder {
        crate::input::get_application_revision_input::Builder::default()
    }
    /// Creates a new `GetApplicationRevision` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetApplicationRevision {
    type Output = std::result::Result<
        crate::output::GetApplicationRevisionOutput,
        crate::error::GetApplicationRevisionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_application_revision_error(response)
        } else {
            crate::operation_deser::parse_get_application_revision_response(response)
        }
    }
}

/// Operation shape for `GetDeployment`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_deployment`](crate::client::Client::get_deployment).
///
/// See [`crate::client::fluent_builders::GetDeployment`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetDeployment {
    _private: (),
}
impl GetDeployment {
    /// Creates a new builder-style object to manufacture [`GetDeploymentInput`](crate::input::GetDeploymentInput)
    pub fn builder() -> crate::input::get_deployment_input::Builder {
        crate::input::get_deployment_input::Builder::default()
    }
    /// Creates a new `GetDeployment` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetDeployment {
    type Output =
        std::result::Result<crate::output::GetDeploymentOutput, crate::error::GetDeploymentError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_deployment_error(response)
        } else {
            crate::operation_deser::parse_get_deployment_response(response)
        }
    }
}

/// Operation shape for `GetDeploymentConfig`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_deployment_config`](crate::client::Client::get_deployment_config).
///
/// See [`crate::client::fluent_builders::GetDeploymentConfig`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetDeploymentConfig {
    _private: (),
}
impl GetDeploymentConfig {
    /// Creates a new builder-style object to manufacture [`GetDeploymentConfigInput`](crate::input::GetDeploymentConfigInput)
    pub fn builder() -> crate::input::get_deployment_config_input::Builder {
        crate::input::get_deployment_config_input::Builder::default()
    }
    /// Creates a new `GetDeploymentConfig` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetDeploymentConfig {
    type Output = std::result::Result<
        crate::output::GetDeploymentConfigOutput,
        crate::error::GetDeploymentConfigError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_deployment_config_error(response)
        } else {
            crate::operation_deser::parse_get_deployment_config_response(response)
        }
    }
}

/// Operation shape for `GetDeploymentGroup`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_deployment_group`](crate::client::Client::get_deployment_group).
///
/// See [`crate::client::fluent_builders::GetDeploymentGroup`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetDeploymentGroup {
    _private: (),
}
impl GetDeploymentGroup {
    /// Creates a new builder-style object to manufacture [`GetDeploymentGroupInput`](crate::input::GetDeploymentGroupInput)
    pub fn builder() -> crate::input::get_deployment_group_input::Builder {
        crate::input::get_deployment_group_input::Builder::default()
    }
    /// Creates a new `GetDeploymentGroup` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetDeploymentGroup {
    type Output = std::result::Result<
        crate::output::GetDeploymentGroupOutput,
        crate::error::GetDeploymentGroupError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_deployment_group_error(response)
        } else {
            crate::operation_deser::parse_get_deployment_group_response(response)
        }
    }
}

/// Operation shape for `GetDeploymentInstance`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_deployment_instance`](crate::client::Client::get_deployment_instance).
///
/// See [`crate::client::fluent_builders::GetDeploymentInstance`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetDeploymentInstance {
    _private: (),
}
impl GetDeploymentInstance {
    /// Creates a new builder-style object to manufacture [`GetDeploymentInstanceInput`](crate::input::GetDeploymentInstanceInput)
    pub fn builder() -> crate::input::get_deployment_instance_input::Builder {
        crate::input::get_deployment_instance_input::Builder::default()
    }
    /// Creates a new `GetDeploymentInstance` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetDeploymentInstance {
    type Output = std::result::Result<
        crate::output::GetDeploymentInstanceOutput,
        crate::error::GetDeploymentInstanceError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_deployment_instance_error(response)
        } else {
            crate::operation_deser::parse_get_deployment_instance_response(response)
        }
    }
}

/// Operation shape for `GetDeploymentTarget`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_deployment_target`](crate::client::Client::get_deployment_target).
///
/// See [`crate::client::fluent_builders::GetDeploymentTarget`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetDeploymentTarget {
    _private: (),
}
impl GetDeploymentTarget {
    /// Creates a new builder-style object to manufacture [`GetDeploymentTargetInput`](crate::input::GetDeploymentTargetInput)
    pub fn builder() -> crate::input::get_deployment_target_input::Builder {
        crate::input::get_deployment_target_input::Builder::default()
    }
    /// Creates a new `GetDeploymentTarget` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetDeploymentTarget {
    type Output = std::result::Result<
        crate::output::GetDeploymentTargetOutput,
        crate::error::GetDeploymentTargetError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_deployment_target_error(response)
        } else {
            crate::operation_deser::parse_get_deployment_target_response(response)
        }
    }
}

/// Operation shape for `GetOnPremisesInstance`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_on_premises_instance`](crate::client::Client::get_on_premises_instance).
///
/// See [`crate::client::fluent_builders::GetOnPremisesInstance`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetOnPremisesInstance {
    _private: (),
}
impl GetOnPremisesInstance {
    /// Creates a new builder-style object to manufacture [`GetOnPremisesInstanceInput`](crate::input::GetOnPremisesInstanceInput)
    pub fn builder() -> crate::input::get_on_premises_instance_input::Builder {
        crate::input::get_on_premises_instance_input::Builder::default()
    }
    /// Creates a new `GetOnPremisesInstance` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetOnPremisesInstance {
    type Output = std::result::Result<
        crate::output::GetOnPremisesInstanceOutput,
        crate::error::GetOnPremisesInstanceError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_on_premises_instance_error(response)
        } else {
            crate::operation_deser::parse_get_on_premises_instance_response(response)
        }
    }
}

/// Operation shape for `ListApplicationRevisions`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_application_revisions`](crate::client::Client::list_application_revisions).
///
/// See [`crate::client::fluent_builders::ListApplicationRevisions`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListApplicationRevisions {
    _private: (),
}
impl ListApplicationRevisions {
    /// Creates a new builder-style object to manufacture [`ListApplicationRevisionsInput`](crate::input::ListApplicationRevisionsInput)
    pub fn builder() -> crate::input::list_application_revisions_input::Builder {
        crate::input::list_application_revisions_input::Builder::default()
    }
    /// Creates a new `ListApplicationRevisions` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListApplicationRevisions {
    type Output = std::result::Result<
        crate::output::ListApplicationRevisionsOutput,
        crate::error::ListApplicationRevisionsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_application_revisions_error(response)
        } else {
            crate::operation_deser::parse_list_application_revisions_response(response)
        }
    }
}

/// Operation shape for `ListApplications`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_applications`](crate::client::Client::list_applications).
///
/// See [`crate::client::fluent_builders::ListApplications`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListApplications {
    _private: (),
}
impl ListApplications {
    /// Creates a new builder-style object to manufacture [`ListApplicationsInput`](crate::input::ListApplicationsInput)
    pub fn builder() -> crate::input::list_applications_input::Builder {
        crate::input::list_applications_input::Builder::default()
    }
    /// Creates a new `ListApplications` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListApplications {
    type Output = std::result::Result<
        crate::output::ListApplicationsOutput,
        crate::error::ListApplicationsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_applications_error(response)
        } else {
            crate::operation_deser::parse_list_applications_response(response)
        }
    }
}

/// Operation shape for `ListDeploymentConfigs`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_deployment_configs`](crate::client::Client::list_deployment_configs).
///
/// See [`crate::client::fluent_builders::ListDeploymentConfigs`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListDeploymentConfigs {
    _private: (),
}
impl ListDeploymentConfigs {
    /// Creates a new builder-style object to manufacture [`ListDeploymentConfigsInput`](crate::input::ListDeploymentConfigsInput)
    pub fn builder() -> crate::input::list_deployment_configs_input::Builder {
        crate::input::list_deployment_configs_input::Builder::default()
    }
    /// Creates a new `ListDeploymentConfigs` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListDeploymentConfigs {
    type Output = std::result::Result<
        crate::output::ListDeploymentConfigsOutput,
        crate::error::ListDeploymentConfigsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_deployment_configs_error(response)
        } else {
            crate::operation_deser::parse_list_deployment_configs_response(response)
        }
    }
}

/// Operation shape for `ListDeploymentGroups`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_deployment_groups`](crate::client::Client::list_deployment_groups).
///
/// See [`crate::client::fluent_builders::ListDeploymentGroups`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListDeploymentGroups {
    _private: (),
}
impl ListDeploymentGroups {
    /// Creates a new builder-style object to manufacture [`ListDeploymentGroupsInput`](crate::input::ListDeploymentGroupsInput)
    pub fn builder() -> crate::input::list_deployment_groups_input::Builder {
        crate::input::list_deployment_groups_input::Builder::default()
    }
    /// Creates a new `ListDeploymentGroups` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListDeploymentGroups {
    type Output = std::result::Result<
        crate::output::ListDeploymentGroupsOutput,
        crate::error::ListDeploymentGroupsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_deployment_groups_error(response)
        } else {
            crate::operation_deser::parse_list_deployment_groups_response(response)
        }
    }
}

/// Operation shape for `ListDeploymentInstances`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_deployment_instances`](crate::client::Client::list_deployment_instances).
///
/// See [`crate::client::fluent_builders::ListDeploymentInstances`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListDeploymentInstances {
    _private: (),
}
impl ListDeploymentInstances {
    /// Creates a new builder-style object to manufacture [`ListDeploymentInstancesInput`](crate::input::ListDeploymentInstancesInput)
    pub fn builder() -> crate::input::list_deployment_instances_input::Builder {
        crate::input::list_deployment_instances_input::Builder::default()
    }
    /// Creates a new `ListDeploymentInstances` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListDeploymentInstances {
    type Output = std::result::Result<
        crate::output::ListDeploymentInstancesOutput,
        crate::error::ListDeploymentInstancesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_deployment_instances_error(response)
        } else {
            crate::operation_deser::parse_list_deployment_instances_response(response)
        }
    }
}

/// Operation shape for `ListDeployments`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_deployments`](crate::client::Client::list_deployments).
///
/// See [`crate::client::fluent_builders::ListDeployments`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListDeployments {
    _private: (),
}
impl ListDeployments {
    /// Creates a new builder-style object to manufacture [`ListDeploymentsInput`](crate::input::ListDeploymentsInput)
    pub fn builder() -> crate::input::list_deployments_input::Builder {
        crate::input::list_deployments_input::Builder::default()
    }
    /// Creates a new `ListDeployments` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListDeployments {
    type Output = std::result::Result<
        crate::output::ListDeploymentsOutput,
        crate::error::ListDeploymentsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_deployments_error(response)
        } else {
            crate::operation_deser::parse_list_deployments_response(response)
        }
    }
}

/// Operation shape for `ListDeploymentTargets`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_deployment_targets`](crate::client::Client::list_deployment_targets).
///
/// See [`crate::client::fluent_builders::ListDeploymentTargets`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListDeploymentTargets {
    _private: (),
}
impl ListDeploymentTargets {
    /// Creates a new builder-style object to manufacture [`ListDeploymentTargetsInput`](crate::input::ListDeploymentTargetsInput)
    pub fn builder() -> crate::input::list_deployment_targets_input::Builder {
        crate::input::list_deployment_targets_input::Builder::default()
    }
    /// Creates a new `ListDeploymentTargets` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListDeploymentTargets {
    type Output = std::result::Result<
        crate::output::ListDeploymentTargetsOutput,
        crate::error::ListDeploymentTargetsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_deployment_targets_error(response)
        } else {
            crate::operation_deser::parse_list_deployment_targets_response(response)
        }
    }
}

/// Operation shape for `ListGitHubAccountTokenNames`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_git_hub_account_token_names`](crate::client::Client::list_git_hub_account_token_names).
///
/// See [`crate::client::fluent_builders::ListGitHubAccountTokenNames`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListGitHubAccountTokenNames {
    _private: (),
}
impl ListGitHubAccountTokenNames {
    /// Creates a new builder-style object to manufacture [`ListGitHubAccountTokenNamesInput`](crate::input::ListGitHubAccountTokenNamesInput)
    pub fn builder() -> crate::input::list_git_hub_account_token_names_input::Builder {
        crate::input::list_git_hub_account_token_names_input::Builder::default()
    }
    /// Creates a new `ListGitHubAccountTokenNames` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListGitHubAccountTokenNames {
    type Output = std::result::Result<
        crate::output::ListGitHubAccountTokenNamesOutput,
        crate::error::ListGitHubAccountTokenNamesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_git_hub_account_token_names_error(response)
        } else {
            crate::operation_deser::parse_list_git_hub_account_token_names_response(response)
        }
    }
}

/// Operation shape for `ListOnPremisesInstances`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_on_premises_instances`](crate::client::Client::list_on_premises_instances).
///
/// See [`crate::client::fluent_builders::ListOnPremisesInstances`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListOnPremisesInstances {
    _private: (),
}
impl ListOnPremisesInstances {
    /// Creates a new builder-style object to manufacture [`ListOnPremisesInstancesInput`](crate::input::ListOnPremisesInstancesInput)
    pub fn builder() -> crate::input::list_on_premises_instances_input::Builder {
        crate::input::list_on_premises_instances_input::Builder::default()
    }
    /// Creates a new `ListOnPremisesInstances` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListOnPremisesInstances {
    type Output = std::result::Result<
        crate::output::ListOnPremisesInstancesOutput,
        crate::error::ListOnPremisesInstancesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_on_premises_instances_error(response)
        } else {
            crate::operation_deser::parse_list_on_premises_instances_response(response)
        }
    }
}

/// Operation shape for `ListTagsForResource`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_tags_for_resource`](crate::client::Client::list_tags_for_resource).
///
/// See [`crate::client::fluent_builders::ListTagsForResource`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListTagsForResource {
    _private: (),
}
impl ListTagsForResource {
    /// Creates a new builder-style object to manufacture [`ListTagsForResourceInput`](crate::input::ListTagsForResourceInput)
    pub fn builder() -> crate::input::list_tags_for_resource_input::Builder {
        crate::input::list_tags_for_resource_input::Builder::default()
    }
    /// Creates a new `ListTagsForResource` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListTagsForResource {
    type Output = std::result::Result<
        crate::output::ListTagsForResourceOutput,
        crate::error::ListTagsForResourceError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_tags_for_resource_error(response)
        } else {
            crate::operation_deser::parse_list_tags_for_resource_response(response)
        }
    }
}

/// Operation shape for `PutLifecycleEventHookExecutionStatus`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`put_lifecycle_event_hook_execution_status`](crate::client::Client::put_lifecycle_event_hook_execution_status).
///
/// See [`crate::client::fluent_builders::PutLifecycleEventHookExecutionStatus`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct PutLifecycleEventHookExecutionStatus {
    _private: (),
}
impl PutLifecycleEventHookExecutionStatus {
    /// Creates a new builder-style object to manufacture [`PutLifecycleEventHookExecutionStatusInput`](crate::input::PutLifecycleEventHookExecutionStatusInput)
    pub fn builder() -> crate::input::put_lifecycle_event_hook_execution_status_input::Builder {
        crate::input::put_lifecycle_event_hook_execution_status_input::Builder::default()
    }
    /// Creates a new `PutLifecycleEventHookExecutionStatus` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for PutLifecycleEventHookExecutionStatus {
    type Output = std::result::Result<
        crate::output::PutLifecycleEventHookExecutionStatusOutput,
        crate::error::PutLifecycleEventHookExecutionStatusError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_put_lifecycle_event_hook_execution_status_error(response)
        } else {
            crate::operation_deser::parse_put_lifecycle_event_hook_execution_status_response(
                response,
            )
        }
    }
}

/// Operation shape for `RegisterApplicationRevision`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`register_application_revision`](crate::client::Client::register_application_revision).
///
/// See [`crate::client::fluent_builders::RegisterApplicationRevision`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct RegisterApplicationRevision {
    _private: (),
}
impl RegisterApplicationRevision {
    /// Creates a new builder-style object to manufacture [`RegisterApplicationRevisionInput`](crate::input::RegisterApplicationRevisionInput)
    pub fn builder() -> crate::input::register_application_revision_input::Builder {
        crate::input::register_application_revision_input::Builder::default()
    }
    /// Creates a new `RegisterApplicationRevision` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for RegisterApplicationRevision {
    type Output = std::result::Result<
        crate::output::RegisterApplicationRevisionOutput,
        crate::error::RegisterApplicationRevisionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_register_application_revision_error(response)
        } else {
            crate::operation_deser::parse_register_application_revision_response(response)
        }
    }
}

/// Operation shape for `RegisterOnPremisesInstance`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`register_on_premises_instance`](crate::client::Client::register_on_premises_instance).
///
/// See [`crate::client::fluent_builders::RegisterOnPremisesInstance`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct RegisterOnPremisesInstance {
    _private: (),
}
impl RegisterOnPremisesInstance {
    /// Creates a new builder-style object to manufacture [`RegisterOnPremisesInstanceInput`](crate::input::RegisterOnPremisesInstanceInput)
    pub fn builder() -> crate::input::register_on_premises_instance_input::Builder {
        crate::input::register_on_premises_instance_input::Builder::default()
    }
    /// Creates a new `RegisterOnPremisesInstance` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for RegisterOnPremisesInstance {
    type Output = std::result::Result<
        crate::output::RegisterOnPremisesInstanceOutput,
        crate::error::RegisterOnPremisesInstanceError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_register_on_premises_instance_error(response)
        } else {
            crate::operation_deser::parse_register_on_premises_instance_response(response)
        }
    }
}

/// Operation shape for `RemoveTagsFromOnPremisesInstances`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`remove_tags_from_on_premises_instances`](crate::client::Client::remove_tags_from_on_premises_instances).
///
/// See [`crate::client::fluent_builders::RemoveTagsFromOnPremisesInstances`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct RemoveTagsFromOnPremisesInstances {
    _private: (),
}
impl RemoveTagsFromOnPremisesInstances {
    /// Creates a new builder-style object to manufacture [`RemoveTagsFromOnPremisesInstancesInput`](crate::input::RemoveTagsFromOnPremisesInstancesInput)
    pub fn builder() -> crate::input::remove_tags_from_on_premises_instances_input::Builder {
        crate::input::remove_tags_from_on_premises_instances_input::Builder::default()
    }
    /// Creates a new `RemoveTagsFromOnPremisesInstances` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for RemoveTagsFromOnPremisesInstances {
    type Output = std::result::Result<
        crate::output::RemoveTagsFromOnPremisesInstancesOutput,
        crate::error::RemoveTagsFromOnPremisesInstancesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_remove_tags_from_on_premises_instances_error(response)
        } else {
            crate::operation_deser::parse_remove_tags_from_on_premises_instances_response(response)
        }
    }
}

/// Operation shape for `SkipWaitTimeForInstanceTermination`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`skip_wait_time_for_instance_termination`](crate::client::Client::skip_wait_time_for_instance_termination).
///
/// See [`crate::client::fluent_builders::SkipWaitTimeForInstanceTermination`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct SkipWaitTimeForInstanceTermination {
    _private: (),
}
impl SkipWaitTimeForInstanceTermination {
    /// Creates a new builder-style object to manufacture [`SkipWaitTimeForInstanceTerminationInput`](crate::input::SkipWaitTimeForInstanceTerminationInput)
    pub fn builder() -> crate::input::skip_wait_time_for_instance_termination_input::Builder {
        crate::input::skip_wait_time_for_instance_termination_input::Builder::default()
    }
    /// Creates a new `SkipWaitTimeForInstanceTermination` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for SkipWaitTimeForInstanceTermination {
    type Output = std::result::Result<
        crate::output::SkipWaitTimeForInstanceTerminationOutput,
        crate::error::SkipWaitTimeForInstanceTerminationError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_skip_wait_time_for_instance_termination_error(response)
        } else {
            crate::operation_deser::parse_skip_wait_time_for_instance_termination_response(response)
        }
    }
}

/// Operation shape for `StopDeployment`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`stop_deployment`](crate::client::Client::stop_deployment).
///
/// See [`crate::client::fluent_builders::StopDeployment`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct StopDeployment {
    _private: (),
}
impl StopDeployment {
    /// Creates a new builder-style object to manufacture [`StopDeploymentInput`](crate::input::StopDeploymentInput)
    pub fn builder() -> crate::input::stop_deployment_input::Builder {
        crate::input::stop_deployment_input::Builder::default()
    }
    /// Creates a new `StopDeployment` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for StopDeployment {
    type Output =
        std::result::Result<crate::output::StopDeploymentOutput, crate::error::StopDeploymentError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_stop_deployment_error(response)
        } else {
            crate::operation_deser::parse_stop_deployment_response(response)
        }
    }
}

/// Operation shape for `TagResource`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`tag_resource`](crate::client::Client::tag_resource).
///
/// See [`crate::client::fluent_builders::TagResource`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct TagResource {
    _private: (),
}
impl TagResource {
    /// Creates a new builder-style object to manufacture [`TagResourceInput`](crate::input::TagResourceInput)
    pub fn builder() -> crate::input::tag_resource_input::Builder {
        crate::input::tag_resource_input::Builder::default()
    }
    /// Creates a new `TagResource` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for TagResource {
    type Output =
        std::result::Result<crate::output::TagResourceOutput, crate::error::TagResourceError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_tag_resource_error(response)
        } else {
            crate::operation_deser::parse_tag_resource_response(response)
        }
    }
}

/// Operation shape for `UntagResource`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`untag_resource`](crate::client::Client::untag_resource).
///
/// See [`crate::client::fluent_builders::UntagResource`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UntagResource {
    _private: (),
}
impl UntagResource {
    /// Creates a new builder-style object to manufacture [`UntagResourceInput`](crate::input::UntagResourceInput)
    pub fn builder() -> crate::input::untag_resource_input::Builder {
        crate::input::untag_resource_input::Builder::default()
    }
    /// Creates a new `UntagResource` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UntagResource {
    type Output =
        std::result::Result<crate::output::UntagResourceOutput, crate::error::UntagResourceError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_untag_resource_error(response)
        } else {
            crate::operation_deser::parse_untag_resource_response(response)
        }
    }
}

/// Operation shape for `UpdateApplication`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_application`](crate::client::Client::update_application).
///
/// See [`crate::client::fluent_builders::UpdateApplication`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UpdateApplication {
    _private: (),
}
impl UpdateApplication {
    /// Creates a new builder-style object to manufacture [`UpdateApplicationInput`](crate::input::UpdateApplicationInput)
    pub fn builder() -> crate::input::update_application_input::Builder {
        crate::input::update_application_input::Builder::default()
    }
    /// Creates a new `UpdateApplication` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateApplication {
    type Output = std::result::Result<
        crate::output::UpdateApplicationOutput,
        crate::error::UpdateApplicationError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_application_error(response)
        } else {
            crate::operation_deser::parse_update_application_response(response)
        }
    }
}

/// Operation shape for `UpdateDeploymentGroup`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_deployment_group`](crate::client::Client::update_deployment_group).
///
/// See [`crate::client::fluent_builders::UpdateDeploymentGroup`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UpdateDeploymentGroup {
    _private: (),
}
impl UpdateDeploymentGroup {
    /// Creates a new builder-style object to manufacture [`UpdateDeploymentGroupInput`](crate::input::UpdateDeploymentGroupInput)
    pub fn builder() -> crate::input::update_deployment_group_input::Builder {
        crate::input::update_deployment_group_input::Builder::default()
    }
    /// Creates a new `UpdateDeploymentGroup` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateDeploymentGroup {
    type Output = std::result::Result<
        crate::output::UpdateDeploymentGroupOutput,
        crate::error::UpdateDeploymentGroupError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_deployment_group_error(response)
        } else {
            crate::operation_deser::parse_update_deployment_group_response(response)
        }
    }
}