aws-sdk-devopsguru 0.0.25-alpha

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/// Operation shape for `AddNotificationChannel`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`add_notification_channel`](crate::client::Client::add_notification_channel).
///
/// See [`crate::client::fluent_builders::AddNotificationChannel`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct AddNotificationChannel {
    _private: (),
}
impl AddNotificationChannel {
    /// Creates a new builder-style object to manufacture [`AddNotificationChannelInput`](crate::input::AddNotificationChannelInput)
    pub fn builder() -> crate::input::add_notification_channel_input::Builder {
        crate::input::add_notification_channel_input::Builder::default()
    }
    /// Creates a new `AddNotificationChannel` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for AddNotificationChannel {
    type Output = std::result::Result<
        crate::output::AddNotificationChannelOutput,
        crate::error::AddNotificationChannelError,
    >;
    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_notification_channel_error(response)
        } else {
            crate::operation_deser::parse_add_notification_channel_response(response)
        }
    }
}

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

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

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

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

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

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

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

/// Operation shape for `GetCostEstimation`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_cost_estimation`](crate::client::Client::get_cost_estimation).
///
/// See [`crate::client::fluent_builders::GetCostEstimation`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetCostEstimation {
    _private: (),
}
impl GetCostEstimation {
    /// Creates a new builder-style object to manufacture [`GetCostEstimationInput`](crate::input::GetCostEstimationInput)
    pub fn builder() -> crate::input::get_cost_estimation_input::Builder {
        crate::input::get_cost_estimation_input::Builder::default()
    }
    /// Creates a new `GetCostEstimation` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetCostEstimation {
    type Output = std::result::Result<
        crate::output::GetCostEstimationOutput,
        crate::error::GetCostEstimationError,
    >;
    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_cost_estimation_error(response)
        } else {
            crate::operation_deser::parse_get_cost_estimation_response(response)
        }
    }
}

/// Operation shape for `GetResourceCollection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_resource_collection`](crate::client::Client::get_resource_collection).
///
/// See [`crate::client::fluent_builders::GetResourceCollection`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetResourceCollection {
    _private: (),
}
impl GetResourceCollection {
    /// Creates a new builder-style object to manufacture [`GetResourceCollectionInput`](crate::input::GetResourceCollectionInput)
    pub fn builder() -> crate::input::get_resource_collection_input::Builder {
        crate::input::get_resource_collection_input::Builder::default()
    }
    /// Creates a new `GetResourceCollection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetResourceCollection {
    type Output = std::result::Result<
        crate::output::GetResourceCollectionOutput,
        crate::error::GetResourceCollectionError,
    >;
    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_resource_collection_error(response)
        } else {
            crate::operation_deser::parse_get_resource_collection_response(response)
        }
    }
}

/// Operation shape for `ListAnomaliesForInsight`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_anomalies_for_insight`](crate::client::Client::list_anomalies_for_insight).
///
/// See [`crate::client::fluent_builders::ListAnomaliesForInsight`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListAnomaliesForInsight {
    _private: (),
}
impl ListAnomaliesForInsight {
    /// Creates a new builder-style object to manufacture [`ListAnomaliesForInsightInput`](crate::input::ListAnomaliesForInsightInput)
    pub fn builder() -> crate::input::list_anomalies_for_insight_input::Builder {
        crate::input::list_anomalies_for_insight_input::Builder::default()
    }
    /// Creates a new `ListAnomaliesForInsight` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListAnomaliesForInsight {
    type Output = std::result::Result<
        crate::output::ListAnomaliesForInsightOutput,
        crate::error::ListAnomaliesForInsightError,
    >;
    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_anomalies_for_insight_error(response)
        } else {
            crate::operation_deser::parse_list_anomalies_for_insight_response(response)
        }
    }
}

/// Operation shape for `ListEvents`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_events`](crate::client::Client::list_events).
///
/// See [`crate::client::fluent_builders::ListEvents`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListEvents {
    _private: (),
}
impl ListEvents {
    /// Creates a new builder-style object to manufacture [`ListEventsInput`](crate::input::ListEventsInput)
    pub fn builder() -> crate::input::list_events_input::Builder {
        crate::input::list_events_input::Builder::default()
    }
    /// Creates a new `ListEvents` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListEvents {
    type Output =
        std::result::Result<crate::output::ListEventsOutput, crate::error::ListEventsError>;
    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_events_error(response)
        } else {
            crate::operation_deser::parse_list_events_response(response)
        }
    }
}

/// Operation shape for `ListInsights`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_insights`](crate::client::Client::list_insights).
///
/// See [`crate::client::fluent_builders::ListInsights`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListInsights {
    _private: (),
}
impl ListInsights {
    /// Creates a new builder-style object to manufacture [`ListInsightsInput`](crate::input::ListInsightsInput)
    pub fn builder() -> crate::input::list_insights_input::Builder {
        crate::input::list_insights_input::Builder::default()
    }
    /// Creates a new `ListInsights` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListInsights {
    type Output =
        std::result::Result<crate::output::ListInsightsOutput, crate::error::ListInsightsError>;
    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_insights_error(response)
        } else {
            crate::operation_deser::parse_list_insights_response(response)
        }
    }
}

/// Operation shape for `ListNotificationChannels`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_notification_channels`](crate::client::Client::list_notification_channels).
///
/// See [`crate::client::fluent_builders::ListNotificationChannels`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListNotificationChannels {
    _private: (),
}
impl ListNotificationChannels {
    /// Creates a new builder-style object to manufacture [`ListNotificationChannelsInput`](crate::input::ListNotificationChannelsInput)
    pub fn builder() -> crate::input::list_notification_channels_input::Builder {
        crate::input::list_notification_channels_input::Builder::default()
    }
    /// Creates a new `ListNotificationChannels` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListNotificationChannels {
    type Output = std::result::Result<
        crate::output::ListNotificationChannelsOutput,
        crate::error::ListNotificationChannelsError,
    >;
    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_notification_channels_error(response)
        } else {
            crate::operation_deser::parse_list_notification_channels_response(response)
        }
    }
}

/// Operation shape for `ListRecommendations`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_recommendations`](crate::client::Client::list_recommendations).
///
/// See [`crate::client::fluent_builders::ListRecommendations`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListRecommendations {
    _private: (),
}
impl ListRecommendations {
    /// Creates a new builder-style object to manufacture [`ListRecommendationsInput`](crate::input::ListRecommendationsInput)
    pub fn builder() -> crate::input::list_recommendations_input::Builder {
        crate::input::list_recommendations_input::Builder::default()
    }
    /// Creates a new `ListRecommendations` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListRecommendations {
    type Output = std::result::Result<
        crate::output::ListRecommendationsOutput,
        crate::error::ListRecommendationsError,
    >;
    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_recommendations_error(response)
        } else {
            crate::operation_deser::parse_list_recommendations_response(response)
        }
    }
}

/// Operation shape for `PutFeedback`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`put_feedback`](crate::client::Client::put_feedback).
///
/// See [`crate::client::fluent_builders::PutFeedback`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct PutFeedback {
    _private: (),
}
impl PutFeedback {
    /// Creates a new builder-style object to manufacture [`PutFeedbackInput`](crate::input::PutFeedbackInput)
    pub fn builder() -> crate::input::put_feedback_input::Builder {
        crate::input::put_feedback_input::Builder::default()
    }
    /// Creates a new `PutFeedback` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for PutFeedback {
    type Output =
        std::result::Result<crate::output::PutFeedbackOutput, crate::error::PutFeedbackError>;
    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_feedback_error(response)
        } else {
            crate::operation_deser::parse_put_feedback_response(response)
        }
    }
}

/// Operation shape for `RemoveNotificationChannel`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`remove_notification_channel`](crate::client::Client::remove_notification_channel).
///
/// See [`crate::client::fluent_builders::RemoveNotificationChannel`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct RemoveNotificationChannel {
    _private: (),
}
impl RemoveNotificationChannel {
    /// Creates a new builder-style object to manufacture [`RemoveNotificationChannelInput`](crate::input::RemoveNotificationChannelInput)
    pub fn builder() -> crate::input::remove_notification_channel_input::Builder {
        crate::input::remove_notification_channel_input::Builder::default()
    }
    /// Creates a new `RemoveNotificationChannel` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for RemoveNotificationChannel {
    type Output = std::result::Result<
        crate::output::RemoveNotificationChannelOutput,
        crate::error::RemoveNotificationChannelError,
    >;
    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_notification_channel_error(response)
        } else {
            crate::operation_deser::parse_remove_notification_channel_response(response)
        }
    }
}

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

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

/// Operation shape for `UpdateResourceCollection`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_resource_collection`](crate::client::Client::update_resource_collection).
///
/// See [`crate::client::fluent_builders::UpdateResourceCollection`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UpdateResourceCollection {
    _private: (),
}
impl UpdateResourceCollection {
    /// Creates a new builder-style object to manufacture [`UpdateResourceCollectionInput`](crate::input::UpdateResourceCollectionInput)
    pub fn builder() -> crate::input::update_resource_collection_input::Builder {
        crate::input::update_resource_collection_input::Builder::default()
    }
    /// Creates a new `UpdateResourceCollection` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateResourceCollection {
    type Output = std::result::Result<
        crate::output::UpdateResourceCollectionOutput,
        crate::error::UpdateResourceCollectionError,
    >;
    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_resource_collection_error(response)
        } else {
            crate::operation_deser::parse_update_resource_collection_response(response)
        }
    }
}

/// Operation shape for `UpdateServiceIntegration`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_service_integration`](crate::client::Client::update_service_integration).
///
/// See [`crate::client::fluent_builders::UpdateServiceIntegration`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UpdateServiceIntegration {
    _private: (),
}
impl UpdateServiceIntegration {
    /// Creates a new builder-style object to manufacture [`UpdateServiceIntegrationInput`](crate::input::UpdateServiceIntegrationInput)
    pub fn builder() -> crate::input::update_service_integration_input::Builder {
        crate::input::update_service_integration_input::Builder::default()
    }
    /// Creates a new `UpdateServiceIntegration` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateServiceIntegration {
    type Output = std::result::Result<
        crate::output::UpdateServiceIntegrationOutput,
        crate::error::UpdateServiceIntegrationError,
    >;
    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_service_integration_error(response)
        } else {
            crate::operation_deser::parse_update_service_integration_response(response)
        }
    }
}