aws-sdk-iotfleetwise 0.5.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Operation shape for `ListSignalCatalogs`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_signal_catalogs`](crate::client::Client::list_signal_catalogs).
///
/// See [`crate::client::fluent_builders::ListSignalCatalogs`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListSignalCatalogs {
    _private: (),
}
impl ListSignalCatalogs {
    /// Creates a new builder-style object to manufacture [`ListSignalCatalogsInput`](crate::input::ListSignalCatalogsInput).
    pub fn builder() -> crate::input::list_signal_catalogs_input::Builder {
        crate::input::list_signal_catalogs_input::Builder::default()
    }
    /// Creates a new `ListSignalCatalogs` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListSignalCatalogs {
    type Output = std::result::Result<
        crate::output::ListSignalCatalogsOutput,
        crate::error::ListSignalCatalogsError,
    >;
    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_signal_catalogs_error(response)
        } else {
            crate::operation_deser::parse_list_signal_catalogs_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 `ListVehicles`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_vehicles`](crate::client::Client::list_vehicles).
///
/// See [`crate::client::fluent_builders::ListVehicles`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListVehicles {
    _private: (),
}
impl ListVehicles {
    /// Creates a new builder-style object to manufacture [`ListVehiclesInput`](crate::input::ListVehiclesInput).
    pub fn builder() -> crate::input::list_vehicles_input::Builder {
        crate::input::list_vehicles_input::Builder::default()
    }
    /// Creates a new `ListVehicles` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListVehicles {
    type Output =
        std::result::Result<crate::output::ListVehiclesOutput, crate::error::ListVehiclesError>;
    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_vehicles_error(response)
        } else {
            crate::operation_deser::parse_list_vehicles_response(response)
        }
    }
}

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

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

/// Operation shape for `RegisterAccount`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`register_account`](crate::client::Client::register_account).
///
/// See [`crate::client::fluent_builders::RegisterAccount`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct RegisterAccount {
    _private: (),
}
impl RegisterAccount {
    /// Creates a new builder-style object to manufacture [`RegisterAccountInput`](crate::input::RegisterAccountInput).
    pub fn builder() -> crate::input::register_account_input::Builder {
        crate::input::register_account_input::Builder::default()
    }
    /// Creates a new `RegisterAccount` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for RegisterAccount {
    type Output = std::result::Result<
        crate::output::RegisterAccountOutput,
        crate::error::RegisterAccountError,
    >;
    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_account_error(response)
        } else {
            crate::operation_deser::parse_register_account_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 `UpdateCampaign`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_campaign`](crate::client::Client::update_campaign).
///
/// See [`crate::client::fluent_builders::UpdateCampaign`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateCampaign {
    _private: (),
}
impl UpdateCampaign {
    /// Creates a new builder-style object to manufacture [`UpdateCampaignInput`](crate::input::UpdateCampaignInput).
    pub fn builder() -> crate::input::update_campaign_input::Builder {
        crate::input::update_campaign_input::Builder::default()
    }
    /// Creates a new `UpdateCampaign` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateCampaign {
    type Output =
        std::result::Result<crate::output::UpdateCampaignOutput, crate::error::UpdateCampaignError>;
    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_campaign_error(response)
        } else {
            crate::operation_deser::parse_update_campaign_response(response)
        }
    }
}

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

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

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

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

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

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