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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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