pub fn add_headers_start_call_analytics_stream_transcription(
input: &crate::input::StartCallAnalyticsStreamTranscriptionInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_1) = &input.language_code {
let formatted_2 = inner_1.as_str();
if !formatted_2.is_empty() {
let header_value = formatted_2;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"language_code",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-language-code", header_value);
}
}
if let Some(inner_3) = &input.media_sample_rate_hertz {
let mut encoder = aws_smithy_types::primitive::Encoder::from(*inner_3);
let formatted_4 = encoder.encode();
if !formatted_4.is_empty() {
let header_value = formatted_4;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"media_sample_rate_hertz",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-sample-rate", header_value);
}
}
if let Some(inner_5) = &input.media_encoding {
let formatted_6 = inner_5.as_str();
if !formatted_6.is_empty() {
let header_value = formatted_6;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"media_encoding",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-media-encoding", header_value);
}
}
if let Some(inner_7) = &input.vocabulary_name {
let formatted_8 = inner_7.as_str();
if !formatted_8.is_empty() {
let header_value = formatted_8;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"vocabulary_name",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-vocabulary-name", header_value);
}
}
if let Some(inner_9) = &input.session_id {
let formatted_10 = inner_9.as_str();
if !formatted_10.is_empty() {
let header_value = formatted_10;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"session_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-session-id", header_value);
}
}
if let Some(inner_11) = &input.vocabulary_filter_name {
let formatted_12 = inner_11.as_str();
if !formatted_12.is_empty() {
let header_value = formatted_12;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"vocabulary_filter_name",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-vocabulary-filter-name", header_value);
}
}
if let Some(inner_13) = &input.vocabulary_filter_method {
let formatted_14 = inner_13.as_str();
if !formatted_14.is_empty() {
let header_value = formatted_14;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"vocabulary_filter_method",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-vocabulary-filter-method", header_value);
}
}
if let Some(inner_15) = &input.language_model_name {
let formatted_16 = inner_15.as_str();
if !formatted_16.is_empty() {
let header_value = formatted_16;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"language_model_name",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-language-model-name", header_value);
}
}
if input.enable_partial_results_stabilization {
let mut encoder =
aws_smithy_types::primitive::Encoder::from(input.enable_partial_results_stabilization);
let formatted_17 = encoder.encode();
if !formatted_17.is_empty() {
let header_value = formatted_17;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"enable_partial_results_stabilization",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amzn-transcribe-enable-partial-results-stabilization",
header_value,
);
}
}
if let Some(inner_18) = &input.partial_results_stability {
let formatted_19 = inner_18.as_str();
if !formatted_19.is_empty() {
let header_value = formatted_19;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"partial_results_stability",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-partial-results-stability", header_value);
}
}
if let Some(inner_20) = &input.content_identification_type {
let formatted_21 = inner_20.as_str();
if !formatted_21.is_empty() {
let header_value = formatted_21;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_identification_type",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amzn-transcribe-content-identification-type",
header_value,
);
}
}
if let Some(inner_22) = &input.content_redaction_type {
let formatted_23 = inner_22.as_str();
if !formatted_23.is_empty() {
let header_value = formatted_23;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_redaction_type",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-content-redaction-type", header_value);
}
}
if let Some(inner_24) = &input.pii_entity_types {
let formatted_25 = inner_24.as_str();
if !formatted_25.is_empty() {
let header_value = formatted_25;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"pii_entity_types",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-pii-entity-types", header_value);
}
}
Ok(builder)
}
pub fn add_headers_start_medical_stream_transcription(
input: &crate::input::StartMedicalStreamTranscriptionInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_26) = &input.language_code {
let formatted_27 = inner_26.as_str();
if !formatted_27.is_empty() {
let header_value = formatted_27;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"language_code",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-language-code", header_value);
}
}
if let Some(inner_28) = &input.media_sample_rate_hertz {
let mut encoder = aws_smithy_types::primitive::Encoder::from(*inner_28);
let formatted_29 = encoder.encode();
if !formatted_29.is_empty() {
let header_value = formatted_29;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"media_sample_rate_hertz",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-sample-rate", header_value);
}
}
if let Some(inner_30) = &input.media_encoding {
let formatted_31 = inner_30.as_str();
if !formatted_31.is_empty() {
let header_value = formatted_31;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"media_encoding",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-media-encoding", header_value);
}
}
if let Some(inner_32) = &input.vocabulary_name {
let formatted_33 = inner_32.as_str();
if !formatted_33.is_empty() {
let header_value = formatted_33;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"vocabulary_name",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-vocabulary-name", header_value);
}
}
if let Some(inner_34) = &input.specialty {
let formatted_35 = inner_34.as_str();
if !formatted_35.is_empty() {
let header_value = formatted_35;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"specialty",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-specialty", header_value);
}
}
if let Some(inner_36) = &input.r#type {
let formatted_37 = inner_36.as_str();
if !formatted_37.is_empty() {
let header_value = formatted_37;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"r#type",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-type", header_value);
}
}
if input.show_speaker_label {
let mut encoder = aws_smithy_types::primitive::Encoder::from(input.show_speaker_label);
let formatted_38 = encoder.encode();
if !formatted_38.is_empty() {
let header_value = formatted_38;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"show_speaker_label",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-show-speaker-label", header_value);
}
}
if let Some(inner_39) = &input.session_id {
let formatted_40 = inner_39.as_str();
if !formatted_40.is_empty() {
let header_value = formatted_40;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"session_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-session-id", header_value);
}
}
if input.enable_channel_identification {
let mut encoder =
aws_smithy_types::primitive::Encoder::from(input.enable_channel_identification);
let formatted_41 = encoder.encode();
if !formatted_41.is_empty() {
let header_value = formatted_41;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"enable_channel_identification",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amzn-transcribe-enable-channel-identification",
header_value,
);
}
}
if let Some(inner_42) = &input.number_of_channels {
let mut encoder = aws_smithy_types::primitive::Encoder::from(*inner_42);
let formatted_43 = encoder.encode();
if !formatted_43.is_empty() {
let header_value = formatted_43;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"number_of_channels",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-number-of-channels", header_value);
}
}
if let Some(inner_44) = &input.content_identification_type {
let formatted_45 = inner_44.as_str();
if !formatted_45.is_empty() {
let header_value = formatted_45;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_identification_type",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amzn-transcribe-content-identification-type",
header_value,
);
}
}
Ok(builder)
}
pub fn add_headers_start_stream_transcription(
input: &crate::input::StartStreamTranscriptionInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_46) = &input.language_code {
let formatted_47 = inner_46.as_str();
if !formatted_47.is_empty() {
let header_value = formatted_47;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"language_code",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-language-code", header_value);
}
}
if let Some(inner_48) = &input.media_sample_rate_hertz {
let mut encoder = aws_smithy_types::primitive::Encoder::from(*inner_48);
let formatted_49 = encoder.encode();
if !formatted_49.is_empty() {
let header_value = formatted_49;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"media_sample_rate_hertz",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-sample-rate", header_value);
}
}
if let Some(inner_50) = &input.media_encoding {
let formatted_51 = inner_50.as_str();
if !formatted_51.is_empty() {
let header_value = formatted_51;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"media_encoding",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-media-encoding", header_value);
}
}
if let Some(inner_52) = &input.vocabulary_name {
let formatted_53 = inner_52.as_str();
if !formatted_53.is_empty() {
let header_value = formatted_53;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"vocabulary_name",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-vocabulary-name", header_value);
}
}
if let Some(inner_54) = &input.session_id {
let formatted_55 = inner_54.as_str();
if !formatted_55.is_empty() {
let header_value = formatted_55;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"session_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-session-id", header_value);
}
}
if let Some(inner_56) = &input.vocabulary_filter_name {
let formatted_57 = inner_56.as_str();
if !formatted_57.is_empty() {
let header_value = formatted_57;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"vocabulary_filter_name",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-vocabulary-filter-name", header_value);
}
}
if let Some(inner_58) = &input.vocabulary_filter_method {
let formatted_59 = inner_58.as_str();
if !formatted_59.is_empty() {
let header_value = formatted_59;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"vocabulary_filter_method",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-vocabulary-filter-method", header_value);
}
}
if input.show_speaker_label {
let mut encoder = aws_smithy_types::primitive::Encoder::from(input.show_speaker_label);
let formatted_60 = encoder.encode();
if !formatted_60.is_empty() {
let header_value = formatted_60;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"show_speaker_label",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-show-speaker-label", header_value);
}
}
if input.enable_channel_identification {
let mut encoder =
aws_smithy_types::primitive::Encoder::from(input.enable_channel_identification);
let formatted_61 = encoder.encode();
if !formatted_61.is_empty() {
let header_value = formatted_61;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"enable_channel_identification",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amzn-transcribe-enable-channel-identification",
header_value,
);
}
}
if let Some(inner_62) = &input.number_of_channels {
let mut encoder = aws_smithy_types::primitive::Encoder::from(*inner_62);
let formatted_63 = encoder.encode();
if !formatted_63.is_empty() {
let header_value = formatted_63;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"number_of_channels",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-number-of-channels", header_value);
}
}
if input.enable_partial_results_stabilization {
let mut encoder =
aws_smithy_types::primitive::Encoder::from(input.enable_partial_results_stabilization);
let formatted_64 = encoder.encode();
if !formatted_64.is_empty() {
let header_value = formatted_64;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"enable_partial_results_stabilization",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amzn-transcribe-enable-partial-results-stabilization",
header_value,
);
}
}
if let Some(inner_65) = &input.partial_results_stability {
let formatted_66 = inner_65.as_str();
if !formatted_66.is_empty() {
let header_value = formatted_66;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"partial_results_stability",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-partial-results-stability", header_value);
}
}
if let Some(inner_67) = &input.content_identification_type {
let formatted_68 = inner_67.as_str();
if !formatted_68.is_empty() {
let header_value = formatted_68;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_identification_type",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amzn-transcribe-content-identification-type",
header_value,
);
}
}
if let Some(inner_69) = &input.content_redaction_type {
let formatted_70 = inner_69.as_str();
if !formatted_70.is_empty() {
let header_value = formatted_70;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_redaction_type",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-content-redaction-type", header_value);
}
}
if let Some(inner_71) = &input.pii_entity_types {
let formatted_72 = inner_71.as_str();
if !formatted_72.is_empty() {
let header_value = formatted_72;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"pii_entity_types",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-pii-entity-types", header_value);
}
}
if let Some(inner_73) = &input.language_model_name {
let formatted_74 = inner_73.as_str();
if !formatted_74.is_empty() {
let header_value = formatted_74;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"language_model_name",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-language-model-name", header_value);
}
}
if input.identify_language {
let mut encoder = aws_smithy_types::primitive::Encoder::from(input.identify_language);
let formatted_75 = encoder.encode();
if !formatted_75.is_empty() {
let header_value = formatted_75;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"identify_language",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-identify-language", header_value);
}
}
if let Some(inner_76) = &input.language_options {
let formatted_77 = inner_76.as_str();
if !formatted_77.is_empty() {
let header_value = formatted_77;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"language_options",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-language-options", header_value);
}
}
if let Some(inner_78) = &input.preferred_language {
let formatted_79 = inner_78.as_str();
if !formatted_79.is_empty() {
let header_value = formatted_79;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"preferred_language",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-preferred-language", header_value);
}
}
if let Some(inner_80) = &input.vocabulary_names {
let formatted_81 = inner_80.as_str();
if !formatted_81.is_empty() {
let header_value = formatted_81;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"vocabulary_names",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-vocabulary-names", header_value);
}
}
if let Some(inner_82) = &input.vocabulary_filter_names {
let formatted_83 = inner_82.as_str();
if !formatted_83.is_empty() {
let header_value = formatted_83;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"vocabulary_filter_names",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amzn-transcribe-vocabulary-filter-names", header_value);
}
}
Ok(builder)
}
pub fn deser_payload_start_call_analytics_stream_transcription_start_call_analytics_stream_transcription_output_call_analytics_transcript_result_stream(
body: &mut aws_smithy_http::body::SdkBody,
) -> std::result::Result<
aws_smithy_http::event_stream::Receiver<
crate::model::CallAnalyticsTranscriptResultStream,
crate::error::CallAnalyticsTranscriptResultStreamError,
>,
crate::error::StartCallAnalyticsStreamTranscriptionError,
> {
let unmarshaller =
crate::event_stream_serde::CallAnalyticsTranscriptResultStreamUnmarshaller::new();
let body = std::mem::replace(body, aws_smithy_http::body::SdkBody::taken());
Ok(aws_smithy_http::event_stream::Receiver::new(
unmarshaller,
body,
))
}
pub(crate) fn deser_header_start_call_analytics_stream_transcription_start_call_analytics_stream_transcription_output_content_identification_type(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::ContentIdentificationType>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-content-identification-type")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_call_analytics_stream_transcription_start_call_analytics_stream_transcription_output_content_redaction_type(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::ContentRedactionType>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-content-redaction-type")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_call_analytics_stream_transcription_start_call_analytics_stream_transcription_output_enable_partial_results_stabilization(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
let headers = header_map
.get_all("x-amzn-transcribe-enable-partial-results-stabilization")
.iter();
let var_84 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
if var_84.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_84.len()
)))
} else {
let mut var_84 = var_84;
Ok(var_84.pop())
}
}
pub(crate) fn deser_header_start_call_analytics_stream_transcription_start_call_analytics_stream_transcription_output_language_code(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::CallAnalyticsLanguageCode>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amzn-transcribe-language-code").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_call_analytics_stream_transcription_start_call_analytics_stream_transcription_output_language_model_name(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-language-model-name")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_call_analytics_stream_transcription_start_call_analytics_stream_transcription_output_media_encoding(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::MediaEncoding>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-media-encoding")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_call_analytics_stream_transcription_start_call_analytics_stream_transcription_output_media_sample_rate_hertz(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
let headers = header_map.get_all("x-amzn-transcribe-sample-rate").iter();
let var_85 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
if var_85.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_85.len()
)))
} else {
let mut var_85 = var_85;
Ok(var_85.pop())
}
}
pub(crate) fn deser_header_start_call_analytics_stream_transcription_start_call_analytics_stream_transcription_output_partial_results_stability(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::PartialResultsStability>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-partial-results-stability")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_call_analytics_stream_transcription_start_call_analytics_stream_transcription_output_pii_entity_types(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-pii-entity-types")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_call_analytics_stream_transcription_start_call_analytics_stream_transcription_output_request_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amzn-request-id").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_call_analytics_stream_transcription_start_call_analytics_stream_transcription_output_session_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amzn-transcribe-session-id").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_call_analytics_stream_transcription_start_call_analytics_stream_transcription_output_vocabulary_filter_method(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::VocabularyFilterMethod>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-vocabulary-filter-method")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_call_analytics_stream_transcription_start_call_analytics_stream_transcription_output_vocabulary_filter_name(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-vocabulary-filter-name")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_call_analytics_stream_transcription_start_call_analytics_stream_transcription_output_vocabulary_name(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-vocabulary-name")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_medical_stream_transcription_start_medical_stream_transcription_output_content_identification_type(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::MedicalContentIdentificationType>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-content-identification-type")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_medical_stream_transcription_start_medical_stream_transcription_output_enable_channel_identification(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
let headers = header_map
.get_all("x-amzn-transcribe-enable-channel-identification")
.iter();
let var_86 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
if var_86.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_86.len()
)))
} else {
let mut var_86 = var_86;
Ok(var_86.pop())
}
}
pub(crate) fn deser_header_start_medical_stream_transcription_start_medical_stream_transcription_output_language_code(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::LanguageCode>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amzn-transcribe-language-code").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_medical_stream_transcription_start_medical_stream_transcription_output_media_encoding(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::MediaEncoding>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-media-encoding")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_medical_stream_transcription_start_medical_stream_transcription_output_media_sample_rate_hertz(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
let headers = header_map.get_all("x-amzn-transcribe-sample-rate").iter();
let var_87 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
if var_87.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_87.len()
)))
} else {
let mut var_87 = var_87;
Ok(var_87.pop())
}
}
pub(crate) fn deser_header_start_medical_stream_transcription_start_medical_stream_transcription_output_number_of_channels(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
let headers = header_map
.get_all("x-amzn-transcribe-number-of-channels")
.iter();
let var_88 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
if var_88.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_88.len()
)))
} else {
let mut var_88 = var_88;
Ok(var_88.pop())
}
}
pub(crate) fn deser_header_start_medical_stream_transcription_start_medical_stream_transcription_output_request_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amzn-request-id").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_medical_stream_transcription_start_medical_stream_transcription_output_session_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amzn-transcribe-session-id").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_medical_stream_transcription_start_medical_stream_transcription_output_show_speaker_label(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
let headers = header_map
.get_all("x-amzn-transcribe-show-speaker-label")
.iter();
let var_89 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
if var_89.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_89.len()
)))
} else {
let mut var_89 = var_89;
Ok(var_89.pop())
}
}
pub(crate) fn deser_header_start_medical_stream_transcription_start_medical_stream_transcription_output_specialty(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::Specialty>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amzn-transcribe-specialty").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub fn deser_payload_start_medical_stream_transcription_start_medical_stream_transcription_output_transcript_result_stream(
body: &mut aws_smithy_http::body::SdkBody,
) -> std::result::Result<
aws_smithy_http::event_stream::Receiver<
crate::model::MedicalTranscriptResultStream,
crate::error::MedicalTranscriptResultStreamError,
>,
crate::error::StartMedicalStreamTranscriptionError,
> {
let unmarshaller = crate::event_stream_serde::MedicalTranscriptResultStreamUnmarshaller::new();
let body = std::mem::replace(body, aws_smithy_http::body::SdkBody::taken());
Ok(aws_smithy_http::event_stream::Receiver::new(
unmarshaller,
body,
))
}
pub(crate) fn deser_header_start_medical_stream_transcription_start_medical_stream_transcription_output_type(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<crate::model::Type>, aws_smithy_http::header::ParseError>
{
let headers = header_map.get_all("x-amzn-transcribe-type").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_medical_stream_transcription_start_medical_stream_transcription_output_vocabulary_name(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-vocabulary-name")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_content_identification_type(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::ContentIdentificationType>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-content-identification-type")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_content_redaction_type(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::ContentRedactionType>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-content-redaction-type")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_enable_channel_identification(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
let headers = header_map
.get_all("x-amzn-transcribe-enable-channel-identification")
.iter();
let var_90 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
if var_90.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_90.len()
)))
} else {
let mut var_90 = var_90;
Ok(var_90.pop())
}
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_enable_partial_results_stabilization(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
let headers = header_map
.get_all("x-amzn-transcribe-enable-partial-results-stabilization")
.iter();
let var_91 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
if var_91.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_91.len()
)))
} else {
let mut var_91 = var_91;
Ok(var_91.pop())
}
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_identify_language(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
let headers = header_map
.get_all("x-amzn-transcribe-identify-language")
.iter();
let var_92 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
if var_92.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_92.len()
)))
} else {
let mut var_92 = var_92;
Ok(var_92.pop())
}
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_language_code(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::LanguageCode>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amzn-transcribe-language-code").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_language_model_name(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-language-model-name")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_language_options(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-language-options")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_media_encoding(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::MediaEncoding>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-media-encoding")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_media_sample_rate_hertz(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
let headers = header_map.get_all("x-amzn-transcribe-sample-rate").iter();
let var_93 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
if var_93.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_93.len()
)))
} else {
let mut var_93 = var_93;
Ok(var_93.pop())
}
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_number_of_channels(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
let headers = header_map
.get_all("x-amzn-transcribe-number-of-channels")
.iter();
let var_94 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
if var_94.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_94.len()
)))
} else {
let mut var_94 = var_94;
Ok(var_94.pop())
}
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_partial_results_stability(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::PartialResultsStability>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-partial-results-stability")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_pii_entity_types(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-pii-entity-types")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_preferred_language(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::LanguageCode>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-preferred-language")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_request_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amzn-request-id").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_session_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amzn-transcribe-session-id").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_show_speaker_label(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
let headers = header_map
.get_all("x-amzn-transcribe-show-speaker-label")
.iter();
let var_95 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
if var_95.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_95.len()
)))
} else {
let mut var_95 = var_95;
Ok(var_95.pop())
}
}
pub fn deser_payload_start_stream_transcription_start_stream_transcription_output_transcript_result_stream(
body: &mut aws_smithy_http::body::SdkBody,
) -> std::result::Result<
aws_smithy_http::event_stream::Receiver<
crate::model::TranscriptResultStream,
crate::error::TranscriptResultStreamError,
>,
crate::error::StartStreamTranscriptionError,
> {
let unmarshaller = crate::event_stream_serde::TranscriptResultStreamUnmarshaller::new();
let body = std::mem::replace(body, aws_smithy_http::body::SdkBody::taken());
Ok(aws_smithy_http::event_stream::Receiver::new(
unmarshaller,
body,
))
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_vocabulary_filter_method(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::VocabularyFilterMethod>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-vocabulary-filter-method")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_vocabulary_filter_name(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-vocabulary-filter-name")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_vocabulary_filter_names(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-vocabulary-filter-names")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_vocabulary_name(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-vocabulary-name")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_start_stream_transcription_start_stream_transcription_output_vocabulary_names(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amzn-transcribe-vocabulary-names")
.iter();
aws_smithy_http::header::one_or_none(headers)
}