aws-sdk-transcribe 0.5.2

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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