#[allow(unused_mut)]
pub fn serialize_structure_crate_model_analysis_scheme(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::AnalysisScheme,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_1 = writer.prefix("AnalysisSchemeName");
if let Some(var_2) = &input.analysis_scheme_name {
scope_1.string(var_2);
}
#[allow(unused_mut)]
let mut scope_3 = writer.prefix("AnalysisSchemeLanguage");
if let Some(var_4) = &input.analysis_scheme_language {
scope_3.string(var_4.as_str());
}
#[allow(unused_mut)]
let mut scope_5 = writer.prefix("AnalysisOptions");
if let Some(var_6) = &input.analysis_options {
crate::query_ser::serialize_structure_crate_model_analysis_options(scope_5, var_6)?;
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_expression(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Expression,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_7 = writer.prefix("ExpressionName");
if let Some(var_8) = &input.expression_name {
scope_7.string(var_8);
}
#[allow(unused_mut)]
let mut scope_9 = writer.prefix("ExpressionValue");
if let Some(var_10) = &input.expression_value {
scope_9.string(var_10);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_index_field(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::IndexField,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_11 = writer.prefix("IndexFieldName");
if let Some(var_12) = &input.index_field_name {
scope_11.string(var_12);
}
#[allow(unused_mut)]
let mut scope_13 = writer.prefix("IndexFieldType");
if let Some(var_14) = &input.index_field_type {
scope_13.string(var_14.as_str());
}
#[allow(unused_mut)]
let mut scope_15 = writer.prefix("IntOptions");
if let Some(var_16) = &input.int_options {
crate::query_ser::serialize_structure_crate_model_int_options(scope_15, var_16)?;
}
#[allow(unused_mut)]
let mut scope_17 = writer.prefix("DoubleOptions");
if let Some(var_18) = &input.double_options {
crate::query_ser::serialize_structure_crate_model_double_options(scope_17, var_18)?;
}
#[allow(unused_mut)]
let mut scope_19 = writer.prefix("LiteralOptions");
if let Some(var_20) = &input.literal_options {
crate::query_ser::serialize_structure_crate_model_literal_options(scope_19, var_20)?;
}
#[allow(unused_mut)]
let mut scope_21 = writer.prefix("TextOptions");
if let Some(var_22) = &input.text_options {
crate::query_ser::serialize_structure_crate_model_text_options(scope_21, var_22)?;
}
#[allow(unused_mut)]
let mut scope_23 = writer.prefix("DateOptions");
if let Some(var_24) = &input.date_options {
crate::query_ser::serialize_structure_crate_model_date_options(scope_23, var_24)?;
}
#[allow(unused_mut)]
let mut scope_25 = writer.prefix("LatLonOptions");
if let Some(var_26) = &input.lat_lon_options {
crate::query_ser::serialize_structure_crate_model_lat_lon_options(scope_25, var_26)?;
}
#[allow(unused_mut)]
let mut scope_27 = writer.prefix("IntArrayOptions");
if let Some(var_28) = &input.int_array_options {
crate::query_ser::serialize_structure_crate_model_int_array_options(scope_27, var_28)?;
}
#[allow(unused_mut)]
let mut scope_29 = writer.prefix("DoubleArrayOptions");
if let Some(var_30) = &input.double_array_options {
crate::query_ser::serialize_structure_crate_model_double_array_options(scope_29, var_30)?;
}
#[allow(unused_mut)]
let mut scope_31 = writer.prefix("LiteralArrayOptions");
if let Some(var_32) = &input.literal_array_options {
crate::query_ser::serialize_structure_crate_model_literal_array_options(scope_31, var_32)?;
}
#[allow(unused_mut)]
let mut scope_33 = writer.prefix("TextArrayOptions");
if let Some(var_34) = &input.text_array_options {
crate::query_ser::serialize_structure_crate_model_text_array_options(scope_33, var_34)?;
}
#[allow(unused_mut)]
let mut scope_35 = writer.prefix("DateArrayOptions");
if let Some(var_36) = &input.date_array_options {
crate::query_ser::serialize_structure_crate_model_date_array_options(scope_35, var_36)?;
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_suggester(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Suggester,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_37 = writer.prefix("SuggesterName");
if let Some(var_38) = &input.suggester_name {
scope_37.string(var_38);
}
#[allow(unused_mut)]
let mut scope_39 = writer.prefix("DocumentSuggesterOptions");
if let Some(var_40) = &input.document_suggester_options {
crate::query_ser::serialize_structure_crate_model_document_suggester_options(
scope_39, var_40,
)?;
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_domain_endpoint_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::DomainEndpointOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_41 = writer.prefix("EnforceHTTPS");
if let Some(var_42) = &input.enforce_https {
scope_41.boolean(*var_42);
}
#[allow(unused_mut)]
let mut scope_43 = writer.prefix("TLSSecurityPolicy");
if let Some(var_44) = &input.tls_security_policy {
scope_43.string(var_44.as_str());
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_scaling_parameters(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ScalingParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_45 = writer.prefix("DesiredInstanceType");
if let Some(var_46) = &input.desired_instance_type {
scope_45.string(var_46.as_str());
}
#[allow(unused_mut)]
let mut scope_47 = writer.prefix("DesiredReplicationCount");
if input.desired_replication_count != 0 {
scope_47.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.desired_replication_count).into()),
);
}
#[allow(unused_mut)]
let mut scope_48 = writer.prefix("DesiredPartitionCount");
if input.desired_partition_count != 0 {
scope_48.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.desired_partition_count).into()),
);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_analysis_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::AnalysisOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_49 = writer.prefix("Synonyms");
if let Some(var_50) = &input.synonyms {
scope_49.string(var_50);
}
#[allow(unused_mut)]
let mut scope_51 = writer.prefix("Stopwords");
if let Some(var_52) = &input.stopwords {
scope_51.string(var_52);
}
#[allow(unused_mut)]
let mut scope_53 = writer.prefix("StemmingDictionary");
if let Some(var_54) = &input.stemming_dictionary {
scope_53.string(var_54);
}
#[allow(unused_mut)]
let mut scope_55 = writer.prefix("JapaneseTokenizationDictionary");
if let Some(var_56) = &input.japanese_tokenization_dictionary {
scope_55.string(var_56);
}
#[allow(unused_mut)]
let mut scope_57 = writer.prefix("AlgorithmicStemming");
if let Some(var_58) = &input.algorithmic_stemming {
scope_57.string(var_58.as_str());
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_int_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::IntOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_59 = writer.prefix("DefaultValue");
if let Some(var_60) = &input.default_value {
scope_59.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_60).into()),
);
}
#[allow(unused_mut)]
let mut scope_61 = writer.prefix("SourceField");
if let Some(var_62) = &input.source_field {
scope_61.string(var_62);
}
#[allow(unused_mut)]
let mut scope_63 = writer.prefix("FacetEnabled");
if let Some(var_64) = &input.facet_enabled {
scope_63.boolean(*var_64);
}
#[allow(unused_mut)]
let mut scope_65 = writer.prefix("SearchEnabled");
if let Some(var_66) = &input.search_enabled {
scope_65.boolean(*var_66);
}
#[allow(unused_mut)]
let mut scope_67 = writer.prefix("ReturnEnabled");
if let Some(var_68) = &input.return_enabled {
scope_67.boolean(*var_68);
}
#[allow(unused_mut)]
let mut scope_69 = writer.prefix("SortEnabled");
if let Some(var_70) = &input.sort_enabled {
scope_69.boolean(*var_70);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_double_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::DoubleOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_71 = writer.prefix("DefaultValue");
if let Some(var_72) = &input.default_value {
scope_71.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_72).into()),
);
}
#[allow(unused_mut)]
let mut scope_73 = writer.prefix("SourceField");
if let Some(var_74) = &input.source_field {
scope_73.string(var_74);
}
#[allow(unused_mut)]
let mut scope_75 = writer.prefix("FacetEnabled");
if let Some(var_76) = &input.facet_enabled {
scope_75.boolean(*var_76);
}
#[allow(unused_mut)]
let mut scope_77 = writer.prefix("SearchEnabled");
if let Some(var_78) = &input.search_enabled {
scope_77.boolean(*var_78);
}
#[allow(unused_mut)]
let mut scope_79 = writer.prefix("ReturnEnabled");
if let Some(var_80) = &input.return_enabled {
scope_79.boolean(*var_80);
}
#[allow(unused_mut)]
let mut scope_81 = writer.prefix("SortEnabled");
if let Some(var_82) = &input.sort_enabled {
scope_81.boolean(*var_82);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_literal_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LiteralOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_83 = writer.prefix("DefaultValue");
if let Some(var_84) = &input.default_value {
scope_83.string(var_84);
}
#[allow(unused_mut)]
let mut scope_85 = writer.prefix("SourceField");
if let Some(var_86) = &input.source_field {
scope_85.string(var_86);
}
#[allow(unused_mut)]
let mut scope_87 = writer.prefix("FacetEnabled");
if let Some(var_88) = &input.facet_enabled {
scope_87.boolean(*var_88);
}
#[allow(unused_mut)]
let mut scope_89 = writer.prefix("SearchEnabled");
if let Some(var_90) = &input.search_enabled {
scope_89.boolean(*var_90);
}
#[allow(unused_mut)]
let mut scope_91 = writer.prefix("ReturnEnabled");
if let Some(var_92) = &input.return_enabled {
scope_91.boolean(*var_92);
}
#[allow(unused_mut)]
let mut scope_93 = writer.prefix("SortEnabled");
if let Some(var_94) = &input.sort_enabled {
scope_93.boolean(*var_94);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_text_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::TextOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_95 = writer.prefix("DefaultValue");
if let Some(var_96) = &input.default_value {
scope_95.string(var_96);
}
#[allow(unused_mut)]
let mut scope_97 = writer.prefix("SourceField");
if let Some(var_98) = &input.source_field {
scope_97.string(var_98);
}
#[allow(unused_mut)]
let mut scope_99 = writer.prefix("ReturnEnabled");
if let Some(var_100) = &input.return_enabled {
scope_99.boolean(*var_100);
}
#[allow(unused_mut)]
let mut scope_101 = writer.prefix("SortEnabled");
if let Some(var_102) = &input.sort_enabled {
scope_101.boolean(*var_102);
}
#[allow(unused_mut)]
let mut scope_103 = writer.prefix("HighlightEnabled");
if let Some(var_104) = &input.highlight_enabled {
scope_103.boolean(*var_104);
}
#[allow(unused_mut)]
let mut scope_105 = writer.prefix("AnalysisScheme");
if let Some(var_106) = &input.analysis_scheme {
scope_105.string(var_106);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_date_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::DateOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_107 = writer.prefix("DefaultValue");
if let Some(var_108) = &input.default_value {
scope_107.string(var_108);
}
#[allow(unused_mut)]
let mut scope_109 = writer.prefix("SourceField");
if let Some(var_110) = &input.source_field {
scope_109.string(var_110);
}
#[allow(unused_mut)]
let mut scope_111 = writer.prefix("FacetEnabled");
if let Some(var_112) = &input.facet_enabled {
scope_111.boolean(*var_112);
}
#[allow(unused_mut)]
let mut scope_113 = writer.prefix("SearchEnabled");
if let Some(var_114) = &input.search_enabled {
scope_113.boolean(*var_114);
}
#[allow(unused_mut)]
let mut scope_115 = writer.prefix("ReturnEnabled");
if let Some(var_116) = &input.return_enabled {
scope_115.boolean(*var_116);
}
#[allow(unused_mut)]
let mut scope_117 = writer.prefix("SortEnabled");
if let Some(var_118) = &input.sort_enabled {
scope_117.boolean(*var_118);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_lat_lon_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LatLonOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_119 = writer.prefix("DefaultValue");
if let Some(var_120) = &input.default_value {
scope_119.string(var_120);
}
#[allow(unused_mut)]
let mut scope_121 = writer.prefix("SourceField");
if let Some(var_122) = &input.source_field {
scope_121.string(var_122);
}
#[allow(unused_mut)]
let mut scope_123 = writer.prefix("FacetEnabled");
if let Some(var_124) = &input.facet_enabled {
scope_123.boolean(*var_124);
}
#[allow(unused_mut)]
let mut scope_125 = writer.prefix("SearchEnabled");
if let Some(var_126) = &input.search_enabled {
scope_125.boolean(*var_126);
}
#[allow(unused_mut)]
let mut scope_127 = writer.prefix("ReturnEnabled");
if let Some(var_128) = &input.return_enabled {
scope_127.boolean(*var_128);
}
#[allow(unused_mut)]
let mut scope_129 = writer.prefix("SortEnabled");
if let Some(var_130) = &input.sort_enabled {
scope_129.boolean(*var_130);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_int_array_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::IntArrayOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_131 = writer.prefix("DefaultValue");
if let Some(var_132) = &input.default_value {
scope_131.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_132).into()),
);
}
#[allow(unused_mut)]
let mut scope_133 = writer.prefix("SourceFields");
if let Some(var_134) = &input.source_fields {
scope_133.string(var_134);
}
#[allow(unused_mut)]
let mut scope_135 = writer.prefix("FacetEnabled");
if let Some(var_136) = &input.facet_enabled {
scope_135.boolean(*var_136);
}
#[allow(unused_mut)]
let mut scope_137 = writer.prefix("SearchEnabled");
if let Some(var_138) = &input.search_enabled {
scope_137.boolean(*var_138);
}
#[allow(unused_mut)]
let mut scope_139 = writer.prefix("ReturnEnabled");
if let Some(var_140) = &input.return_enabled {
scope_139.boolean(*var_140);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_double_array_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::DoubleArrayOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_141 = writer.prefix("DefaultValue");
if let Some(var_142) = &input.default_value {
scope_141.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_142).into()),
);
}
#[allow(unused_mut)]
let mut scope_143 = writer.prefix("SourceFields");
if let Some(var_144) = &input.source_fields {
scope_143.string(var_144);
}
#[allow(unused_mut)]
let mut scope_145 = writer.prefix("FacetEnabled");
if let Some(var_146) = &input.facet_enabled {
scope_145.boolean(*var_146);
}
#[allow(unused_mut)]
let mut scope_147 = writer.prefix("SearchEnabled");
if let Some(var_148) = &input.search_enabled {
scope_147.boolean(*var_148);
}
#[allow(unused_mut)]
let mut scope_149 = writer.prefix("ReturnEnabled");
if let Some(var_150) = &input.return_enabled {
scope_149.boolean(*var_150);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_literal_array_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LiteralArrayOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_151 = writer.prefix("DefaultValue");
if let Some(var_152) = &input.default_value {
scope_151.string(var_152);
}
#[allow(unused_mut)]
let mut scope_153 = writer.prefix("SourceFields");
if let Some(var_154) = &input.source_fields {
scope_153.string(var_154);
}
#[allow(unused_mut)]
let mut scope_155 = writer.prefix("FacetEnabled");
if let Some(var_156) = &input.facet_enabled {
scope_155.boolean(*var_156);
}
#[allow(unused_mut)]
let mut scope_157 = writer.prefix("SearchEnabled");
if let Some(var_158) = &input.search_enabled {
scope_157.boolean(*var_158);
}
#[allow(unused_mut)]
let mut scope_159 = writer.prefix("ReturnEnabled");
if let Some(var_160) = &input.return_enabled {
scope_159.boolean(*var_160);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_text_array_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::TextArrayOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_161 = writer.prefix("DefaultValue");
if let Some(var_162) = &input.default_value {
scope_161.string(var_162);
}
#[allow(unused_mut)]
let mut scope_163 = writer.prefix("SourceFields");
if let Some(var_164) = &input.source_fields {
scope_163.string(var_164);
}
#[allow(unused_mut)]
let mut scope_165 = writer.prefix("ReturnEnabled");
if let Some(var_166) = &input.return_enabled {
scope_165.boolean(*var_166);
}
#[allow(unused_mut)]
let mut scope_167 = writer.prefix("HighlightEnabled");
if let Some(var_168) = &input.highlight_enabled {
scope_167.boolean(*var_168);
}
#[allow(unused_mut)]
let mut scope_169 = writer.prefix("AnalysisScheme");
if let Some(var_170) = &input.analysis_scheme {
scope_169.string(var_170);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_date_array_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::DateArrayOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_171 = writer.prefix("DefaultValue");
if let Some(var_172) = &input.default_value {
scope_171.string(var_172);
}
#[allow(unused_mut)]
let mut scope_173 = writer.prefix("SourceFields");
if let Some(var_174) = &input.source_fields {
scope_173.string(var_174);
}
#[allow(unused_mut)]
let mut scope_175 = writer.prefix("FacetEnabled");
if let Some(var_176) = &input.facet_enabled {
scope_175.boolean(*var_176);
}
#[allow(unused_mut)]
let mut scope_177 = writer.prefix("SearchEnabled");
if let Some(var_178) = &input.search_enabled {
scope_177.boolean(*var_178);
}
#[allow(unused_mut)]
let mut scope_179 = writer.prefix("ReturnEnabled");
if let Some(var_180) = &input.return_enabled {
scope_179.boolean(*var_180);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_document_suggester_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::DocumentSuggesterOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_181 = writer.prefix("SourceField");
if let Some(var_182) = &input.source_field {
scope_181.string(var_182);
}
#[allow(unused_mut)]
let mut scope_183 = writer.prefix("FuzzyMatching");
if let Some(var_184) = &input.fuzzy_matching {
scope_183.string(var_184.as_str());
}
#[allow(unused_mut)]
let mut scope_185 = writer.prefix("SortExpression");
if let Some(var_186) = &input.sort_expression {
scope_185.string(var_186);
}
Ok(())
}