aws-sdk-kinesisanalyticsv2 0.24.0

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

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

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

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

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

/// Operation shape for `AddApplicationVpcConfiguration`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`add_application_vpc_configuration`](crate::client::Client::add_application_vpc_configuration).
///
/// See [`crate::client::fluent_builders::AddApplicationVpcConfiguration`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct AddApplicationVpcConfiguration {
    _private: (),
}
impl AddApplicationVpcConfiguration {
    /// Creates a new builder-style object to manufacture [`AddApplicationVpcConfigurationInput`](crate::input::AddApplicationVpcConfigurationInput).
    pub fn builder() -> crate::input::add_application_vpc_configuration_input::Builder {
        crate::input::add_application_vpc_configuration_input::Builder::default()
    }
    /// Creates a new `AddApplicationVpcConfiguration` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for AddApplicationVpcConfiguration {
    type Output = std::result::Result<
        crate::output::AddApplicationVpcConfigurationOutput,
        crate::error::AddApplicationVpcConfigurationError,
    >;
    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_application_vpc_configuration_error(response)
        } else {
            crate::operation_deser::parse_add_application_vpc_configuration_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::clone::Clone, std::default::Default, 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 `CreateApplicationPresignedUrl`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_application_presigned_url`](crate::client::Client::create_application_presigned_url).
///
/// See [`crate::client::fluent_builders::CreateApplicationPresignedUrl`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateApplicationPresignedUrl {
    _private: (),
}
impl CreateApplicationPresignedUrl {
    /// Creates a new builder-style object to manufacture [`CreateApplicationPresignedUrlInput`](crate::input::CreateApplicationPresignedUrlInput).
    pub fn builder() -> crate::input::create_application_presigned_url_input::Builder {
        crate::input::create_application_presigned_url_input::Builder::default()
    }
    /// Creates a new `CreateApplicationPresignedUrl` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateApplicationPresignedUrl {
    type Output = std::result::Result<
        crate::output::CreateApplicationPresignedUrlOutput,
        crate::error::CreateApplicationPresignedUrlError,
    >;
    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_presigned_url_error(response)
        } else {
            crate::operation_deser::parse_create_application_presigned_url_response(response)
        }
    }
}

/// Operation shape for `CreateApplicationSnapshot`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_application_snapshot`](crate::client::Client::create_application_snapshot).
///
/// See [`crate::client::fluent_builders::CreateApplicationSnapshot`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateApplicationSnapshot {
    _private: (),
}
impl CreateApplicationSnapshot {
    /// Creates a new builder-style object to manufacture [`CreateApplicationSnapshotInput`](crate::input::CreateApplicationSnapshotInput).
    pub fn builder() -> crate::input::create_application_snapshot_input::Builder {
        crate::input::create_application_snapshot_input::Builder::default()
    }
    /// Creates a new `CreateApplicationSnapshot` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateApplicationSnapshot {
    type Output = std::result::Result<
        crate::output::CreateApplicationSnapshotOutput,
        crate::error::CreateApplicationSnapshotError,
    >;
    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_snapshot_error(response)
        } else {
            crate::operation_deser::parse_create_application_snapshot_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::clone::Clone, std::default::Default, 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 `DeleteApplicationCloudWatchLoggingOption`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_application_cloud_watch_logging_option`](crate::client::Client::delete_application_cloud_watch_logging_option).
///
/// See [`crate::client::fluent_builders::DeleteApplicationCloudWatchLoggingOption`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteApplicationCloudWatchLoggingOption {
    _private: (),
}
impl DeleteApplicationCloudWatchLoggingOption {
    /// Creates a new builder-style object to manufacture [`DeleteApplicationCloudWatchLoggingOptionInput`](crate::input::DeleteApplicationCloudWatchLoggingOptionInput).
    pub fn builder() -> crate::input::delete_application_cloud_watch_logging_option_input::Builder {
        crate::input::delete_application_cloud_watch_logging_option_input::Builder::default()
    }
    /// Creates a new `DeleteApplicationCloudWatchLoggingOption` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteApplicationCloudWatchLoggingOption {
    type Output = std::result::Result<
        crate::output::DeleteApplicationCloudWatchLoggingOptionOutput,
        crate::error::DeleteApplicationCloudWatchLoggingOptionError,
    >;
    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_cloud_watch_logging_option_error(
                response,
            )
        } else {
            crate::operation_deser::parse_delete_application_cloud_watch_logging_option_response(
                response,
            )
        }
    }
}

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

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

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

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

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

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

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

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

/// Operation shape for `DiscoverInputSchema`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`discover_input_schema`](crate::client::Client::discover_input_schema).
///
/// See [`crate::client::fluent_builders::DiscoverInputSchema`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DiscoverInputSchema {
    _private: (),
}
impl DiscoverInputSchema {
    /// Creates a new builder-style object to manufacture [`DiscoverInputSchemaInput`](crate::input::DiscoverInputSchemaInput).
    pub fn builder() -> crate::input::discover_input_schema_input::Builder {
        crate::input::discover_input_schema_input::Builder::default()
    }
    /// Creates a new `DiscoverInputSchema` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DiscoverInputSchema {
    type Output = std::result::Result<
        crate::output::DiscoverInputSchemaOutput,
        crate::error::DiscoverInputSchemaError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_discover_input_schema_error(response)
        } else {
            crate::operation_deser::parse_discover_input_schema_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::clone::Clone, std::default::Default, 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 `ListApplicationSnapshots`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_application_snapshots`](crate::client::Client::list_application_snapshots).
///
/// See [`crate::client::fluent_builders::ListApplicationSnapshots`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListApplicationSnapshots {
    _private: (),
}
impl ListApplicationSnapshots {
    /// Creates a new builder-style object to manufacture [`ListApplicationSnapshotsInput`](crate::input::ListApplicationSnapshotsInput).
    pub fn builder() -> crate::input::list_application_snapshots_input::Builder {
        crate::input::list_application_snapshots_input::Builder::default()
    }
    /// Creates a new `ListApplicationSnapshots` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListApplicationSnapshots {
    type Output = std::result::Result<
        crate::output::ListApplicationSnapshotsOutput,
        crate::error::ListApplicationSnapshotsError,
    >;
    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_snapshots_error(response)
        } else {
            crate::operation_deser::parse_list_application_snapshots_response(response)
        }
    }
}

/// Operation shape for `ListApplicationVersions`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_application_versions`](crate::client::Client::list_application_versions).
///
/// See [`crate::client::fluent_builders::ListApplicationVersions`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListApplicationVersions {
    _private: (),
}
impl ListApplicationVersions {
    /// Creates a new builder-style object to manufacture [`ListApplicationVersionsInput`](crate::input::ListApplicationVersionsInput).
    pub fn builder() -> crate::input::list_application_versions_input::Builder {
        crate::input::list_application_versions_input::Builder::default()
    }
    /// Creates a new `ListApplicationVersions` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListApplicationVersions {
    type Output = std::result::Result<
        crate::output::ListApplicationVersionsOutput,
        crate::error::ListApplicationVersionsError,
    >;
    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_versions_error(response)
        } else {
            crate::operation_deser::parse_list_application_versions_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::clone::Clone, std::default::Default, 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 `RollbackApplication`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`rollback_application`](crate::client::Client::rollback_application).
///
/// See [`crate::client::fluent_builders::RollbackApplication`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct RollbackApplication {
    _private: (),
}
impl RollbackApplication {
    /// Creates a new builder-style object to manufacture [`RollbackApplicationInput`](crate::input::RollbackApplicationInput).
    pub fn builder() -> crate::input::rollback_application_input::Builder {
        crate::input::rollback_application_input::Builder::default()
    }
    /// Creates a new `RollbackApplication` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for RollbackApplication {
    type Output = std::result::Result<
        crate::output::RollbackApplicationOutput,
        crate::error::RollbackApplicationError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_rollback_application_error(response)
        } else {
            crate::operation_deser::parse_rollback_application_response(response)
        }
    }
}

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

/// Operation shape for `StopApplication`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`stop_application`](crate::client::Client::stop_application).
///
/// See [`crate::client::fluent_builders::StopApplication`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct StopApplication {
    _private: (),
}
impl StopApplication {
    /// Creates a new builder-style object to manufacture [`StopApplicationInput`](crate::input::StopApplicationInput).
    pub fn builder() -> crate::input::stop_application_input::Builder {
        crate::input::stop_application_input::Builder::default()
    }
    /// Creates a new `StopApplication` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for StopApplication {
    type Output = std::result::Result<
        crate::output::StopApplicationOutput,
        crate::error::StopApplicationError,
    >;
    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_application_error(response)
        } else {
            crate::operation_deser::parse_stop_application_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::clone::Clone, std::default::Default, 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::clone::Clone, std::default::Default, 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::clone::Clone, std::default::Default, 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 `UpdateApplicationMaintenanceConfiguration`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_application_maintenance_configuration`](crate::client::Client::update_application_maintenance_configuration).
///
/// See [`crate::client::fluent_builders::UpdateApplicationMaintenanceConfiguration`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateApplicationMaintenanceConfiguration {
    _private: (),
}
impl UpdateApplicationMaintenanceConfiguration {
    /// Creates a new builder-style object to manufacture [`UpdateApplicationMaintenanceConfigurationInput`](crate::input::UpdateApplicationMaintenanceConfigurationInput).
    pub fn builder() -> crate::input::update_application_maintenance_configuration_input::Builder {
        crate::input::update_application_maintenance_configuration_input::Builder::default()
    }
    /// Creates a new `UpdateApplicationMaintenanceConfiguration` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateApplicationMaintenanceConfiguration {
    type Output = std::result::Result<
        crate::output::UpdateApplicationMaintenanceConfigurationOutput,
        crate::error::UpdateApplicationMaintenanceConfigurationError,
    >;
    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_maintenance_configuration_error(
                response,
            )
        } else {
            crate::operation_deser::parse_update_application_maintenance_configuration_response(
                response,
            )
        }
    }
}

/// Operation customization and supporting types
pub mod customize;