pub fn serialize_structure_crate_input_batch_create_custom_vocabulary_item_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchCreateCustomVocabularyItemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.custom_vocabulary_item_list {
let mut array_2 = object.key("customVocabularyItemList").start_array();
for item_3 in var_1 {
{
#[allow(unused_mut)]
let mut object_4 = array_2.value().start_object();
crate::json_ser::serialize_structure_crate_model_new_custom_vocabulary_item(
&mut object_4,
item_3,
)?;
object_4.finish();
}
}
array_2.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_delete_custom_vocabulary_item_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDeleteCustomVocabularyItemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_5) = &input.custom_vocabulary_item_list {
let mut array_6 = object.key("customVocabularyItemList").start_array();
for item_7 in var_5 {
{
#[allow(unused_mut)]
let mut object_8 = array_6.value().start_object();
crate::json_ser::serialize_structure_crate_model_custom_vocabulary_entry_id(
&mut object_8,
item_7,
)?;
object_8.finish();
}
}
array_6.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_update_custom_vocabulary_item_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchUpdateCustomVocabularyItemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_9) = &input.custom_vocabulary_item_list {
let mut array_10 = object.key("customVocabularyItemList").start_array();
for item_11 in var_9 {
{
#[allow(unused_mut)]
let mut object_12 = array_10.value().start_object();
crate::json_ser::serialize_structure_crate_model_custom_vocabulary_item(
&mut object_12,
item_11,
)?;
object_12.finish();
}
}
array_10.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_bot_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBotInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_13) = &input.bot_name {
object.key("botName").string(var_13.as_str());
}
if let Some(var_14) = &input.bot_tags {
#[allow(unused_mut)]
let mut object_15 = object.key("botTags").start_object();
for (key_16, value_17) in var_14 {
{
object_15.key(key_16.as_str()).string(value_17.as_str());
}
}
object_15.finish();
}
if let Some(var_18) = &input.data_privacy {
#[allow(unused_mut)]
let mut object_19 = object.key("dataPrivacy").start_object();
crate::json_ser::serialize_structure_crate_model_data_privacy(&mut object_19, var_18)?;
object_19.finish();
}
if let Some(var_20) = &input.description {
object.key("description").string(var_20.as_str());
}
if let Some(var_21) = &input.idle_session_ttl_in_seconds {
object.key("idleSessionTTLInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_21).into()),
);
}
if let Some(var_22) = &input.role_arn {
object.key("roleArn").string(var_22.as_str());
}
if let Some(var_23) = &input.test_bot_alias_tags {
#[allow(unused_mut)]
let mut object_24 = object.key("testBotAliasTags").start_object();
for (key_25, value_26) in var_23 {
{
object_24.key(key_25.as_str()).string(value_26.as_str());
}
}
object_24.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_bot_alias_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBotAliasInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_27) = &input.bot_alias_locale_settings {
#[allow(unused_mut)]
let mut object_28 = object.key("botAliasLocaleSettings").start_object();
for (key_29, value_30) in var_27 {
{
#[allow(unused_mut)]
let mut object_31 = object_28.key(key_29.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_bot_alias_locale_settings(
&mut object_31,
value_30,
)?;
object_31.finish();
}
}
object_28.finish();
}
if let Some(var_32) = &input.bot_alias_name {
object.key("botAliasName").string(var_32.as_str());
}
if let Some(var_33) = &input.bot_version {
object.key("botVersion").string(var_33.as_str());
}
if let Some(var_34) = &input.conversation_log_settings {
#[allow(unused_mut)]
let mut object_35 = object.key("conversationLogSettings").start_object();
crate::json_ser::serialize_structure_crate_model_conversation_log_settings(
&mut object_35,
var_34,
)?;
object_35.finish();
}
if let Some(var_36) = &input.description {
object.key("description").string(var_36.as_str());
}
if let Some(var_37) = &input.sentiment_analysis_settings {
#[allow(unused_mut)]
let mut object_38 = object.key("sentimentAnalysisSettings").start_object();
crate::json_ser::serialize_structure_crate_model_sentiment_analysis_settings(
&mut object_38,
var_37,
)?;
object_38.finish();
}
if let Some(var_39) = &input.tags {
#[allow(unused_mut)]
let mut object_40 = object.key("tags").start_object();
for (key_41, value_42) in var_39 {
{
object_40.key(key_41.as_str()).string(value_42.as_str());
}
}
object_40.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_bot_locale_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBotLocaleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_43) = &input.description {
object.key("description").string(var_43.as_str());
}
if let Some(var_44) = &input.locale_id {
object.key("localeId").string(var_44.as_str());
}
if let Some(var_45) = &input.nlu_intent_confidence_threshold {
object.key("nluIntentConfidenceThreshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_45).into()),
);
}
if let Some(var_46) = &input.voice_settings {
#[allow(unused_mut)]
let mut object_47 = object.key("voiceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_voice_settings(&mut object_47, var_46)?;
object_47.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_bot_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBotVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_48) = &input.bot_version_locale_specification {
#[allow(unused_mut)]
let mut object_49 = object.key("botVersionLocaleSpecification").start_object();
for (key_50, value_51) in var_48 {
{
#[allow(unused_mut)]
let mut object_52 = object_49.key(key_50.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_bot_version_locale_details(
&mut object_52,
value_51,
)?;
object_52.finish();
}
}
object_49.finish();
}
if let Some(var_53) = &input.description {
object.key("description").string(var_53.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_export_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateExportInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_54) = &input.file_format {
object.key("fileFormat").string(var_54.as_str());
}
if let Some(var_55) = &input.file_password {
object.key("filePassword").string(var_55.as_str());
}
if let Some(var_56) = &input.resource_specification {
#[allow(unused_mut)]
let mut object_57 = object.key("resourceSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_export_resource_specification(
&mut object_57,
var_56,
)?;
object_57.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_intent_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateIntentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_58) = &input.description {
object.key("description").string(var_58.as_str());
}
if let Some(var_59) = &input.dialog_code_hook {
#[allow(unused_mut)]
let mut object_60 = object.key("dialogCodeHook").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_code_hook_settings(
&mut object_60,
var_59,
)?;
object_60.finish();
}
if let Some(var_61) = &input.fulfillment_code_hook {
#[allow(unused_mut)]
let mut object_62 = object.key("fulfillmentCodeHook").start_object();
crate::json_ser::serialize_structure_crate_model_fulfillment_code_hook_settings(
&mut object_62,
var_61,
)?;
object_62.finish();
}
if let Some(var_63) = &input.initial_response_setting {
#[allow(unused_mut)]
let mut object_64 = object.key("initialResponseSetting").start_object();
crate::json_ser::serialize_structure_crate_model_initial_response_setting(
&mut object_64,
var_63,
)?;
object_64.finish();
}
if let Some(var_65) = &input.input_contexts {
let mut array_66 = object.key("inputContexts").start_array();
for item_67 in var_65 {
{
#[allow(unused_mut)]
let mut object_68 = array_66.value().start_object();
crate::json_ser::serialize_structure_crate_model_input_context(
&mut object_68,
item_67,
)?;
object_68.finish();
}
}
array_66.finish();
}
if let Some(var_69) = &input.intent_closing_setting {
#[allow(unused_mut)]
let mut object_70 = object.key("intentClosingSetting").start_object();
crate::json_ser::serialize_structure_crate_model_intent_closing_setting(
&mut object_70,
var_69,
)?;
object_70.finish();
}
if let Some(var_71) = &input.intent_confirmation_setting {
#[allow(unused_mut)]
let mut object_72 = object.key("intentConfirmationSetting").start_object();
crate::json_ser::serialize_structure_crate_model_intent_confirmation_setting(
&mut object_72,
var_71,
)?;
object_72.finish();
}
if let Some(var_73) = &input.intent_name {
object.key("intentName").string(var_73.as_str());
}
if let Some(var_74) = &input.kendra_configuration {
#[allow(unused_mut)]
let mut object_75 = object.key("kendraConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_kendra_configuration(
&mut object_75,
var_74,
)?;
object_75.finish();
}
if let Some(var_76) = &input.output_contexts {
let mut array_77 = object.key("outputContexts").start_array();
for item_78 in var_76 {
{
#[allow(unused_mut)]
let mut object_79 = array_77.value().start_object();
crate::json_ser::serialize_structure_crate_model_output_context(
&mut object_79,
item_78,
)?;
object_79.finish();
}
}
array_77.finish();
}
if let Some(var_80) = &input.parent_intent_signature {
object.key("parentIntentSignature").string(var_80.as_str());
}
if let Some(var_81) = &input.sample_utterances {
let mut array_82 = object.key("sampleUtterances").start_array();
for item_83 in var_81 {
{
#[allow(unused_mut)]
let mut object_84 = array_82.value().start_object();
crate::json_ser::serialize_structure_crate_model_sample_utterance(
&mut object_84,
item_83,
)?;
object_84.finish();
}
}
array_82.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateResourcePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.policy {
object.key("policy").string(var_85.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_resource_policy_statement_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateResourcePolicyStatementInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_86) = &input.action {
let mut array_87 = object.key("action").start_array();
for item_88 in var_86 {
{
array_87.value().string(item_88.as_str());
}
}
array_87.finish();
}
if let Some(var_89) = &input.condition {
#[allow(unused_mut)]
let mut object_90 = object.key("condition").start_object();
for (key_91, value_92) in var_89 {
{
#[allow(unused_mut)]
let mut object_93 = object_90.key(key_91.as_str()).start_object();
for (key_94, value_95) in value_92 {
{
object_93.key(key_94.as_str()).string(value_95.as_str());
}
}
object_93.finish();
}
}
object_90.finish();
}
if let Some(var_96) = &input.effect {
object.key("effect").string(var_96.as_str());
}
if let Some(var_97) = &input.principal {
let mut array_98 = object.key("principal").start_array();
for item_99 in var_97 {
{
#[allow(unused_mut)]
let mut object_100 = array_98.value().start_object();
crate::json_ser::serialize_structure_crate_model_principal(
&mut object_100,
item_99,
)?;
object_100.finish();
}
}
array_98.finish();
}
if let Some(var_101) = &input.statement_id {
object.key("statementId").string(var_101.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_slot_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSlotInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_102) = &input.description {
object.key("description").string(var_102.as_str());
}
if let Some(var_103) = &input.multiple_values_setting {
#[allow(unused_mut)]
let mut object_104 = object.key("multipleValuesSetting").start_object();
crate::json_ser::serialize_structure_crate_model_multiple_values_setting(
&mut object_104,
var_103,
)?;
object_104.finish();
}
if let Some(var_105) = &input.obfuscation_setting {
#[allow(unused_mut)]
let mut object_106 = object.key("obfuscationSetting").start_object();
crate::json_ser::serialize_structure_crate_model_obfuscation_setting(
&mut object_106,
var_105,
)?;
object_106.finish();
}
if let Some(var_107) = &input.slot_name {
object.key("slotName").string(var_107.as_str());
}
if let Some(var_108) = &input.slot_type_id {
object.key("slotTypeId").string(var_108.as_str());
}
if let Some(var_109) = &input.sub_slot_setting {
#[allow(unused_mut)]
let mut object_110 = object.key("subSlotSetting").start_object();
crate::json_ser::serialize_structure_crate_model_sub_slot_setting(
&mut object_110,
var_109,
)?;
object_110.finish();
}
if let Some(var_111) = &input.value_elicitation_setting {
#[allow(unused_mut)]
let mut object_112 = object.key("valueElicitationSetting").start_object();
crate::json_ser::serialize_structure_crate_model_slot_value_elicitation_setting(
&mut object_112,
var_111,
)?;
object_112.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_slot_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSlotTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_113) = &input.composite_slot_type_setting {
#[allow(unused_mut)]
let mut object_114 = object.key("compositeSlotTypeSetting").start_object();
crate::json_ser::serialize_structure_crate_model_composite_slot_type_setting(
&mut object_114,
var_113,
)?;
object_114.finish();
}
if let Some(var_115) = &input.description {
object.key("description").string(var_115.as_str());
}
if let Some(var_116) = &input.external_source_setting {
#[allow(unused_mut)]
let mut object_117 = object.key("externalSourceSetting").start_object();
crate::json_ser::serialize_structure_crate_model_external_source_setting(
&mut object_117,
var_116,
)?;
object_117.finish();
}
if let Some(var_118) = &input.parent_slot_type_signature {
object
.key("parentSlotTypeSignature")
.string(var_118.as_str());
}
if let Some(var_119) = &input.slot_type_name {
object.key("slotTypeName").string(var_119.as_str());
}
if let Some(var_120) = &input.slot_type_values {
let mut array_121 = object.key("slotTypeValues").start_array();
for item_122 in var_120 {
{
#[allow(unused_mut)]
let mut object_123 = array_121.value().start_object();
crate::json_ser::serialize_structure_crate_model_slot_type_value(
&mut object_123,
item_122,
)?;
object_123.finish();
}
}
array_121.finish();
}
if let Some(var_124) = &input.value_selection_setting {
#[allow(unused_mut)]
let mut object_125 = object.key("valueSelectionSetting").start_object();
crate::json_ser::serialize_structure_crate_model_slot_value_selection_setting(
&mut object_125,
var_124,
)?;
object_125.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_aggregated_utterances_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAggregatedUtterancesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_126) = &input.aggregation_duration {
#[allow(unused_mut)]
let mut object_127 = object.key("aggregationDuration").start_object();
crate::json_ser::serialize_structure_crate_model_utterance_aggregation_duration(
&mut object_127,
var_126,
)?;
object_127.finish();
}
if let Some(var_128) = &input.bot_alias_id {
object.key("botAliasId").string(var_128.as_str());
}
if let Some(var_129) = &input.bot_version {
object.key("botVersion").string(var_129.as_str());
}
if let Some(var_130) = &input.filters {
let mut array_131 = object.key("filters").start_array();
for item_132 in var_130 {
{
#[allow(unused_mut)]
let mut object_133 = array_131.value().start_object();
crate::json_ser::serialize_structure_crate_model_aggregated_utterances_filter(
&mut object_133,
item_132,
)?;
object_133.finish();
}
}
array_131.finish();
}
if let Some(var_134) = &input.locale_id {
object.key("localeId").string(var_134.as_str());
}
if let Some(var_135) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_135).into()),
);
}
if let Some(var_136) = &input.next_token {
object.key("nextToken").string(var_136.as_str());
}
if let Some(var_137) = &input.sort_by {
#[allow(unused_mut)]
let mut object_138 = object.key("sortBy").start_object();
crate::json_ser::serialize_structure_crate_model_aggregated_utterances_sort_by(
&mut object_138,
var_137,
)?;
object_138.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_bot_aliases_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListBotAliasesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_139) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_139).into()),
);
}
if let Some(var_140) = &input.next_token {
object.key("nextToken").string(var_140.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_bot_locales_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListBotLocalesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_141) = &input.filters {
let mut array_142 = object.key("filters").start_array();
for item_143 in var_141 {
{
#[allow(unused_mut)]
let mut object_144 = array_142.value().start_object();
crate::json_ser::serialize_structure_crate_model_bot_locale_filter(
&mut object_144,
item_143,
)?;
object_144.finish();
}
}
array_142.finish();
}
if let Some(var_145) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_145).into()),
);
}
if let Some(var_146) = &input.next_token {
object.key("nextToken").string(var_146.as_str());
}
if let Some(var_147) = &input.sort_by {
#[allow(unused_mut)]
let mut object_148 = object.key("sortBy").start_object();
crate::json_ser::serialize_structure_crate_model_bot_locale_sort_by(
&mut object_148,
var_147,
)?;
object_148.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_bot_recommendations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListBotRecommendationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_149) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_149).into()),
);
}
if let Some(var_150) = &input.next_token {
object.key("nextToken").string(var_150.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_bots_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListBotsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_151) = &input.filters {
let mut array_152 = object.key("filters").start_array();
for item_153 in var_151 {
{
#[allow(unused_mut)]
let mut object_154 = array_152.value().start_object();
crate::json_ser::serialize_structure_crate_model_bot_filter(
&mut object_154,
item_153,
)?;
object_154.finish();
}
}
array_152.finish();
}
if let Some(var_155) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_155).into()),
);
}
if let Some(var_156) = &input.next_token {
object.key("nextToken").string(var_156.as_str());
}
if let Some(var_157) = &input.sort_by {
#[allow(unused_mut)]
let mut object_158 = object.key("sortBy").start_object();
crate::json_ser::serialize_structure_crate_model_bot_sort_by(&mut object_158, var_157)?;
object_158.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_bot_versions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListBotVersionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_159) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_159).into()),
);
}
if let Some(var_160) = &input.next_token {
object.key("nextToken").string(var_160.as_str());
}
if let Some(var_161) = &input.sort_by {
#[allow(unused_mut)]
let mut object_162 = object.key("sortBy").start_object();
crate::json_ser::serialize_structure_crate_model_bot_version_sort_by(
&mut object_162,
var_161,
)?;
object_162.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_built_in_intents_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListBuiltInIntentsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_163) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_163).into()),
);
}
if let Some(var_164) = &input.next_token {
object.key("nextToken").string(var_164.as_str());
}
if let Some(var_165) = &input.sort_by {
#[allow(unused_mut)]
let mut object_166 = object.key("sortBy").start_object();
crate::json_ser::serialize_structure_crate_model_built_in_intent_sort_by(
&mut object_166,
var_165,
)?;
object_166.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_built_in_slot_types_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListBuiltInSlotTypesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_167) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_167).into()),
);
}
if let Some(var_168) = &input.next_token {
object.key("nextToken").string(var_168.as_str());
}
if let Some(var_169) = &input.sort_by {
#[allow(unused_mut)]
let mut object_170 = object.key("sortBy").start_object();
crate::json_ser::serialize_structure_crate_model_built_in_slot_type_sort_by(
&mut object_170,
var_169,
)?;
object_170.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_custom_vocabulary_items_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListCustomVocabularyItemsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_171) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_171).into()),
);
}
if let Some(var_172) = &input.next_token {
object.key("nextToken").string(var_172.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_exports_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListExportsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_173) = &input.bot_id {
object.key("botId").string(var_173.as_str());
}
if let Some(var_174) = &input.bot_version {
object.key("botVersion").string(var_174.as_str());
}
if let Some(var_175) = &input.filters {
let mut array_176 = object.key("filters").start_array();
for item_177 in var_175 {
{
#[allow(unused_mut)]
let mut object_178 = array_176.value().start_object();
crate::json_ser::serialize_structure_crate_model_export_filter(
&mut object_178,
item_177,
)?;
object_178.finish();
}
}
array_176.finish();
}
if let Some(var_179) = &input.locale_id {
object.key("localeId").string(var_179.as_str());
}
if let Some(var_180) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_180).into()),
);
}
if let Some(var_181) = &input.next_token {
object.key("nextToken").string(var_181.as_str());
}
if let Some(var_182) = &input.sort_by {
#[allow(unused_mut)]
let mut object_183 = object.key("sortBy").start_object();
crate::json_ser::serialize_structure_crate_model_export_sort_by(&mut object_183, var_182)?;
object_183.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_imports_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListImportsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_184) = &input.bot_id {
object.key("botId").string(var_184.as_str());
}
if let Some(var_185) = &input.bot_version {
object.key("botVersion").string(var_185.as_str());
}
if let Some(var_186) = &input.filters {
let mut array_187 = object.key("filters").start_array();
for item_188 in var_186 {
{
#[allow(unused_mut)]
let mut object_189 = array_187.value().start_object();
crate::json_ser::serialize_structure_crate_model_import_filter(
&mut object_189,
item_188,
)?;
object_189.finish();
}
}
array_187.finish();
}
if let Some(var_190) = &input.locale_id {
object.key("localeId").string(var_190.as_str());
}
if let Some(var_191) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_191).into()),
);
}
if let Some(var_192) = &input.next_token {
object.key("nextToken").string(var_192.as_str());
}
if let Some(var_193) = &input.sort_by {
#[allow(unused_mut)]
let mut object_194 = object.key("sortBy").start_object();
crate::json_ser::serialize_structure_crate_model_import_sort_by(&mut object_194, var_193)?;
object_194.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_intents_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListIntentsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_195) = &input.filters {
let mut array_196 = object.key("filters").start_array();
for item_197 in var_195 {
{
#[allow(unused_mut)]
let mut object_198 = array_196.value().start_object();
crate::json_ser::serialize_structure_crate_model_intent_filter(
&mut object_198,
item_197,
)?;
object_198.finish();
}
}
array_196.finish();
}
if let Some(var_199) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_199).into()),
);
}
if let Some(var_200) = &input.next_token {
object.key("nextToken").string(var_200.as_str());
}
if let Some(var_201) = &input.sort_by {
#[allow(unused_mut)]
let mut object_202 = object.key("sortBy").start_object();
crate::json_ser::serialize_structure_crate_model_intent_sort_by(&mut object_202, var_201)?;
object_202.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_recommended_intents_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListRecommendedIntentsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_203) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_203).into()),
);
}
if let Some(var_204) = &input.next_token {
object.key("nextToken").string(var_204.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_slots_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSlotsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_205) = &input.filters {
let mut array_206 = object.key("filters").start_array();
for item_207 in var_205 {
{
#[allow(unused_mut)]
let mut object_208 = array_206.value().start_object();
crate::json_ser::serialize_structure_crate_model_slot_filter(
&mut object_208,
item_207,
)?;
object_208.finish();
}
}
array_206.finish();
}
if let Some(var_209) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_209).into()),
);
}
if let Some(var_210) = &input.next_token {
object.key("nextToken").string(var_210.as_str());
}
if let Some(var_211) = &input.sort_by {
#[allow(unused_mut)]
let mut object_212 = object.key("sortBy").start_object();
crate::json_ser::serialize_structure_crate_model_slot_sort_by(&mut object_212, var_211)?;
object_212.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_slot_types_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSlotTypesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_213) = &input.filters {
let mut array_214 = object.key("filters").start_array();
for item_215 in var_213 {
{
#[allow(unused_mut)]
let mut object_216 = array_214.value().start_object();
crate::json_ser::serialize_structure_crate_model_slot_type_filter(
&mut object_216,
item_215,
)?;
object_216.finish();
}
}
array_214.finish();
}
if let Some(var_217) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_217).into()),
);
}
if let Some(var_218) = &input.next_token {
object.key("nextToken").string(var_218.as_str());
}
if let Some(var_219) = &input.sort_by {
#[allow(unused_mut)]
let mut object_220 = object.key("sortBy").start_object();
crate::json_ser::serialize_structure_crate_model_slot_type_sort_by(
&mut object_220,
var_219,
)?;
object_220.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_search_associated_transcripts_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchAssociatedTranscriptsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_221) = &input.filters {
let mut array_222 = object.key("filters").start_array();
for item_223 in var_221 {
{
#[allow(unused_mut)]
let mut object_224 = array_222.value().start_object();
crate::json_ser::serialize_structure_crate_model_associated_transcript_filter(
&mut object_224,
item_223,
)?;
object_224.finish();
}
}
array_222.finish();
}
if let Some(var_225) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_225).into()),
);
}
if let Some(var_226) = &input.next_index {
object.key("nextIndex").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_226).into()),
);
}
if let Some(var_227) = &input.search_order {
object.key("searchOrder").string(var_227.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_bot_recommendation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartBotRecommendationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_228) = &input.encryption_setting {
#[allow(unused_mut)]
let mut object_229 = object.key("encryptionSetting").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_setting(
&mut object_229,
var_228,
)?;
object_229.finish();
}
if let Some(var_230) = &input.transcript_source_setting {
#[allow(unused_mut)]
let mut object_231 = object.key("transcriptSourceSetting").start_object();
crate::json_ser::serialize_structure_crate_model_transcript_source_setting(
&mut object_231,
var_230,
)?;
object_231.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_import_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartImportInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_232) = &input.file_password {
object.key("filePassword").string(var_232.as_str());
}
if let Some(var_233) = &input.import_id {
object.key("importId").string(var_233.as_str());
}
if let Some(var_234) = &input.merge_strategy {
object.key("mergeStrategy").string(var_234.as_str());
}
if let Some(var_235) = &input.resource_specification {
#[allow(unused_mut)]
let mut object_236 = object.key("resourceSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_import_resource_specification(
&mut object_236,
var_235,
)?;
object_236.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_237) = &input.tags {
#[allow(unused_mut)]
let mut object_238 = object.key("tags").start_object();
for (key_239, value_240) in var_237 {
{
object_238.key(key_239.as_str()).string(value_240.as_str());
}
}
object_238.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_bot_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBotInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_241) = &input.bot_name {
object.key("botName").string(var_241.as_str());
}
if let Some(var_242) = &input.data_privacy {
#[allow(unused_mut)]
let mut object_243 = object.key("dataPrivacy").start_object();
crate::json_ser::serialize_structure_crate_model_data_privacy(&mut object_243, var_242)?;
object_243.finish();
}
if let Some(var_244) = &input.description {
object.key("description").string(var_244.as_str());
}
if let Some(var_245) = &input.idle_session_ttl_in_seconds {
object.key("idleSessionTTLInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_245).into()),
);
}
if let Some(var_246) = &input.role_arn {
object.key("roleArn").string(var_246.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_bot_alias_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBotAliasInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_247) = &input.bot_alias_locale_settings {
#[allow(unused_mut)]
let mut object_248 = object.key("botAliasLocaleSettings").start_object();
for (key_249, value_250) in var_247 {
{
#[allow(unused_mut)]
let mut object_251 = object_248.key(key_249.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_bot_alias_locale_settings(
&mut object_251,
value_250,
)?;
object_251.finish();
}
}
object_248.finish();
}
if let Some(var_252) = &input.bot_alias_name {
object.key("botAliasName").string(var_252.as_str());
}
if let Some(var_253) = &input.bot_version {
object.key("botVersion").string(var_253.as_str());
}
if let Some(var_254) = &input.conversation_log_settings {
#[allow(unused_mut)]
let mut object_255 = object.key("conversationLogSettings").start_object();
crate::json_ser::serialize_structure_crate_model_conversation_log_settings(
&mut object_255,
var_254,
)?;
object_255.finish();
}
if let Some(var_256) = &input.description {
object.key("description").string(var_256.as_str());
}
if let Some(var_257) = &input.sentiment_analysis_settings {
#[allow(unused_mut)]
let mut object_258 = object.key("sentimentAnalysisSettings").start_object();
crate::json_ser::serialize_structure_crate_model_sentiment_analysis_settings(
&mut object_258,
var_257,
)?;
object_258.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_bot_locale_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBotLocaleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_259) = &input.description {
object.key("description").string(var_259.as_str());
}
if let Some(var_260) = &input.nlu_intent_confidence_threshold {
object.key("nluIntentConfidenceThreshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_260).into()),
);
}
if let Some(var_261) = &input.voice_settings {
#[allow(unused_mut)]
let mut object_262 = object.key("voiceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_voice_settings(&mut object_262, var_261)?;
object_262.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_bot_recommendation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBotRecommendationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_263) = &input.encryption_setting {
#[allow(unused_mut)]
let mut object_264 = object.key("encryptionSetting").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_setting(
&mut object_264,
var_263,
)?;
object_264.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_export_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateExportInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_265) = &input.file_password {
object.key("filePassword").string(var_265.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_intent_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateIntentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_266) = &input.description {
object.key("description").string(var_266.as_str());
}
if let Some(var_267) = &input.dialog_code_hook {
#[allow(unused_mut)]
let mut object_268 = object.key("dialogCodeHook").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_code_hook_settings(
&mut object_268,
var_267,
)?;
object_268.finish();
}
if let Some(var_269) = &input.fulfillment_code_hook {
#[allow(unused_mut)]
let mut object_270 = object.key("fulfillmentCodeHook").start_object();
crate::json_ser::serialize_structure_crate_model_fulfillment_code_hook_settings(
&mut object_270,
var_269,
)?;
object_270.finish();
}
if let Some(var_271) = &input.initial_response_setting {
#[allow(unused_mut)]
let mut object_272 = object.key("initialResponseSetting").start_object();
crate::json_ser::serialize_structure_crate_model_initial_response_setting(
&mut object_272,
var_271,
)?;
object_272.finish();
}
if let Some(var_273) = &input.input_contexts {
let mut array_274 = object.key("inputContexts").start_array();
for item_275 in var_273 {
{
#[allow(unused_mut)]
let mut object_276 = array_274.value().start_object();
crate::json_ser::serialize_structure_crate_model_input_context(
&mut object_276,
item_275,
)?;
object_276.finish();
}
}
array_274.finish();
}
if let Some(var_277) = &input.intent_closing_setting {
#[allow(unused_mut)]
let mut object_278 = object.key("intentClosingSetting").start_object();
crate::json_ser::serialize_structure_crate_model_intent_closing_setting(
&mut object_278,
var_277,
)?;
object_278.finish();
}
if let Some(var_279) = &input.intent_confirmation_setting {
#[allow(unused_mut)]
let mut object_280 = object.key("intentConfirmationSetting").start_object();
crate::json_ser::serialize_structure_crate_model_intent_confirmation_setting(
&mut object_280,
var_279,
)?;
object_280.finish();
}
if let Some(var_281) = &input.intent_name {
object.key("intentName").string(var_281.as_str());
}
if let Some(var_282) = &input.kendra_configuration {
#[allow(unused_mut)]
let mut object_283 = object.key("kendraConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_kendra_configuration(
&mut object_283,
var_282,
)?;
object_283.finish();
}
if let Some(var_284) = &input.output_contexts {
let mut array_285 = object.key("outputContexts").start_array();
for item_286 in var_284 {
{
#[allow(unused_mut)]
let mut object_287 = array_285.value().start_object();
crate::json_ser::serialize_structure_crate_model_output_context(
&mut object_287,
item_286,
)?;
object_287.finish();
}
}
array_285.finish();
}
if let Some(var_288) = &input.parent_intent_signature {
object.key("parentIntentSignature").string(var_288.as_str());
}
if let Some(var_289) = &input.sample_utterances {
let mut array_290 = object.key("sampleUtterances").start_array();
for item_291 in var_289 {
{
#[allow(unused_mut)]
let mut object_292 = array_290.value().start_object();
crate::json_ser::serialize_structure_crate_model_sample_utterance(
&mut object_292,
item_291,
)?;
object_292.finish();
}
}
array_290.finish();
}
if let Some(var_293) = &input.slot_priorities {
let mut array_294 = object.key("slotPriorities").start_array();
for item_295 in var_293 {
{
#[allow(unused_mut)]
let mut object_296 = array_294.value().start_object();
crate::json_ser::serialize_structure_crate_model_slot_priority(
&mut object_296,
item_295,
)?;
object_296.finish();
}
}
array_294.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateResourcePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_297) = &input.policy {
object.key("policy").string(var_297.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_slot_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSlotInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_298) = &input.description {
object.key("description").string(var_298.as_str());
}
if let Some(var_299) = &input.multiple_values_setting {
#[allow(unused_mut)]
let mut object_300 = object.key("multipleValuesSetting").start_object();
crate::json_ser::serialize_structure_crate_model_multiple_values_setting(
&mut object_300,
var_299,
)?;
object_300.finish();
}
if let Some(var_301) = &input.obfuscation_setting {
#[allow(unused_mut)]
let mut object_302 = object.key("obfuscationSetting").start_object();
crate::json_ser::serialize_structure_crate_model_obfuscation_setting(
&mut object_302,
var_301,
)?;
object_302.finish();
}
if let Some(var_303) = &input.slot_name {
object.key("slotName").string(var_303.as_str());
}
if let Some(var_304) = &input.slot_type_id {
object.key("slotTypeId").string(var_304.as_str());
}
if let Some(var_305) = &input.sub_slot_setting {
#[allow(unused_mut)]
let mut object_306 = object.key("subSlotSetting").start_object();
crate::json_ser::serialize_structure_crate_model_sub_slot_setting(
&mut object_306,
var_305,
)?;
object_306.finish();
}
if let Some(var_307) = &input.value_elicitation_setting {
#[allow(unused_mut)]
let mut object_308 = object.key("valueElicitationSetting").start_object();
crate::json_ser::serialize_structure_crate_model_slot_value_elicitation_setting(
&mut object_308,
var_307,
)?;
object_308.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_slot_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSlotTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_309) = &input.composite_slot_type_setting {
#[allow(unused_mut)]
let mut object_310 = object.key("compositeSlotTypeSetting").start_object();
crate::json_ser::serialize_structure_crate_model_composite_slot_type_setting(
&mut object_310,
var_309,
)?;
object_310.finish();
}
if let Some(var_311) = &input.description {
object.key("description").string(var_311.as_str());
}
if let Some(var_312) = &input.external_source_setting {
#[allow(unused_mut)]
let mut object_313 = object.key("externalSourceSetting").start_object();
crate::json_ser::serialize_structure_crate_model_external_source_setting(
&mut object_313,
var_312,
)?;
object_313.finish();
}
if let Some(var_314) = &input.parent_slot_type_signature {
object
.key("parentSlotTypeSignature")
.string(var_314.as_str());
}
if let Some(var_315) = &input.slot_type_name {
object.key("slotTypeName").string(var_315.as_str());
}
if let Some(var_316) = &input.slot_type_values {
let mut array_317 = object.key("slotTypeValues").start_array();
for item_318 in var_316 {
{
#[allow(unused_mut)]
let mut object_319 = array_317.value().start_object();
crate::json_ser::serialize_structure_crate_model_slot_type_value(
&mut object_319,
item_318,
)?;
object_319.finish();
}
}
array_317.finish();
}
if let Some(var_320) = &input.value_selection_setting {
#[allow(unused_mut)]
let mut object_321 = object.key("valueSelectionSetting").start_object();
crate::json_ser::serialize_structure_crate_model_slot_value_selection_setting(
&mut object_321,
var_320,
)?;
object_321.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_new_custom_vocabulary_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NewCustomVocabularyItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_322) = &input.phrase {
object.key("phrase").string(var_322.as_str());
}
if let Some(var_323) = &input.weight {
object.key("weight").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_323).into()),
);
}
if let Some(var_324) = &input.display_as {
object.key("displayAs").string(var_324.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_vocabulary_entry_id(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomVocabularyEntryId,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_325) = &input.item_id {
object.key("itemId").string(var_325.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_vocabulary_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomVocabularyItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_326) = &input.item_id {
object.key("itemId").string(var_326.as_str());
}
if let Some(var_327) = &input.phrase {
object.key("phrase").string(var_327.as_str());
}
if let Some(var_328) = &input.weight {
object.key("weight").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_328).into()),
);
}
if let Some(var_329) = &input.display_as {
object.key("displayAs").string(var_329.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_privacy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataPrivacy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("childDirected").boolean(input.child_directed);
}
Ok(())
}
pub fn serialize_structure_crate_model_bot_alias_locale_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BotAliasLocaleSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("enabled").boolean(input.enabled);
}
if let Some(var_330) = &input.code_hook_specification {
#[allow(unused_mut)]
let mut object_331 = object.key("codeHookSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_code_hook_specification(
&mut object_331,
var_330,
)?;
object_331.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_conversation_log_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConversationLogSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_332) = &input.text_log_settings {
let mut array_333 = object.key("textLogSettings").start_array();
for item_334 in var_332 {
{
#[allow(unused_mut)]
let mut object_335 = array_333.value().start_object();
crate::json_ser::serialize_structure_crate_model_text_log_setting(
&mut object_335,
item_334,
)?;
object_335.finish();
}
}
array_333.finish();
}
if let Some(var_336) = &input.audio_log_settings {
let mut array_337 = object.key("audioLogSettings").start_array();
for item_338 in var_336 {
{
#[allow(unused_mut)]
let mut object_339 = array_337.value().start_object();
crate::json_ser::serialize_structure_crate_model_audio_log_setting(
&mut object_339,
item_338,
)?;
object_339.finish();
}
}
array_337.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sentiment_analysis_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SentimentAnalysisSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object
.key("detectSentiment")
.boolean(input.detect_sentiment);
}
Ok(())
}
pub fn serialize_structure_crate_model_voice_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VoiceSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_340) = &input.voice_id {
object.key("voiceId").string(var_340.as_str());
}
if let Some(var_341) = &input.engine {
object.key("engine").string(var_341.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_bot_version_locale_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BotVersionLocaleDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_342) = &input.source_bot_version {
object.key("sourceBotVersion").string(var_342.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_export_resource_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExportResourceSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_343) = &input.bot_export_specification {
#[allow(unused_mut)]
let mut object_344 = object.key("botExportSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_bot_export_specification(
&mut object_344,
var_343,
)?;
object_344.finish();
}
if let Some(var_345) = &input.bot_locale_export_specification {
#[allow(unused_mut)]
let mut object_346 = object.key("botLocaleExportSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_bot_locale_export_specification(
&mut object_346,
var_345,
)?;
object_346.finish();
}
if let Some(var_347) = &input.custom_vocabulary_export_specification {
#[allow(unused_mut)]
let mut object_348 = object
.key("customVocabularyExportSpecification")
.start_object();
crate::json_ser::serialize_structure_crate_model_custom_vocabulary_export_specification(
&mut object_348,
var_347,
)?;
object_348.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_dialog_code_hook_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DialogCodeHookSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("enabled").boolean(input.enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_fulfillment_code_hook_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FulfillmentCodeHookSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("enabled").boolean(input.enabled);
}
if let Some(var_349) = &input.post_fulfillment_status_specification {
#[allow(unused_mut)]
let mut object_350 = object
.key("postFulfillmentStatusSpecification")
.start_object();
crate::json_ser::serialize_structure_crate_model_post_fulfillment_status_specification(
&mut object_350,
var_349,
)?;
object_350.finish();
}
if let Some(var_351) = &input.fulfillment_updates_specification {
#[allow(unused_mut)]
let mut object_352 = object.key("fulfillmentUpdatesSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_fulfillment_updates_specification(
&mut object_352,
var_351,
)?;
object_352.finish();
}
if let Some(var_353) = &input.active {
object.key("active").boolean(*var_353);
}
Ok(())
}
pub fn serialize_structure_crate_model_initial_response_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InitialResponseSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_354) = &input.initial_response {
#[allow(unused_mut)]
let mut object_355 = object.key("initialResponse").start_object();
crate::json_ser::serialize_structure_crate_model_response_specification(
&mut object_355,
var_354,
)?;
object_355.finish();
}
if let Some(var_356) = &input.next_step {
#[allow(unused_mut)]
let mut object_357 = object.key("nextStep").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_state(&mut object_357, var_356)?;
object_357.finish();
}
if let Some(var_358) = &input.conditional {
#[allow(unused_mut)]
let mut object_359 = object.key("conditional").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_specification(
&mut object_359,
var_358,
)?;
object_359.finish();
}
if let Some(var_360) = &input.code_hook {
#[allow(unused_mut)]
let mut object_361 = object.key("codeHook").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_code_hook_invocation_setting(
&mut object_361,
var_360,
)?;
object_361.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_input_context(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InputContext,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_362) = &input.name {
object.key("name").string(var_362.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_intent_closing_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IntentClosingSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_363) = &input.closing_response {
#[allow(unused_mut)]
let mut object_364 = object.key("closingResponse").start_object();
crate::json_ser::serialize_structure_crate_model_response_specification(
&mut object_364,
var_363,
)?;
object_364.finish();
}
if let Some(var_365) = &input.active {
object.key("active").boolean(*var_365);
}
if let Some(var_366) = &input.next_step {
#[allow(unused_mut)]
let mut object_367 = object.key("nextStep").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_state(&mut object_367, var_366)?;
object_367.finish();
}
if let Some(var_368) = &input.conditional {
#[allow(unused_mut)]
let mut object_369 = object.key("conditional").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_specification(
&mut object_369,
var_368,
)?;
object_369.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_intent_confirmation_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IntentConfirmationSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_370) = &input.prompt_specification {
#[allow(unused_mut)]
let mut object_371 = object.key("promptSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_prompt_specification(
&mut object_371,
var_370,
)?;
object_371.finish();
}
if let Some(var_372) = &input.declination_response {
#[allow(unused_mut)]
let mut object_373 = object.key("declinationResponse").start_object();
crate::json_ser::serialize_structure_crate_model_response_specification(
&mut object_373,
var_372,
)?;
object_373.finish();
}
if let Some(var_374) = &input.active {
object.key("active").boolean(*var_374);
}
if let Some(var_375) = &input.confirmation_response {
#[allow(unused_mut)]
let mut object_376 = object.key("confirmationResponse").start_object();
crate::json_ser::serialize_structure_crate_model_response_specification(
&mut object_376,
var_375,
)?;
object_376.finish();
}
if let Some(var_377) = &input.confirmation_next_step {
#[allow(unused_mut)]
let mut object_378 = object.key("confirmationNextStep").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_state(&mut object_378, var_377)?;
object_378.finish();
}
if let Some(var_379) = &input.confirmation_conditional {
#[allow(unused_mut)]
let mut object_380 = object.key("confirmationConditional").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_specification(
&mut object_380,
var_379,
)?;
object_380.finish();
}
if let Some(var_381) = &input.declination_next_step {
#[allow(unused_mut)]
let mut object_382 = object.key("declinationNextStep").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_state(&mut object_382, var_381)?;
object_382.finish();
}
if let Some(var_383) = &input.declination_conditional {
#[allow(unused_mut)]
let mut object_384 = object.key("declinationConditional").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_specification(
&mut object_384,
var_383,
)?;
object_384.finish();
}
if let Some(var_385) = &input.failure_response {
#[allow(unused_mut)]
let mut object_386 = object.key("failureResponse").start_object();
crate::json_ser::serialize_structure_crate_model_response_specification(
&mut object_386,
var_385,
)?;
object_386.finish();
}
if let Some(var_387) = &input.failure_next_step {
#[allow(unused_mut)]
let mut object_388 = object.key("failureNextStep").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_state(&mut object_388, var_387)?;
object_388.finish();
}
if let Some(var_389) = &input.failure_conditional {
#[allow(unused_mut)]
let mut object_390 = object.key("failureConditional").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_specification(
&mut object_390,
var_389,
)?;
object_390.finish();
}
if let Some(var_391) = &input.code_hook {
#[allow(unused_mut)]
let mut object_392 = object.key("codeHook").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_code_hook_invocation_setting(
&mut object_392,
var_391,
)?;
object_392.finish();
}
if let Some(var_393) = &input.elicitation_code_hook {
#[allow(unused_mut)]
let mut object_394 = object.key("elicitationCodeHook").start_object();
crate::json_ser::serialize_structure_crate_model_elicitation_code_hook_invocation_setting(
&mut object_394,
var_393,
)?;
object_394.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_kendra_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KendraConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_395) = &input.kendra_index {
object.key("kendraIndex").string(var_395.as_str());
}
if input.query_filter_string_enabled {
object
.key("queryFilterStringEnabled")
.boolean(input.query_filter_string_enabled);
}
if let Some(var_396) = &input.query_filter_string {
object.key("queryFilterString").string(var_396.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_output_context(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OutputContext,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_397) = &input.name {
object.key("name").string(var_397.as_str());
}
if let Some(var_398) = &input.time_to_live_in_seconds {
object.key("timeToLiveInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_398).into()),
);
}
if let Some(var_399) = &input.turns_to_live {
object.key("turnsToLive").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_399).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_sample_utterance(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SampleUtterance,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_400) = &input.utterance {
object.key("utterance").string(var_400.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_principal(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Principal,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_401) = &input.service {
object.key("service").string(var_401.as_str());
}
if let Some(var_402) = &input.arn {
object.key("arn").string(var_402.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_multiple_values_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MultipleValuesSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.allow_multiple_values {
object
.key("allowMultipleValues")
.boolean(input.allow_multiple_values);
}
Ok(())
}
pub fn serialize_structure_crate_model_obfuscation_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ObfuscationSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_403) = &input.obfuscation_setting_type {
object
.key("obfuscationSettingType")
.string(var_403.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sub_slot_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SubSlotSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_404) = &input.expression {
object.key("expression").string(var_404.as_str());
}
if let Some(var_405) = &input.slot_specifications {
#[allow(unused_mut)]
let mut object_406 = object.key("slotSpecifications").start_object();
for (key_407, value_408) in var_405 {
{
#[allow(unused_mut)]
let mut object_409 = object_406.key(key_407.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_specifications(
&mut object_409,
value_408,
)?;
object_409.finish();
}
}
object_406.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_slot_value_elicitation_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SlotValueElicitationSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_410) = &input.default_value_specification {
#[allow(unused_mut)]
let mut object_411 = object.key("defaultValueSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_slot_default_value_specification(
&mut object_411,
var_410,
)?;
object_411.finish();
}
if let Some(var_412) = &input.slot_constraint {
object.key("slotConstraint").string(var_412.as_str());
}
if let Some(var_413) = &input.prompt_specification {
#[allow(unused_mut)]
let mut object_414 = object.key("promptSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_prompt_specification(
&mut object_414,
var_413,
)?;
object_414.finish();
}
if let Some(var_415) = &input.sample_utterances {
let mut array_416 = object.key("sampleUtterances").start_array();
for item_417 in var_415 {
{
#[allow(unused_mut)]
let mut object_418 = array_416.value().start_object();
crate::json_ser::serialize_structure_crate_model_sample_utterance(
&mut object_418,
item_417,
)?;
object_418.finish();
}
}
array_416.finish();
}
if let Some(var_419) = &input.wait_and_continue_specification {
#[allow(unused_mut)]
let mut object_420 = object.key("waitAndContinueSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_wait_and_continue_specification(
&mut object_420,
var_419,
)?;
object_420.finish();
}
if let Some(var_421) = &input.slot_capture_setting {
#[allow(unused_mut)]
let mut object_422 = object.key("slotCaptureSetting").start_object();
crate::json_ser::serialize_structure_crate_model_slot_capture_setting(
&mut object_422,
var_421,
)?;
object_422.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_composite_slot_type_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CompositeSlotTypeSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_423) = &input.sub_slots {
let mut array_424 = object.key("subSlots").start_array();
for item_425 in var_423 {
{
#[allow(unused_mut)]
let mut object_426 = array_424.value().start_object();
crate::json_ser::serialize_structure_crate_model_sub_slot_type_composition(
&mut object_426,
item_425,
)?;
object_426.finish();
}
}
array_424.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_external_source_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExternalSourceSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_427) = &input.grammar_slot_type_setting {
#[allow(unused_mut)]
let mut object_428 = object.key("grammarSlotTypeSetting").start_object();
crate::json_ser::serialize_structure_crate_model_grammar_slot_type_setting(
&mut object_428,
var_427,
)?;
object_428.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_slot_type_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SlotTypeValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_429) = &input.sample_value {
#[allow(unused_mut)]
let mut object_430 = object.key("sampleValue").start_object();
crate::json_ser::serialize_structure_crate_model_sample_value(&mut object_430, var_429)?;
object_430.finish();
}
if let Some(var_431) = &input.synonyms {
let mut array_432 = object.key("synonyms").start_array();
for item_433 in var_431 {
{
#[allow(unused_mut)]
let mut object_434 = array_432.value().start_object();
crate::json_ser::serialize_structure_crate_model_sample_value(
&mut object_434,
item_433,
)?;
object_434.finish();
}
}
array_432.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_slot_value_selection_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SlotValueSelectionSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_435) = &input.resolution_strategy {
object.key("resolutionStrategy").string(var_435.as_str());
}
if let Some(var_436) = &input.regex_filter {
#[allow(unused_mut)]
let mut object_437 = object.key("regexFilter").start_object();
crate::json_ser::serialize_structure_crate_model_slot_value_regex_filter(
&mut object_437,
var_436,
)?;
object_437.finish();
}
if let Some(var_438) = &input.advanced_recognition_setting {
#[allow(unused_mut)]
let mut object_439 = object.key("advancedRecognitionSetting").start_object();
crate::json_ser::serialize_structure_crate_model_advanced_recognition_setting(
&mut object_439,
var_438,
)?;
object_439.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_utterance_aggregation_duration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UtteranceAggregationDuration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_440) = &input.relative_aggregation_duration {
#[allow(unused_mut)]
let mut object_441 = object.key("relativeAggregationDuration").start_object();
crate::json_ser::serialize_structure_crate_model_relative_aggregation_duration(
&mut object_441,
var_440,
)?;
object_441.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aggregated_utterances_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AggregatedUtterancesFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_442) = &input.name {
object.key("name").string(var_442.as_str());
}
if let Some(var_443) = &input.values {
let mut array_444 = object.key("values").start_array();
for item_445 in var_443 {
{
array_444.value().string(item_445.as_str());
}
}
array_444.finish();
}
if let Some(var_446) = &input.operator {
object.key("operator").string(var_446.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aggregated_utterances_sort_by(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AggregatedUtterancesSortBy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_447) = &input.attribute {
object.key("attribute").string(var_447.as_str());
}
if let Some(var_448) = &input.order {
object.key("order").string(var_448.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_bot_locale_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BotLocaleFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_449) = &input.name {
object.key("name").string(var_449.as_str());
}
if let Some(var_450) = &input.values {
let mut array_451 = object.key("values").start_array();
for item_452 in var_450 {
{
array_451.value().string(item_452.as_str());
}
}
array_451.finish();
}
if let Some(var_453) = &input.operator {
object.key("operator").string(var_453.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_bot_locale_sort_by(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BotLocaleSortBy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_454) = &input.attribute {
object.key("attribute").string(var_454.as_str());
}
if let Some(var_455) = &input.order {
object.key("order").string(var_455.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_bot_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BotFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_456) = &input.name {
object.key("name").string(var_456.as_str());
}
if let Some(var_457) = &input.values {
let mut array_458 = object.key("values").start_array();
for item_459 in var_457 {
{
array_458.value().string(item_459.as_str());
}
}
array_458.finish();
}
if let Some(var_460) = &input.operator {
object.key("operator").string(var_460.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_bot_sort_by(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BotSortBy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_461) = &input.attribute {
object.key("attribute").string(var_461.as_str());
}
if let Some(var_462) = &input.order {
object.key("order").string(var_462.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_bot_version_sort_by(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BotVersionSortBy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_463) = &input.attribute {
object.key("attribute").string(var_463.as_str());
}
if let Some(var_464) = &input.order {
object.key("order").string(var_464.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_built_in_intent_sort_by(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BuiltInIntentSortBy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_465) = &input.attribute {
object.key("attribute").string(var_465.as_str());
}
if let Some(var_466) = &input.order {
object.key("order").string(var_466.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_built_in_slot_type_sort_by(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BuiltInSlotTypeSortBy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_467) = &input.attribute {
object.key("attribute").string(var_467.as_str());
}
if let Some(var_468) = &input.order {
object.key("order").string(var_468.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_export_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExportFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_469) = &input.name {
object.key("name").string(var_469.as_str());
}
if let Some(var_470) = &input.values {
let mut array_471 = object.key("values").start_array();
for item_472 in var_470 {
{
array_471.value().string(item_472.as_str());
}
}
array_471.finish();
}
if let Some(var_473) = &input.operator {
object.key("operator").string(var_473.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_export_sort_by(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExportSortBy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_474) = &input.attribute {
object.key("attribute").string(var_474.as_str());
}
if let Some(var_475) = &input.order {
object.key("order").string(var_475.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_import_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImportFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_476) = &input.name {
object.key("name").string(var_476.as_str());
}
if let Some(var_477) = &input.values {
let mut array_478 = object.key("values").start_array();
for item_479 in var_477 {
{
array_478.value().string(item_479.as_str());
}
}
array_478.finish();
}
if let Some(var_480) = &input.operator {
object.key("operator").string(var_480.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_import_sort_by(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImportSortBy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_481) = &input.attribute {
object.key("attribute").string(var_481.as_str());
}
if let Some(var_482) = &input.order {
object.key("order").string(var_482.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_intent_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IntentFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_483) = &input.name {
object.key("name").string(var_483.as_str());
}
if let Some(var_484) = &input.values {
let mut array_485 = object.key("values").start_array();
for item_486 in var_484 {
{
array_485.value().string(item_486.as_str());
}
}
array_485.finish();
}
if let Some(var_487) = &input.operator {
object.key("operator").string(var_487.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_intent_sort_by(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IntentSortBy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_488) = &input.attribute {
object.key("attribute").string(var_488.as_str());
}
if let Some(var_489) = &input.order {
object.key("order").string(var_489.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_slot_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SlotFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_490) = &input.name {
object.key("name").string(var_490.as_str());
}
if let Some(var_491) = &input.values {
let mut array_492 = object.key("values").start_array();
for item_493 in var_491 {
{
array_492.value().string(item_493.as_str());
}
}
array_492.finish();
}
if let Some(var_494) = &input.operator {
object.key("operator").string(var_494.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_slot_sort_by(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SlotSortBy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_495) = &input.attribute {
object.key("attribute").string(var_495.as_str());
}
if let Some(var_496) = &input.order {
object.key("order").string(var_496.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_slot_type_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SlotTypeFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_497) = &input.name {
object.key("name").string(var_497.as_str());
}
if let Some(var_498) = &input.values {
let mut array_499 = object.key("values").start_array();
for item_500 in var_498 {
{
array_499.value().string(item_500.as_str());
}
}
array_499.finish();
}
if let Some(var_501) = &input.operator {
object.key("operator").string(var_501.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_slot_type_sort_by(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SlotTypeSortBy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_502) = &input.attribute {
object.key("attribute").string(var_502.as_str());
}
if let Some(var_503) = &input.order {
object.key("order").string(var_503.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_associated_transcript_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AssociatedTranscriptFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_504) = &input.name {
object.key("name").string(var_504.as_str());
}
if let Some(var_505) = &input.values {
let mut array_506 = object.key("values").start_array();
for item_507 in var_505 {
{
array_506.value().string(item_507.as_str());
}
}
array_506.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_encryption_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EncryptionSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_508) = &input.kms_key_arn {
object.key("kmsKeyArn").string(var_508.as_str());
}
if let Some(var_509) = &input.bot_locale_export_password {
object
.key("botLocaleExportPassword")
.string(var_509.as_str());
}
if let Some(var_510) = &input.associated_transcripts_password {
object
.key("associatedTranscriptsPassword")
.string(var_510.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_transcript_source_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TranscriptSourceSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_511) = &input.s3_bucket_transcript_source {
#[allow(unused_mut)]
let mut object_512 = object.key("s3BucketTranscriptSource").start_object();
crate::json_ser::serialize_structure_crate_model_s3_bucket_transcript_source(
&mut object_512,
var_511,
)?;
object_512.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_import_resource_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImportResourceSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_513) = &input.bot_import_specification {
#[allow(unused_mut)]
let mut object_514 = object.key("botImportSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_bot_import_specification(
&mut object_514,
var_513,
)?;
object_514.finish();
}
if let Some(var_515) = &input.bot_locale_import_specification {
#[allow(unused_mut)]
let mut object_516 = object.key("botLocaleImportSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_bot_locale_import_specification(
&mut object_516,
var_515,
)?;
object_516.finish();
}
if let Some(var_517) = &input.custom_vocabulary_import_specification {
#[allow(unused_mut)]
let mut object_518 = object
.key("customVocabularyImportSpecification")
.start_object();
crate::json_ser::serialize_structure_crate_model_custom_vocabulary_import_specification(
&mut object_518,
var_517,
)?;
object_518.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_slot_priority(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SlotPriority,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_519) = &input.priority {
object.key("priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_519).into()),
);
}
if let Some(var_520) = &input.slot_id {
object.key("slotId").string(var_520.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_code_hook_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CodeHookSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_521) = &input.lambda_code_hook {
#[allow(unused_mut)]
let mut object_522 = object.key("lambdaCodeHook").start_object();
crate::json_ser::serialize_structure_crate_model_lambda_code_hook(
&mut object_522,
var_521,
)?;
object_522.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_text_log_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TextLogSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("enabled").boolean(input.enabled);
}
if let Some(var_523) = &input.destination {
#[allow(unused_mut)]
let mut object_524 = object.key("destination").start_object();
crate::json_ser::serialize_structure_crate_model_text_log_destination(
&mut object_524,
var_523,
)?;
object_524.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_audio_log_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AudioLogSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("enabled").boolean(input.enabled);
}
if let Some(var_525) = &input.destination {
#[allow(unused_mut)]
let mut object_526 = object.key("destination").start_object();
crate::json_ser::serialize_structure_crate_model_audio_log_destination(
&mut object_526,
var_525,
)?;
object_526.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_bot_export_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BotExportSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_527) = &input.bot_id {
object.key("botId").string(var_527.as_str());
}
if let Some(var_528) = &input.bot_version {
object.key("botVersion").string(var_528.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_bot_locale_export_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BotLocaleExportSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_529) = &input.bot_id {
object.key("botId").string(var_529.as_str());
}
if let Some(var_530) = &input.bot_version {
object.key("botVersion").string(var_530.as_str());
}
if let Some(var_531) = &input.locale_id {
object.key("localeId").string(var_531.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_vocabulary_export_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomVocabularyExportSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_532) = &input.bot_id {
object.key("botId").string(var_532.as_str());
}
if let Some(var_533) = &input.bot_version {
object.key("botVersion").string(var_533.as_str());
}
if let Some(var_534) = &input.locale_id {
object.key("localeId").string(var_534.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_post_fulfillment_status_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PostFulfillmentStatusSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_535) = &input.success_response {
#[allow(unused_mut)]
let mut object_536 = object.key("successResponse").start_object();
crate::json_ser::serialize_structure_crate_model_response_specification(
&mut object_536,
var_535,
)?;
object_536.finish();
}
if let Some(var_537) = &input.failure_response {
#[allow(unused_mut)]
let mut object_538 = object.key("failureResponse").start_object();
crate::json_ser::serialize_structure_crate_model_response_specification(
&mut object_538,
var_537,
)?;
object_538.finish();
}
if let Some(var_539) = &input.timeout_response {
#[allow(unused_mut)]
let mut object_540 = object.key("timeoutResponse").start_object();
crate::json_ser::serialize_structure_crate_model_response_specification(
&mut object_540,
var_539,
)?;
object_540.finish();
}
if let Some(var_541) = &input.success_next_step {
#[allow(unused_mut)]
let mut object_542 = object.key("successNextStep").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_state(&mut object_542, var_541)?;
object_542.finish();
}
if let Some(var_543) = &input.success_conditional {
#[allow(unused_mut)]
let mut object_544 = object.key("successConditional").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_specification(
&mut object_544,
var_543,
)?;
object_544.finish();
}
if let Some(var_545) = &input.failure_next_step {
#[allow(unused_mut)]
let mut object_546 = object.key("failureNextStep").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_state(&mut object_546, var_545)?;
object_546.finish();
}
if let Some(var_547) = &input.failure_conditional {
#[allow(unused_mut)]
let mut object_548 = object.key("failureConditional").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_specification(
&mut object_548,
var_547,
)?;
object_548.finish();
}
if let Some(var_549) = &input.timeout_next_step {
#[allow(unused_mut)]
let mut object_550 = object.key("timeoutNextStep").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_state(&mut object_550, var_549)?;
object_550.finish();
}
if let Some(var_551) = &input.timeout_conditional {
#[allow(unused_mut)]
let mut object_552 = object.key("timeoutConditional").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_specification(
&mut object_552,
var_551,
)?;
object_552.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_fulfillment_updates_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FulfillmentUpdatesSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_553) = &input.active {
object.key("active").boolean(*var_553);
}
if let Some(var_554) = &input.start_response {
#[allow(unused_mut)]
let mut object_555 = object.key("startResponse").start_object();
crate::json_ser::serialize_structure_crate_model_fulfillment_start_response_specification(
&mut object_555,
var_554,
)?;
object_555.finish();
}
if let Some(var_556) = &input.update_response {
#[allow(unused_mut)]
let mut object_557 = object.key("updateResponse").start_object();
crate::json_ser::serialize_structure_crate_model_fulfillment_update_response_specification(
&mut object_557,
var_556,
)?;
object_557.finish();
}
if let Some(var_558) = &input.timeout_in_seconds {
object.key("timeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_558).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_response_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResponseSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_559) = &input.message_groups {
let mut array_560 = object.key("messageGroups").start_array();
for item_561 in var_559 {
{
#[allow(unused_mut)]
let mut object_562 = array_560.value().start_object();
crate::json_ser::serialize_structure_crate_model_message_group(
&mut object_562,
item_561,
)?;
object_562.finish();
}
}
array_560.finish();
}
if let Some(var_563) = &input.allow_interrupt {
object.key("allowInterrupt").boolean(*var_563);
}
Ok(())
}
pub fn serialize_structure_crate_model_dialog_state(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DialogState,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_564) = &input.dialog_action {
#[allow(unused_mut)]
let mut object_565 = object.key("dialogAction").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_action(&mut object_565, var_564)?;
object_565.finish();
}
if let Some(var_566) = &input.intent {
#[allow(unused_mut)]
let mut object_567 = object.key("intent").start_object();
crate::json_ser::serialize_structure_crate_model_intent_override(&mut object_567, var_566)?;
object_567.finish();
}
if let Some(var_568) = &input.session_attributes {
#[allow(unused_mut)]
let mut object_569 = object.key("sessionAttributes").start_object();
for (key_570, value_571) in var_568 {
{
object_569.key(key_570.as_str()).string(value_571.as_str());
}
}
object_569.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_conditional_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConditionalSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_572) = &input.active {
object.key("active").boolean(*var_572);
}
if let Some(var_573) = &input.conditional_branches {
let mut array_574 = object.key("conditionalBranches").start_array();
for item_575 in var_573 {
{
#[allow(unused_mut)]
let mut object_576 = array_574.value().start_object();
crate::json_ser::serialize_structure_crate_model_conditional_branch(
&mut object_576,
item_575,
)?;
object_576.finish();
}
}
array_574.finish();
}
if let Some(var_577) = &input.default_branch {
#[allow(unused_mut)]
let mut object_578 = object.key("defaultBranch").start_object();
crate::json_ser::serialize_structure_crate_model_default_conditional_branch(
&mut object_578,
var_577,
)?;
object_578.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_dialog_code_hook_invocation_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DialogCodeHookInvocationSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_579) = &input.enable_code_hook_invocation {
object.key("enableCodeHookInvocation").boolean(*var_579);
}
if let Some(var_580) = &input.active {
object.key("active").boolean(*var_580);
}
if let Some(var_581) = &input.invocation_label {
object.key("invocationLabel").string(var_581.as_str());
}
if let Some(var_582) = &input.post_code_hook_specification {
#[allow(unused_mut)]
let mut object_583 = object.key("postCodeHookSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_post_dialog_code_hook_invocation_specification(&mut object_583, var_582)?;
object_583.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_prompt_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PromptSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_584) = &input.message_groups {
let mut array_585 = object.key("messageGroups").start_array();
for item_586 in var_584 {
{
#[allow(unused_mut)]
let mut object_587 = array_585.value().start_object();
crate::json_ser::serialize_structure_crate_model_message_group(
&mut object_587,
item_586,
)?;
object_587.finish();
}
}
array_585.finish();
}
if let Some(var_588) = &input.max_retries {
object.key("maxRetries").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_588).into()),
);
}
if let Some(var_589) = &input.allow_interrupt {
object.key("allowInterrupt").boolean(*var_589);
}
if let Some(var_590) = &input.message_selection_strategy {
object
.key("messageSelectionStrategy")
.string(var_590.as_str());
}
if let Some(var_591) = &input.prompt_attempts_specification {
#[allow(unused_mut)]
let mut object_592 = object.key("promptAttemptsSpecification").start_object();
for (key_593, value_594) in var_591 {
{
#[allow(unused_mut)]
let mut object_595 = object_592.key(key_593.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_prompt_attempt_specification(
&mut object_595,
value_594,
)?;
object_595.finish();
}
}
object_592.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_elicitation_code_hook_invocation_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ElicitationCodeHookInvocationSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_596) = &input.enable_code_hook_invocation {
object.key("enableCodeHookInvocation").boolean(*var_596);
}
if let Some(var_597) = &input.invocation_label {
object.key("invocationLabel").string(var_597.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_specifications(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Specifications,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_598) = &input.slot_type_id {
object.key("slotTypeId").string(var_598.as_str());
}
if let Some(var_599) = &input.value_elicitation_setting {
#[allow(unused_mut)]
let mut object_600 = object.key("valueElicitationSetting").start_object();
crate::json_ser::serialize_structure_crate_model_sub_slot_value_elicitation_setting(
&mut object_600,
var_599,
)?;
object_600.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_slot_default_value_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SlotDefaultValueSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_601) = &input.default_value_list {
let mut array_602 = object.key("defaultValueList").start_array();
for item_603 in var_601 {
{
#[allow(unused_mut)]
let mut object_604 = array_602.value().start_object();
crate::json_ser::serialize_structure_crate_model_slot_default_value(
&mut object_604,
item_603,
)?;
object_604.finish();
}
}
array_602.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_wait_and_continue_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WaitAndContinueSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_605) = &input.waiting_response {
#[allow(unused_mut)]
let mut object_606 = object.key("waitingResponse").start_object();
crate::json_ser::serialize_structure_crate_model_response_specification(
&mut object_606,
var_605,
)?;
object_606.finish();
}
if let Some(var_607) = &input.continue_response {
#[allow(unused_mut)]
let mut object_608 = object.key("continueResponse").start_object();
crate::json_ser::serialize_structure_crate_model_response_specification(
&mut object_608,
var_607,
)?;
object_608.finish();
}
if let Some(var_609) = &input.still_waiting_response {
#[allow(unused_mut)]
let mut object_610 = object.key("stillWaitingResponse").start_object();
crate::json_ser::serialize_structure_crate_model_still_waiting_response_specification(
&mut object_610,
var_609,
)?;
object_610.finish();
}
if let Some(var_611) = &input.active {
object.key("active").boolean(*var_611);
}
Ok(())
}
pub fn serialize_structure_crate_model_slot_capture_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SlotCaptureSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_612) = &input.capture_response {
#[allow(unused_mut)]
let mut object_613 = object.key("captureResponse").start_object();
crate::json_ser::serialize_structure_crate_model_response_specification(
&mut object_613,
var_612,
)?;
object_613.finish();
}
if let Some(var_614) = &input.capture_next_step {
#[allow(unused_mut)]
let mut object_615 = object.key("captureNextStep").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_state(&mut object_615, var_614)?;
object_615.finish();
}
if let Some(var_616) = &input.capture_conditional {
#[allow(unused_mut)]
let mut object_617 = object.key("captureConditional").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_specification(
&mut object_617,
var_616,
)?;
object_617.finish();
}
if let Some(var_618) = &input.failure_response {
#[allow(unused_mut)]
let mut object_619 = object.key("failureResponse").start_object();
crate::json_ser::serialize_structure_crate_model_response_specification(
&mut object_619,
var_618,
)?;
object_619.finish();
}
if let Some(var_620) = &input.failure_next_step {
#[allow(unused_mut)]
let mut object_621 = object.key("failureNextStep").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_state(&mut object_621, var_620)?;
object_621.finish();
}
if let Some(var_622) = &input.failure_conditional {
#[allow(unused_mut)]
let mut object_623 = object.key("failureConditional").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_specification(
&mut object_623,
var_622,
)?;
object_623.finish();
}
if let Some(var_624) = &input.code_hook {
#[allow(unused_mut)]
let mut object_625 = object.key("codeHook").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_code_hook_invocation_setting(
&mut object_625,
var_624,
)?;
object_625.finish();
}
if let Some(var_626) = &input.elicitation_code_hook {
#[allow(unused_mut)]
let mut object_627 = object.key("elicitationCodeHook").start_object();
crate::json_ser::serialize_structure_crate_model_elicitation_code_hook_invocation_setting(
&mut object_627,
var_626,
)?;
object_627.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sub_slot_type_composition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SubSlotTypeComposition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_628) = &input.name {
object.key("name").string(var_628.as_str());
}
if let Some(var_629) = &input.slot_type_id {
object.key("slotTypeId").string(var_629.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_grammar_slot_type_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GrammarSlotTypeSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_630) = &input.source {
#[allow(unused_mut)]
let mut object_631 = object.key("source").start_object();
crate::json_ser::serialize_structure_crate_model_grammar_slot_type_source(
&mut object_631,
var_630,
)?;
object_631.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sample_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SampleValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_632) = &input.value {
object.key("value").string(var_632.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_slot_value_regex_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SlotValueRegexFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_633) = &input.pattern {
object.key("pattern").string(var_633.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_advanced_recognition_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AdvancedRecognitionSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_634) = &input.audio_recognition_strategy {
object
.key("audioRecognitionStrategy")
.string(var_634.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_relative_aggregation_duration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RelativeAggregationDuration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_635) = &input.time_dimension {
object.key("timeDimension").string(var_635.as_str());
}
{
object.key("timeValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.time_value).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_bucket_transcript_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3BucketTranscriptSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_636) = &input.s3_bucket_name {
object.key("s3BucketName").string(var_636.as_str());
}
if let Some(var_637) = &input.path_format {
#[allow(unused_mut)]
let mut object_638 = object.key("pathFormat").start_object();
crate::json_ser::serialize_structure_crate_model_path_format(&mut object_638, var_637)?;
object_638.finish();
}
if let Some(var_639) = &input.transcript_format {
object.key("transcriptFormat").string(var_639.as_str());
}
if let Some(var_640) = &input.transcript_filter {
#[allow(unused_mut)]
let mut object_641 = object.key("transcriptFilter").start_object();
crate::json_ser::serialize_structure_crate_model_transcript_filter(
&mut object_641,
var_640,
)?;
object_641.finish();
}
if let Some(var_642) = &input.kms_key_arn {
object.key("kmsKeyArn").string(var_642.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_bot_import_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BotImportSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_643) = &input.bot_name {
object.key("botName").string(var_643.as_str());
}
if let Some(var_644) = &input.role_arn {
object.key("roleArn").string(var_644.as_str());
}
if let Some(var_645) = &input.data_privacy {
#[allow(unused_mut)]
let mut object_646 = object.key("dataPrivacy").start_object();
crate::json_ser::serialize_structure_crate_model_data_privacy(&mut object_646, var_645)?;
object_646.finish();
}
if let Some(var_647) = &input.idle_session_ttl_in_seconds {
object.key("idleSessionTTLInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_647).into()),
);
}
if let Some(var_648) = &input.bot_tags {
#[allow(unused_mut)]
let mut object_649 = object.key("botTags").start_object();
for (key_650, value_651) in var_648 {
{
object_649.key(key_650.as_str()).string(value_651.as_str());
}
}
object_649.finish();
}
if let Some(var_652) = &input.test_bot_alias_tags {
#[allow(unused_mut)]
let mut object_653 = object.key("testBotAliasTags").start_object();
for (key_654, value_655) in var_652 {
{
object_653.key(key_654.as_str()).string(value_655.as_str());
}
}
object_653.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_bot_locale_import_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BotLocaleImportSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_656) = &input.bot_id {
object.key("botId").string(var_656.as_str());
}
if let Some(var_657) = &input.bot_version {
object.key("botVersion").string(var_657.as_str());
}
if let Some(var_658) = &input.locale_id {
object.key("localeId").string(var_658.as_str());
}
if let Some(var_659) = &input.nlu_intent_confidence_threshold {
object.key("nluIntentConfidenceThreshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_659).into()),
);
}
if let Some(var_660) = &input.voice_settings {
#[allow(unused_mut)]
let mut object_661 = object.key("voiceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_voice_settings(&mut object_661, var_660)?;
object_661.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_vocabulary_import_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomVocabularyImportSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_662) = &input.bot_id {
object.key("botId").string(var_662.as_str());
}
if let Some(var_663) = &input.bot_version {
object.key("botVersion").string(var_663.as_str());
}
if let Some(var_664) = &input.locale_id {
object.key("localeId").string(var_664.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lambda_code_hook(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LambdaCodeHook,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_665) = &input.lambda_arn {
object.key("lambdaARN").string(var_665.as_str());
}
if let Some(var_666) = &input.code_hook_interface_version {
object
.key("codeHookInterfaceVersion")
.string(var_666.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_text_log_destination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TextLogDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_667) = &input.cloud_watch {
#[allow(unused_mut)]
let mut object_668 = object.key("cloudWatch").start_object();
crate::json_ser::serialize_structure_crate_model_cloud_watch_log_group_log_destination(
&mut object_668,
var_667,
)?;
object_668.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_audio_log_destination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AudioLogDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_669) = &input.s3_bucket {
#[allow(unused_mut)]
let mut object_670 = object.key("s3Bucket").start_object();
crate::json_ser::serialize_structure_crate_model_s3_bucket_log_destination(
&mut object_670,
var_669,
)?;
object_670.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_fulfillment_start_response_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FulfillmentStartResponseSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_671) = &input.delay_in_seconds {
object.key("delayInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_671).into()),
);
}
if let Some(var_672) = &input.message_groups {
let mut array_673 = object.key("messageGroups").start_array();
for item_674 in var_672 {
{
#[allow(unused_mut)]
let mut object_675 = array_673.value().start_object();
crate::json_ser::serialize_structure_crate_model_message_group(
&mut object_675,
item_674,
)?;
object_675.finish();
}
}
array_673.finish();
}
if let Some(var_676) = &input.allow_interrupt {
object.key("allowInterrupt").boolean(*var_676);
}
Ok(())
}
pub fn serialize_structure_crate_model_fulfillment_update_response_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FulfillmentUpdateResponseSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_677) = &input.frequency_in_seconds {
object.key("frequencyInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_677).into()),
);
}
if let Some(var_678) = &input.message_groups {
let mut array_679 = object.key("messageGroups").start_array();
for item_680 in var_678 {
{
#[allow(unused_mut)]
let mut object_681 = array_679.value().start_object();
crate::json_ser::serialize_structure_crate_model_message_group(
&mut object_681,
item_680,
)?;
object_681.finish();
}
}
array_679.finish();
}
if let Some(var_682) = &input.allow_interrupt {
object.key("allowInterrupt").boolean(*var_682);
}
Ok(())
}
pub fn serialize_structure_crate_model_message_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MessageGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_683) = &input.message {
#[allow(unused_mut)]
let mut object_684 = object.key("message").start_object();
crate::json_ser::serialize_structure_crate_model_message(&mut object_684, var_683)?;
object_684.finish();
}
if let Some(var_685) = &input.variations {
let mut array_686 = object.key("variations").start_array();
for item_687 in var_685 {
{
#[allow(unused_mut)]
let mut object_688 = array_686.value().start_object();
crate::json_ser::serialize_structure_crate_model_message(
&mut object_688,
item_687,
)?;
object_688.finish();
}
}
array_686.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_dialog_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DialogAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_689) = &input.r#type {
object.key("type").string(var_689.as_str());
}
if let Some(var_690) = &input.slot_to_elicit {
object.key("slotToElicit").string(var_690.as_str());
}
if let Some(var_691) = &input.suppress_next_message {
object.key("suppressNextMessage").boolean(*var_691);
}
Ok(())
}
pub fn serialize_structure_crate_model_intent_override(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IntentOverride,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_692) = &input.name {
object.key("name").string(var_692.as_str());
}
if let Some(var_693) = &input.slots {
#[allow(unused_mut)]
let mut object_694 = object.key("slots").start_object();
for (key_695, value_696) in var_693 {
{
#[allow(unused_mut)]
let mut object_697 = object_694.key(key_695.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_slot_value_override(
&mut object_697,
value_696,
)?;
object_697.finish();
}
}
object_694.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_conditional_branch(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConditionalBranch,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_698) = &input.name {
object.key("name").string(var_698.as_str());
}
if let Some(var_699) = &input.condition {
#[allow(unused_mut)]
let mut object_700 = object.key("condition").start_object();
crate::json_ser::serialize_structure_crate_model_condition(&mut object_700, var_699)?;
object_700.finish();
}
if let Some(var_701) = &input.next_step {
#[allow(unused_mut)]
let mut object_702 = object.key("nextStep").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_state(&mut object_702, var_701)?;
object_702.finish();
}
if let Some(var_703) = &input.response {
#[allow(unused_mut)]
let mut object_704 = object.key("response").start_object();
crate::json_ser::serialize_structure_crate_model_response_specification(
&mut object_704,
var_703,
)?;
object_704.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_default_conditional_branch(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DefaultConditionalBranch,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_705) = &input.next_step {
#[allow(unused_mut)]
let mut object_706 = object.key("nextStep").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_state(&mut object_706, var_705)?;
object_706.finish();
}
if let Some(var_707) = &input.response {
#[allow(unused_mut)]
let mut object_708 = object.key("response").start_object();
crate::json_ser::serialize_structure_crate_model_response_specification(
&mut object_708,
var_707,
)?;
object_708.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_post_dialog_code_hook_invocation_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PostDialogCodeHookInvocationSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_709) = &input.success_response {
#[allow(unused_mut)]
let mut object_710 = object.key("successResponse").start_object();
crate::json_ser::serialize_structure_crate_model_response_specification(
&mut object_710,
var_709,
)?;
object_710.finish();
}
if let Some(var_711) = &input.success_next_step {
#[allow(unused_mut)]
let mut object_712 = object.key("successNextStep").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_state(&mut object_712, var_711)?;
object_712.finish();
}
if let Some(var_713) = &input.success_conditional {
#[allow(unused_mut)]
let mut object_714 = object.key("successConditional").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_specification(
&mut object_714,
var_713,
)?;
object_714.finish();
}
if let Some(var_715) = &input.failure_response {
#[allow(unused_mut)]
let mut object_716 = object.key("failureResponse").start_object();
crate::json_ser::serialize_structure_crate_model_response_specification(
&mut object_716,
var_715,
)?;
object_716.finish();
}
if let Some(var_717) = &input.failure_next_step {
#[allow(unused_mut)]
let mut object_718 = object.key("failureNextStep").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_state(&mut object_718, var_717)?;
object_718.finish();
}
if let Some(var_719) = &input.failure_conditional {
#[allow(unused_mut)]
let mut object_720 = object.key("failureConditional").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_specification(
&mut object_720,
var_719,
)?;
object_720.finish();
}
if let Some(var_721) = &input.timeout_response {
#[allow(unused_mut)]
let mut object_722 = object.key("timeoutResponse").start_object();
crate::json_ser::serialize_structure_crate_model_response_specification(
&mut object_722,
var_721,
)?;
object_722.finish();
}
if let Some(var_723) = &input.timeout_next_step {
#[allow(unused_mut)]
let mut object_724 = object.key("timeoutNextStep").start_object();
crate::json_ser::serialize_structure_crate_model_dialog_state(&mut object_724, var_723)?;
object_724.finish();
}
if let Some(var_725) = &input.timeout_conditional {
#[allow(unused_mut)]
let mut object_726 = object.key("timeoutConditional").start_object();
crate::json_ser::serialize_structure_crate_model_conditional_specification(
&mut object_726,
var_725,
)?;
object_726.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_prompt_attempt_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PromptAttemptSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_727) = &input.allow_interrupt {
object.key("allowInterrupt").boolean(*var_727);
}
if let Some(var_728) = &input.allowed_input_types {
#[allow(unused_mut)]
let mut object_729 = object.key("allowedInputTypes").start_object();
crate::json_ser::serialize_structure_crate_model_allowed_input_types(
&mut object_729,
var_728,
)?;
object_729.finish();
}
if let Some(var_730) = &input.audio_and_dtmf_input_specification {
#[allow(unused_mut)]
let mut object_731 = object.key("audioAndDTMFInputSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_audio_and_dtmf_input_specification(
&mut object_731,
var_730,
)?;
object_731.finish();
}
if let Some(var_732) = &input.text_input_specification {
#[allow(unused_mut)]
let mut object_733 = object.key("textInputSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_text_input_specification(
&mut object_733,
var_732,
)?;
object_733.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sub_slot_value_elicitation_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SubSlotValueElicitationSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_734) = &input.default_value_specification {
#[allow(unused_mut)]
let mut object_735 = object.key("defaultValueSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_slot_default_value_specification(
&mut object_735,
var_734,
)?;
object_735.finish();
}
if let Some(var_736) = &input.prompt_specification {
#[allow(unused_mut)]
let mut object_737 = object.key("promptSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_prompt_specification(
&mut object_737,
var_736,
)?;
object_737.finish();
}
if let Some(var_738) = &input.sample_utterances {
let mut array_739 = object.key("sampleUtterances").start_array();
for item_740 in var_738 {
{
#[allow(unused_mut)]
let mut object_741 = array_739.value().start_object();
crate::json_ser::serialize_structure_crate_model_sample_utterance(
&mut object_741,
item_740,
)?;
object_741.finish();
}
}
array_739.finish();
}
if let Some(var_742) = &input.wait_and_continue_specification {
#[allow(unused_mut)]
let mut object_743 = object.key("waitAndContinueSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_wait_and_continue_specification(
&mut object_743,
var_742,
)?;
object_743.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_slot_default_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SlotDefaultValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_744) = &input.default_value {
object.key("defaultValue").string(var_744.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_still_waiting_response_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StillWaitingResponseSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_745) = &input.message_groups {
let mut array_746 = object.key("messageGroups").start_array();
for item_747 in var_745 {
{
#[allow(unused_mut)]
let mut object_748 = array_746.value().start_object();
crate::json_ser::serialize_structure_crate_model_message_group(
&mut object_748,
item_747,
)?;
object_748.finish();
}
}
array_746.finish();
}
if let Some(var_749) = &input.frequency_in_seconds {
object.key("frequencyInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_749).into()),
);
}
if let Some(var_750) = &input.timeout_in_seconds {
object.key("timeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_750).into()),
);
}
if let Some(var_751) = &input.allow_interrupt {
object.key("allowInterrupt").boolean(*var_751);
}
Ok(())
}
pub fn serialize_structure_crate_model_grammar_slot_type_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GrammarSlotTypeSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_752) = &input.s3_bucket_name {
object.key("s3BucketName").string(var_752.as_str());
}
if let Some(var_753) = &input.s3_object_key {
object.key("s3ObjectKey").string(var_753.as_str());
}
if let Some(var_754) = &input.kms_key_arn {
object.key("kmsKeyArn").string(var_754.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_path_format(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PathFormat,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_755) = &input.object_prefixes {
let mut array_756 = object.key("objectPrefixes").start_array();
for item_757 in var_755 {
{
array_756.value().string(item_757.as_str());
}
}
array_756.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_transcript_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TranscriptFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_758) = &input.lex_transcript_filter {
#[allow(unused_mut)]
let mut object_759 = object.key("lexTranscriptFilter").start_object();
crate::json_ser::serialize_structure_crate_model_lex_transcript_filter(
&mut object_759,
var_758,
)?;
object_759.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_cloud_watch_log_group_log_destination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CloudWatchLogGroupLogDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_760) = &input.cloud_watch_log_group_arn {
object.key("cloudWatchLogGroupArn").string(var_760.as_str());
}
if let Some(var_761) = &input.log_prefix {
object.key("logPrefix").string(var_761.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_bucket_log_destination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3BucketLogDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_762) = &input.kms_key_arn {
object.key("kmsKeyArn").string(var_762.as_str());
}
if let Some(var_763) = &input.s3_bucket_arn {
object.key("s3BucketArn").string(var_763.as_str());
}
if let Some(var_764) = &input.log_prefix {
object.key("logPrefix").string(var_764.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Message,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_765) = &input.plain_text_message {
#[allow(unused_mut)]
let mut object_766 = object.key("plainTextMessage").start_object();
crate::json_ser::serialize_structure_crate_model_plain_text_message(
&mut object_766,
var_765,
)?;
object_766.finish();
}
if let Some(var_767) = &input.custom_payload {
#[allow(unused_mut)]
let mut object_768 = object.key("customPayload").start_object();
crate::json_ser::serialize_structure_crate_model_custom_payload(&mut object_768, var_767)?;
object_768.finish();
}
if let Some(var_769) = &input.ssml_message {
#[allow(unused_mut)]
let mut object_770 = object.key("ssmlMessage").start_object();
crate::json_ser::serialize_structure_crate_model_ssml_message(&mut object_770, var_769)?;
object_770.finish();
}
if let Some(var_771) = &input.image_response_card {
#[allow(unused_mut)]
let mut object_772 = object.key("imageResponseCard").start_object();
crate::json_ser::serialize_structure_crate_model_image_response_card(
&mut object_772,
var_771,
)?;
object_772.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_slot_value_override(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SlotValueOverride,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_773) = &input.shape {
object.key("shape").string(var_773.as_str());
}
if let Some(var_774) = &input.value {
#[allow(unused_mut)]
let mut object_775 = object.key("value").start_object();
crate::json_ser::serialize_structure_crate_model_slot_value(&mut object_775, var_774)?;
object_775.finish();
}
if let Some(var_776) = &input.values {
let mut array_777 = object.key("values").start_array();
for item_778 in var_776 {
{
#[allow(unused_mut)]
let mut object_779 = array_777.value().start_object();
crate::json_ser::serialize_structure_crate_model_slot_value_override(
&mut object_779,
item_778,
)?;
object_779.finish();
}
}
array_777.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Condition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_780) = &input.expression_string {
object.key("expressionString").string(var_780.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_allowed_input_types(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AllowedInputTypes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_781) = &input.allow_audio_input {
object.key("allowAudioInput").boolean(*var_781);
}
if let Some(var_782) = &input.allow_dtmf_input {
object.key("allowDTMFInput").boolean(*var_782);
}
Ok(())
}
pub fn serialize_structure_crate_model_audio_and_dtmf_input_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AudioAndDtmfInputSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_783) = &input.start_timeout_ms {
object.key("startTimeoutMs").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_783).into()),
);
}
if let Some(var_784) = &input.audio_specification {
#[allow(unused_mut)]
let mut object_785 = object.key("audioSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_audio_specification(
&mut object_785,
var_784,
)?;
object_785.finish();
}
if let Some(var_786) = &input.dtmf_specification {
#[allow(unused_mut)]
let mut object_787 = object.key("dtmfSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_dtmf_specification(
&mut object_787,
var_786,
)?;
object_787.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_text_input_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TextInputSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_788) = &input.start_timeout_ms {
object.key("startTimeoutMs").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_788).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_lex_transcript_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LexTranscriptFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_789) = &input.date_range_filter {
#[allow(unused_mut)]
let mut object_790 = object.key("dateRangeFilter").start_object();
crate::json_ser::serialize_structure_crate_model_date_range_filter(
&mut object_790,
var_789,
)?;
object_790.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_plain_text_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PlainTextMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_791) = &input.value {
object.key("value").string(var_791.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_payload(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomPayload,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_792) = &input.value {
object.key("value").string(var_792.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ssml_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SsmlMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_793) = &input.value {
object.key("value").string(var_793.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_image_response_card(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImageResponseCard,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_794) = &input.title {
object.key("title").string(var_794.as_str());
}
if let Some(var_795) = &input.subtitle {
object.key("subtitle").string(var_795.as_str());
}
if let Some(var_796) = &input.image_url {
object.key("imageUrl").string(var_796.as_str());
}
if let Some(var_797) = &input.buttons {
let mut array_798 = object.key("buttons").start_array();
for item_799 in var_797 {
{
#[allow(unused_mut)]
let mut object_800 = array_798.value().start_object();
crate::json_ser::serialize_structure_crate_model_button(&mut object_800, item_799)?;
object_800.finish();
}
}
array_798.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_slot_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SlotValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_801) = &input.interpreted_value {
object.key("interpretedValue").string(var_801.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_audio_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AudioSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_802) = &input.max_length_ms {
object.key("maxLengthMs").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_802).into()),
);
}
if let Some(var_803) = &input.end_timeout_ms {
object.key("endTimeoutMs").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_803).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_dtmf_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DtmfSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_804) = &input.max_length {
object.key("maxLength").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_804).into()),
);
}
if let Some(var_805) = &input.end_timeout_ms {
object.key("endTimeoutMs").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_805).into()),
);
}
if let Some(var_806) = &input.deletion_character {
object.key("deletionCharacter").string(var_806.as_str());
}
if let Some(var_807) = &input.end_character {
object.key("endCharacter").string(var_807.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_date_range_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DateRangeFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_808) = &input.start_date_time {
object
.key("startDateTime")
.date_time(var_808, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_809) = &input.end_date_time {
object
.key("endDateTime")
.date_time(var_809, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_button(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Button,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_810) = &input.text {
object.key("text").string(var_810.as_str());
}
if let Some(var_811) = &input.value {
object.key("value").string(var_811.as_str());
}
Ok(())
}