pub fn serialize_structure_crate_input_create_api_key_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateApiKeyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.customer_id {
object.key("customerId").string(var_1.as_str());
}
if let Some(var_2) = &input.description {
object.key("description").string(var_2.as_str());
}
if input.enabled {
object.key("enabled").boolean(input.enabled);
}
if input.generate_distinct_id {
object
.key("generateDistinctId")
.boolean(input.generate_distinct_id);
}
if let Some(var_3) = &input.name {
object.key("name").string(var_3.as_str());
}
if let Some(var_4) = &input.stage_keys {
let mut array_5 = object.key("stageKeys").start_array();
for item_6 in var_4 {
{
#[allow(unused_mut)]
let mut object_7 = array_5.value().start_object();
crate::json_ser::serialize_structure_crate_model_stage_key(&mut object_7, item_6)?;
object_7.finish();
}
}
array_5.finish();
}
if let Some(var_8) = &input.tags {
#[allow(unused_mut)]
let mut object_9 = object.key("tags").start_object();
for (key_10, value_11) in var_8 {
{
object_9.key(key_10.as_str()).string(value_11.as_str());
}
}
object_9.finish();
}
if let Some(var_12) = &input.value {
object.key("value").string(var_12.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_authorizer_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAuthorizerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_13) = &input.auth_type {
object.key("authType").string(var_13.as_str());
}
if let Some(var_14) = &input.authorizer_credentials {
object.key("authorizerCredentials").string(var_14.as_str());
}
if let Some(var_15) = &input.authorizer_result_ttl_in_seconds {
object.key("authorizerResultTtlInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_15).into()),
);
}
if let Some(var_16) = &input.authorizer_uri {
object.key("authorizerUri").string(var_16.as_str());
}
if let Some(var_17) = &input.identity_source {
object.key("identitySource").string(var_17.as_str());
}
if let Some(var_18) = &input.identity_validation_expression {
object
.key("identityValidationExpression")
.string(var_18.as_str());
}
if let Some(var_19) = &input.name {
object.key("name").string(var_19.as_str());
}
if let Some(var_20) = &input.provider_ar_ns {
let mut array_21 = object.key("providerARNs").start_array();
for item_22 in var_20 {
{
array_21.value().string(item_22.as_str());
}
}
array_21.finish();
}
if let Some(var_23) = &input.r#type {
object.key("type").string(var_23.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_base_path_mapping_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBasePathMappingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_24) = &input.base_path {
object.key("basePath").string(var_24.as_str());
}
if let Some(var_25) = &input.rest_api_id {
object.key("restApiId").string(var_25.as_str());
}
if let Some(var_26) = &input.stage {
object.key("stage").string(var_26.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_deployment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDeploymentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_27) = &input.cache_cluster_enabled {
object.key("cacheClusterEnabled").boolean(*var_27);
}
if let Some(var_28) = &input.cache_cluster_size {
object.key("cacheClusterSize").string(var_28.as_str());
}
if let Some(var_29) = &input.canary_settings {
#[allow(unused_mut)]
let mut object_30 = object.key("canarySettings").start_object();
crate::json_ser::serialize_structure_crate_model_deployment_canary_settings(
&mut object_30,
var_29,
)?;
object_30.finish();
}
if let Some(var_31) = &input.description {
object.key("description").string(var_31.as_str());
}
if let Some(var_32) = &input.stage_description {
object.key("stageDescription").string(var_32.as_str());
}
if let Some(var_33) = &input.stage_name {
object.key("stageName").string(var_33.as_str());
}
if let Some(var_34) = &input.tracing_enabled {
object.key("tracingEnabled").boolean(*var_34);
}
if let Some(var_35) = &input.variables {
#[allow(unused_mut)]
let mut object_36 = object.key("variables").start_object();
for (key_37, value_38) in var_35 {
{
object_36.key(key_37.as_str()).string(value_38.as_str());
}
}
object_36.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_documentation_part_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDocumentationPartInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_39) = &input.location {
#[allow(unused_mut)]
let mut object_40 = object.key("location").start_object();
crate::json_ser::serialize_structure_crate_model_documentation_part_location(
&mut object_40,
var_39,
)?;
object_40.finish();
}
if let Some(var_41) = &input.properties {
object.key("properties").string(var_41.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_documentation_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDocumentationVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_42) = &input.description {
object.key("description").string(var_42.as_str());
}
if let Some(var_43) = &input.documentation_version {
object.key("documentationVersion").string(var_43.as_str());
}
if let Some(var_44) = &input.stage_name {
object.key("stageName").string(var_44.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_domain_name_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDomainNameInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_45) = &input.certificate_arn {
object.key("certificateArn").string(var_45.as_str());
}
if let Some(var_46) = &input.certificate_body {
object.key("certificateBody").string(var_46.as_str());
}
if let Some(var_47) = &input.certificate_chain {
object.key("certificateChain").string(var_47.as_str());
}
if let Some(var_48) = &input.certificate_name {
object.key("certificateName").string(var_48.as_str());
}
if let Some(var_49) = &input.certificate_private_key {
object.key("certificatePrivateKey").string(var_49.as_str());
}
if let Some(var_50) = &input.domain_name {
object.key("domainName").string(var_50.as_str());
}
if let Some(var_51) = &input.endpoint_configuration {
#[allow(unused_mut)]
let mut object_52 = object.key("endpointConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_configuration(
&mut object_52,
var_51,
)?;
object_52.finish();
}
if let Some(var_53) = &input.mutual_tls_authentication {
#[allow(unused_mut)]
let mut object_54 = object.key("mutualTlsAuthentication").start_object();
crate::json_ser::serialize_structure_crate_model_mutual_tls_authentication_input(
&mut object_54,
var_53,
)?;
object_54.finish();
}
if let Some(var_55) = &input.ownership_verification_certificate_arn {
object
.key("ownershipVerificationCertificateArn")
.string(var_55.as_str());
}
if let Some(var_56) = &input.regional_certificate_arn {
object.key("regionalCertificateArn").string(var_56.as_str());
}
if let Some(var_57) = &input.regional_certificate_name {
object
.key("regionalCertificateName")
.string(var_57.as_str());
}
if let Some(var_58) = &input.security_policy {
object.key("securityPolicy").string(var_58.as_str());
}
if let Some(var_59) = &input.tags {
#[allow(unused_mut)]
let mut object_60 = object.key("tags").start_object();
for (key_61, value_62) in var_59 {
{
object_60.key(key_61.as_str()).string(value_62.as_str());
}
}
object_60.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_63) = &input.content_type {
object.key("contentType").string(var_63.as_str());
}
if let Some(var_64) = &input.description {
object.key("description").string(var_64.as_str());
}
if let Some(var_65) = &input.name {
object.key("name").string(var_65.as_str());
}
if let Some(var_66) = &input.schema {
object.key("schema").string(var_66.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_request_validator_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateRequestValidatorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_67) = &input.name {
object.key("name").string(var_67.as_str());
}
if input.validate_request_body {
object
.key("validateRequestBody")
.boolean(input.validate_request_body);
}
if input.validate_request_parameters {
object
.key("validateRequestParameters")
.boolean(input.validate_request_parameters);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_68) = &input.path_part {
object.key("pathPart").string(var_68.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_rest_api_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateRestApiInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_69) = &input.api_key_source {
object.key("apiKeySource").string(var_69.as_str());
}
if let Some(var_70) = &input.binary_media_types {
let mut array_71 = object.key("binaryMediaTypes").start_array();
for item_72 in var_70 {
{
array_71.value().string(item_72.as_str());
}
}
array_71.finish();
}
if let Some(var_73) = &input.clone_from {
object.key("cloneFrom").string(var_73.as_str());
}
if let Some(var_74) = &input.description {
object.key("description").string(var_74.as_str());
}
if input.disable_execute_api_endpoint {
object
.key("disableExecuteApiEndpoint")
.boolean(input.disable_execute_api_endpoint);
}
if let Some(var_75) = &input.endpoint_configuration {
#[allow(unused_mut)]
let mut object_76 = object.key("endpointConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_configuration(
&mut object_76,
var_75,
)?;
object_76.finish();
}
if let Some(var_77) = &input.minimum_compression_size {
object.key("minimumCompressionSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_77).into()),
);
}
if let Some(var_78) = &input.name {
object.key("name").string(var_78.as_str());
}
if let Some(var_79) = &input.policy {
object.key("policy").string(var_79.as_str());
}
if let Some(var_80) = &input.tags {
#[allow(unused_mut)]
let mut object_81 = object.key("tags").start_object();
for (key_82, value_83) in var_80 {
{
object_81.key(key_82.as_str()).string(value_83.as_str());
}
}
object_81.finish();
}
if let Some(var_84) = &input.version {
object.key("version").string(var_84.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_stage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateStageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.cache_cluster_enabled {
object
.key("cacheClusterEnabled")
.boolean(input.cache_cluster_enabled);
}
if let Some(var_85) = &input.cache_cluster_size {
object.key("cacheClusterSize").string(var_85.as_str());
}
if let Some(var_86) = &input.canary_settings {
#[allow(unused_mut)]
let mut object_87 = object.key("canarySettings").start_object();
crate::json_ser::serialize_structure_crate_model_canary_settings(&mut object_87, var_86)?;
object_87.finish();
}
if let Some(var_88) = &input.deployment_id {
object.key("deploymentId").string(var_88.as_str());
}
if let Some(var_89) = &input.description {
object.key("description").string(var_89.as_str());
}
if let Some(var_90) = &input.documentation_version {
object.key("documentationVersion").string(var_90.as_str());
}
if let Some(var_91) = &input.stage_name {
object.key("stageName").string(var_91.as_str());
}
if let Some(var_92) = &input.tags {
#[allow(unused_mut)]
let mut object_93 = object.key("tags").start_object();
for (key_94, value_95) in var_92 {
{
object_93.key(key_94.as_str()).string(value_95.as_str());
}
}
object_93.finish();
}
if input.tracing_enabled {
object.key("tracingEnabled").boolean(input.tracing_enabled);
}
if let Some(var_96) = &input.variables {
#[allow(unused_mut)]
let mut object_97 = object.key("variables").start_object();
for (key_98, value_99) in var_96 {
{
object_97.key(key_98.as_str()).string(value_99.as_str());
}
}
object_97.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_usage_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateUsagePlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_100) = &input.api_stages {
let mut array_101 = object.key("apiStages").start_array();
for item_102 in var_100 {
{
#[allow(unused_mut)]
let mut object_103 = array_101.value().start_object();
crate::json_ser::serialize_structure_crate_model_api_stage(
&mut object_103,
item_102,
)?;
object_103.finish();
}
}
array_101.finish();
}
if let Some(var_104) = &input.description {
object.key("description").string(var_104.as_str());
}
if let Some(var_105) = &input.name {
object.key("name").string(var_105.as_str());
}
if let Some(var_106) = &input.quota {
#[allow(unused_mut)]
let mut object_107 = object.key("quota").start_object();
crate::json_ser::serialize_structure_crate_model_quota_settings(&mut object_107, var_106)?;
object_107.finish();
}
if let Some(var_108) = &input.tags {
#[allow(unused_mut)]
let mut object_109 = object.key("tags").start_object();
for (key_110, value_111) in var_108 {
{
object_109.key(key_110.as_str()).string(value_111.as_str());
}
}
object_109.finish();
}
if let Some(var_112) = &input.throttle {
#[allow(unused_mut)]
let mut object_113 = object.key("throttle").start_object();
crate::json_ser::serialize_structure_crate_model_throttle_settings(
&mut object_113,
var_112,
)?;
object_113.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_usage_plan_key_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateUsagePlanKeyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_114) = &input.key_id {
object.key("keyId").string(var_114.as_str());
}
if let Some(var_115) = &input.key_type {
object.key("keyType").string(var_115.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_vpc_link_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateVpcLinkInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_116) = &input.description {
object.key("description").string(var_116.as_str());
}
if let Some(var_117) = &input.name {
object.key("name").string(var_117.as_str());
}
if let Some(var_118) = &input.tags {
#[allow(unused_mut)]
let mut object_119 = object.key("tags").start_object();
for (key_120, value_121) in var_118 {
{
object_119.key(key_120.as_str()).string(value_121.as_str());
}
}
object_119.finish();
}
if let Some(var_122) = &input.target_arns {
let mut array_123 = object.key("targetArns").start_array();
for item_124 in var_122 {
{
array_123.value().string(item_124.as_str());
}
}
array_123.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_generate_client_certificate_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GenerateClientCertificateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_125) = &input.description {
object.key("description").string(var_125.as_str());
}
if let Some(var_126) = &input.tags {
#[allow(unused_mut)]
let mut object_127 = object.key("tags").start_object();
for (key_128, value_129) in var_126 {
{
object_127.key(key_128.as_str()).string(value_129.as_str());
}
}
object_127.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_gateway_response_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutGatewayResponseInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_130) = &input.response_parameters {
#[allow(unused_mut)]
let mut object_131 = object.key("responseParameters").start_object();
for (key_132, value_133) in var_130 {
{
object_131.key(key_132.as_str()).string(value_133.as_str());
}
}
object_131.finish();
}
if let Some(var_134) = &input.response_templates {
#[allow(unused_mut)]
let mut object_135 = object.key("responseTemplates").start_object();
for (key_136, value_137) in var_134 {
{
object_135.key(key_136.as_str()).string(value_137.as_str());
}
}
object_135.finish();
}
if let Some(var_138) = &input.status_code {
object.key("statusCode").string(var_138.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_integration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutIntegrationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_139) = &input.cache_key_parameters {
let mut array_140 = object.key("cacheKeyParameters").start_array();
for item_141 in var_139 {
{
array_140.value().string(item_141.as_str());
}
}
array_140.finish();
}
if let Some(var_142) = &input.cache_namespace {
object.key("cacheNamespace").string(var_142.as_str());
}
if let Some(var_143) = &input.connection_id {
object.key("connectionId").string(var_143.as_str());
}
if let Some(var_144) = &input.connection_type {
object.key("connectionType").string(var_144.as_str());
}
if let Some(var_145) = &input.content_handling {
object.key("contentHandling").string(var_145.as_str());
}
if let Some(var_146) = &input.credentials {
object.key("credentials").string(var_146.as_str());
}
if let Some(var_147) = &input.integration_http_method {
object.key("httpMethod").string(var_147.as_str());
}
if let Some(var_148) = &input.passthrough_behavior {
object.key("passthroughBehavior").string(var_148.as_str());
}
if let Some(var_149) = &input.request_parameters {
#[allow(unused_mut)]
let mut object_150 = object.key("requestParameters").start_object();
for (key_151, value_152) in var_149 {
{
object_150.key(key_151.as_str()).string(value_152.as_str());
}
}
object_150.finish();
}
if let Some(var_153) = &input.request_templates {
#[allow(unused_mut)]
let mut object_154 = object.key("requestTemplates").start_object();
for (key_155, value_156) in var_153 {
{
object_154.key(key_155.as_str()).string(value_156.as_str());
}
}
object_154.finish();
}
if let Some(var_157) = &input.timeout_in_millis {
object.key("timeoutInMillis").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_157).into()),
);
}
if let Some(var_158) = &input.tls_config {
#[allow(unused_mut)]
let mut object_159 = object.key("tlsConfig").start_object();
crate::json_ser::serialize_structure_crate_model_tls_config(&mut object_159, var_158)?;
object_159.finish();
}
if let Some(var_160) = &input.r#type {
object.key("type").string(var_160.as_str());
}
if let Some(var_161) = &input.uri {
object.key("uri").string(var_161.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_integration_response_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutIntegrationResponseInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_162) = &input.content_handling {
object.key("contentHandling").string(var_162.as_str());
}
if let Some(var_163) = &input.response_parameters {
#[allow(unused_mut)]
let mut object_164 = object.key("responseParameters").start_object();
for (key_165, value_166) in var_163 {
{
object_164.key(key_165.as_str()).string(value_166.as_str());
}
}
object_164.finish();
}
if let Some(var_167) = &input.response_templates {
#[allow(unused_mut)]
let mut object_168 = object.key("responseTemplates").start_object();
for (key_169, value_170) in var_167 {
{
object_168.key(key_169.as_str()).string(value_170.as_str());
}
}
object_168.finish();
}
if let Some(var_171) = &input.selection_pattern {
object.key("selectionPattern").string(var_171.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_method_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutMethodInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.api_key_required {
object.key("apiKeyRequired").boolean(input.api_key_required);
}
if let Some(var_172) = &input.authorization_scopes {
let mut array_173 = object.key("authorizationScopes").start_array();
for item_174 in var_172 {
{
array_173.value().string(item_174.as_str());
}
}
array_173.finish();
}
if let Some(var_175) = &input.authorization_type {
object.key("authorizationType").string(var_175.as_str());
}
if let Some(var_176) = &input.authorizer_id {
object.key("authorizerId").string(var_176.as_str());
}
if let Some(var_177) = &input.operation_name {
object.key("operationName").string(var_177.as_str());
}
if let Some(var_178) = &input.request_models {
#[allow(unused_mut)]
let mut object_179 = object.key("requestModels").start_object();
for (key_180, value_181) in var_178 {
{
object_179.key(key_180.as_str()).string(value_181.as_str());
}
}
object_179.finish();
}
if let Some(var_182) = &input.request_parameters {
#[allow(unused_mut)]
let mut object_183 = object.key("requestParameters").start_object();
for (key_184, value_185) in var_182 {
{
object_183.key(key_184.as_str()).boolean(*value_185);
}
}
object_183.finish();
}
if let Some(var_186) = &input.request_validator_id {
object.key("requestValidatorId").string(var_186.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_method_response_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutMethodResponseInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_187) = &input.response_models {
#[allow(unused_mut)]
let mut object_188 = object.key("responseModels").start_object();
for (key_189, value_190) in var_187 {
{
object_188.key(key_189.as_str()).string(value_190.as_str());
}
}
object_188.finish();
}
if let Some(var_191) = &input.response_parameters {
#[allow(unused_mut)]
let mut object_192 = object.key("responseParameters").start_object();
for (key_193, value_194) in var_191 {
{
object_192.key(key_193.as_str()).boolean(*value_194);
}
}
object_192.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_195) = &input.tags {
#[allow(unused_mut)]
let mut object_196 = object.key("tags").start_object();
for (key_197, value_198) in var_195 {
{
object_196.key(key_197.as_str()).string(value_198.as_str());
}
}
object_196.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_test_invoke_authorizer_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TestInvokeAuthorizerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_199) = &input.additional_context {
#[allow(unused_mut)]
let mut object_200 = object.key("additionalContext").start_object();
for (key_201, value_202) in var_199 {
{
object_200.key(key_201.as_str()).string(value_202.as_str());
}
}
object_200.finish();
}
if let Some(var_203) = &input.body {
object.key("body").string(var_203.as_str());
}
if let Some(var_204) = &input.headers {
#[allow(unused_mut)]
let mut object_205 = object.key("headers").start_object();
for (key_206, value_207) in var_204 {
{
object_205.key(key_206.as_str()).string(value_207.as_str());
}
}
object_205.finish();
}
if let Some(var_208) = &input.multi_value_headers {
#[allow(unused_mut)]
let mut object_209 = object.key("multiValueHeaders").start_object();
for (key_210, value_211) in var_208 {
{
let mut array_212 = object_209.key(key_210.as_str()).start_array();
for item_213 in value_211 {
{
array_212.value().string(item_213.as_str());
}
}
array_212.finish();
}
}
object_209.finish();
}
if let Some(var_214) = &input.path_with_query_string {
object.key("pathWithQueryString").string(var_214.as_str());
}
if let Some(var_215) = &input.stage_variables {
#[allow(unused_mut)]
let mut object_216 = object.key("stageVariables").start_object();
for (key_217, value_218) in var_215 {
{
object_216.key(key_217.as_str()).string(value_218.as_str());
}
}
object_216.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_test_invoke_method_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TestInvokeMethodInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_219) = &input.body {
object.key("body").string(var_219.as_str());
}
if let Some(var_220) = &input.client_certificate_id {
object.key("clientCertificateId").string(var_220.as_str());
}
if let Some(var_221) = &input.headers {
#[allow(unused_mut)]
let mut object_222 = object.key("headers").start_object();
for (key_223, value_224) in var_221 {
{
object_222.key(key_223.as_str()).string(value_224.as_str());
}
}
object_222.finish();
}
if let Some(var_225) = &input.multi_value_headers {
#[allow(unused_mut)]
let mut object_226 = object.key("multiValueHeaders").start_object();
for (key_227, value_228) in var_225 {
{
let mut array_229 = object_226.key(key_227.as_str()).start_array();
for item_230 in value_228 {
{
array_229.value().string(item_230.as_str());
}
}
array_229.finish();
}
}
object_226.finish();
}
if let Some(var_231) = &input.path_with_query_string {
object.key("pathWithQueryString").string(var_231.as_str());
}
if let Some(var_232) = &input.stage_variables {
#[allow(unused_mut)]
let mut object_233 = object.key("stageVariables").start_object();
for (key_234, value_235) in var_232 {
{
object_233.key(key_234.as_str()).string(value_235.as_str());
}
}
object_233.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_236) = &input.patch_operations {
let mut array_237 = object.key("patchOperations").start_array();
for item_238 in var_236 {
{
#[allow(unused_mut)]
let mut object_239 = array_237.value().start_object();
crate::json_ser::serialize_structure_crate_model_patch_operation(
&mut object_239,
item_238,
)?;
object_239.finish();
}
}
array_237.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_api_key_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateApiKeyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_240) = &input.patch_operations {
let mut array_241 = object.key("patchOperations").start_array();
for item_242 in var_240 {
{
#[allow(unused_mut)]
let mut object_243 = array_241.value().start_object();
crate::json_ser::serialize_structure_crate_model_patch_operation(
&mut object_243,
item_242,
)?;
object_243.finish();
}
}
array_241.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_authorizer_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAuthorizerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_244) = &input.patch_operations {
let mut array_245 = object.key("patchOperations").start_array();
for item_246 in var_244 {
{
#[allow(unused_mut)]
let mut object_247 = array_245.value().start_object();
crate::json_ser::serialize_structure_crate_model_patch_operation(
&mut object_247,
item_246,
)?;
object_247.finish();
}
}
array_245.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_base_path_mapping_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBasePathMappingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_248) = &input.patch_operations {
let mut array_249 = object.key("patchOperations").start_array();
for item_250 in var_248 {
{
#[allow(unused_mut)]
let mut object_251 = array_249.value().start_object();
crate::json_ser::serialize_structure_crate_model_patch_operation(
&mut object_251,
item_250,
)?;
object_251.finish();
}
}
array_249.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_client_certificate_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateClientCertificateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_252) = &input.patch_operations {
let mut array_253 = object.key("patchOperations").start_array();
for item_254 in var_252 {
{
#[allow(unused_mut)]
let mut object_255 = array_253.value().start_object();
crate::json_ser::serialize_structure_crate_model_patch_operation(
&mut object_255,
item_254,
)?;
object_255.finish();
}
}
array_253.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_deployment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDeploymentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_256) = &input.patch_operations {
let mut array_257 = object.key("patchOperations").start_array();
for item_258 in var_256 {
{
#[allow(unused_mut)]
let mut object_259 = array_257.value().start_object();
crate::json_ser::serialize_structure_crate_model_patch_operation(
&mut object_259,
item_258,
)?;
object_259.finish();
}
}
array_257.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_documentation_part_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDocumentationPartInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_260) = &input.patch_operations {
let mut array_261 = object.key("patchOperations").start_array();
for item_262 in var_260 {
{
#[allow(unused_mut)]
let mut object_263 = array_261.value().start_object();
crate::json_ser::serialize_structure_crate_model_patch_operation(
&mut object_263,
item_262,
)?;
object_263.finish();
}
}
array_261.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_documentation_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDocumentationVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_264) = &input.patch_operations {
let mut array_265 = object.key("patchOperations").start_array();
for item_266 in var_264 {
{
#[allow(unused_mut)]
let mut object_267 = array_265.value().start_object();
crate::json_ser::serialize_structure_crate_model_patch_operation(
&mut object_267,
item_266,
)?;
object_267.finish();
}
}
array_265.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_domain_name_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDomainNameInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_268) = &input.patch_operations {
let mut array_269 = object.key("patchOperations").start_array();
for item_270 in var_268 {
{
#[allow(unused_mut)]
let mut object_271 = array_269.value().start_object();
crate::json_ser::serialize_structure_crate_model_patch_operation(
&mut object_271,
item_270,
)?;
object_271.finish();
}
}
array_269.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_gateway_response_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGatewayResponseInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_272) = &input.patch_operations {
let mut array_273 = object.key("patchOperations").start_array();
for item_274 in var_272 {
{
#[allow(unused_mut)]
let mut object_275 = array_273.value().start_object();
crate::json_ser::serialize_structure_crate_model_patch_operation(
&mut object_275,
item_274,
)?;
object_275.finish();
}
}
array_273.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_integration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateIntegrationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_276) = &input.patch_operations {
let mut array_277 = object.key("patchOperations").start_array();
for item_278 in var_276 {
{
#[allow(unused_mut)]
let mut object_279 = array_277.value().start_object();
crate::json_ser::serialize_structure_crate_model_patch_operation(
&mut object_279,
item_278,
)?;
object_279.finish();
}
}
array_277.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_integration_response_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateIntegrationResponseInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_280) = &input.patch_operations {
let mut array_281 = object.key("patchOperations").start_array();
for item_282 in var_280 {
{
#[allow(unused_mut)]
let mut object_283 = array_281.value().start_object();
crate::json_ser::serialize_structure_crate_model_patch_operation(
&mut object_283,
item_282,
)?;
object_283.finish();
}
}
array_281.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_method_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateMethodInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_284) = &input.patch_operations {
let mut array_285 = object.key("patchOperations").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_patch_operation(
&mut object_287,
item_286,
)?;
object_287.finish();
}
}
array_285.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_method_response_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateMethodResponseInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_288) = &input.patch_operations {
let mut array_289 = object.key("patchOperations").start_array();
for item_290 in var_288 {
{
#[allow(unused_mut)]
let mut object_291 = array_289.value().start_object();
crate::json_ser::serialize_structure_crate_model_patch_operation(
&mut object_291,
item_290,
)?;
object_291.finish();
}
}
array_289.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_292) = &input.patch_operations {
let mut array_293 = object.key("patchOperations").start_array();
for item_294 in var_292 {
{
#[allow(unused_mut)]
let mut object_295 = array_293.value().start_object();
crate::json_ser::serialize_structure_crate_model_patch_operation(
&mut object_295,
item_294,
)?;
object_295.finish();
}
}
array_293.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_request_validator_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRequestValidatorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_296) = &input.patch_operations {
let mut array_297 = object.key("patchOperations").start_array();
for item_298 in var_296 {
{
#[allow(unused_mut)]
let mut object_299 = array_297.value().start_object();
crate::json_ser::serialize_structure_crate_model_patch_operation(
&mut object_299,
item_298,
)?;
object_299.finish();
}
}
array_297.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_300) = &input.patch_operations {
let mut array_301 = object.key("patchOperations").start_array();
for item_302 in var_300 {
{
#[allow(unused_mut)]
let mut object_303 = array_301.value().start_object();
crate::json_ser::serialize_structure_crate_model_patch_operation(
&mut object_303,
item_302,
)?;
object_303.finish();
}
}
array_301.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_rest_api_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRestApiInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_304) = &input.patch_operations {
let mut array_305 = object.key("patchOperations").start_array();
for item_306 in var_304 {
{
#[allow(unused_mut)]
let mut object_307 = array_305.value().start_object();
crate::json_ser::serialize_structure_crate_model_patch_operation(
&mut object_307,
item_306,
)?;
object_307.finish();
}
}
array_305.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_stage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateStageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_308) = &input.patch_operations {
let mut array_309 = object.key("patchOperations").start_array();
for item_310 in var_308 {
{
#[allow(unused_mut)]
let mut object_311 = array_309.value().start_object();
crate::json_ser::serialize_structure_crate_model_patch_operation(
&mut object_311,
item_310,
)?;
object_311.finish();
}
}
array_309.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_usage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateUsageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_312) = &input.patch_operations {
let mut array_313 = object.key("patchOperations").start_array();
for item_314 in var_312 {
{
#[allow(unused_mut)]
let mut object_315 = array_313.value().start_object();
crate::json_ser::serialize_structure_crate_model_patch_operation(
&mut object_315,
item_314,
)?;
object_315.finish();
}
}
array_313.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_usage_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateUsagePlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_316) = &input.patch_operations {
let mut array_317 = object.key("patchOperations").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_patch_operation(
&mut object_319,
item_318,
)?;
object_319.finish();
}
}
array_317.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_vpc_link_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateVpcLinkInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_320) = &input.patch_operations {
let mut array_321 = object.key("patchOperations").start_array();
for item_322 in var_320 {
{
#[allow(unused_mut)]
let mut object_323 = array_321.value().start_object();
crate::json_ser::serialize_structure_crate_model_patch_operation(
&mut object_323,
item_322,
)?;
object_323.finish();
}
}
array_321.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_stage_key(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StageKey,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_324) = &input.rest_api_id {
object.key("restApiId").string(var_324.as_str());
}
if let Some(var_325) = &input.stage_name {
object.key("stageName").string(var_325.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_deployment_canary_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeploymentCanarySettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.percent_traffic != 0.0 {
object.key("percentTraffic").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.percent_traffic).into()),
);
}
if let Some(var_326) = &input.stage_variable_overrides {
#[allow(unused_mut)]
let mut object_327 = object.key("stageVariableOverrides").start_object();
for (key_328, value_329) in var_326 {
{
object_327.key(key_328.as_str()).string(value_329.as_str());
}
}
object_327.finish();
}
if input.use_stage_cache {
object.key("useStageCache").boolean(input.use_stage_cache);
}
Ok(())
}
pub fn serialize_structure_crate_model_documentation_part_location(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DocumentationPartLocation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_330) = &input.r#type {
object.key("type").string(var_330.as_str());
}
if let Some(var_331) = &input.path {
object.key("path").string(var_331.as_str());
}
if let Some(var_332) = &input.method {
object.key("method").string(var_332.as_str());
}
if let Some(var_333) = &input.status_code {
object.key("statusCode").string(var_333.as_str());
}
if let Some(var_334) = &input.name {
object.key("name").string(var_334.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_endpoint_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EndpointConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_335) = &input.types {
let mut array_336 = object.key("types").start_array();
for item_337 in var_335 {
{
array_336.value().string(item_337.as_str());
}
}
array_336.finish();
}
if let Some(var_338) = &input.vpc_endpoint_ids {
let mut array_339 = object.key("vpcEndpointIds").start_array();
for item_340 in var_338 {
{
array_339.value().string(item_340.as_str());
}
}
array_339.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_mutual_tls_authentication_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MutualTlsAuthenticationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_341) = &input.truststore_uri {
object.key("truststoreUri").string(var_341.as_str());
}
if let Some(var_342) = &input.truststore_version {
object.key("truststoreVersion").string(var_342.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_canary_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CanarySettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.percent_traffic != 0.0 {
object.key("percentTraffic").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.percent_traffic).into()),
);
}
if let Some(var_343) = &input.deployment_id {
object.key("deploymentId").string(var_343.as_str());
}
if let Some(var_344) = &input.stage_variable_overrides {
#[allow(unused_mut)]
let mut object_345 = object.key("stageVariableOverrides").start_object();
for (key_346, value_347) in var_344 {
{
object_345.key(key_346.as_str()).string(value_347.as_str());
}
}
object_345.finish();
}
if input.use_stage_cache {
object.key("useStageCache").boolean(input.use_stage_cache);
}
Ok(())
}
pub fn serialize_structure_crate_model_api_stage(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ApiStage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_348) = &input.api_id {
object.key("apiId").string(var_348.as_str());
}
if let Some(var_349) = &input.stage {
object.key("stage").string(var_349.as_str());
}
if let Some(var_350) = &input.throttle {
#[allow(unused_mut)]
let mut object_351 = object.key("throttle").start_object();
for (key_352, value_353) in var_350 {
{
#[allow(unused_mut)]
let mut object_354 = object_351.key(key_352.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_throttle_settings(
&mut object_354,
value_353,
)?;
object_354.finish();
}
}
object_351.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_quota_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::QuotaSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.limit != 0 {
object.key("limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if input.offset != 0 {
object.key("offset").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.offset).into()),
);
}
if let Some(var_355) = &input.period {
object.key("period").string(var_355.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_throttle_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ThrottleSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.burst_limit != 0 {
object.key("burstLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.burst_limit).into()),
);
}
if input.rate_limit != 0.0 {
object.key("rateLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.rate_limit).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_tls_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TlsConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.insecure_skip_verification {
object
.key("insecureSkipVerification")
.boolean(input.insecure_skip_verification);
}
Ok(())
}
pub fn serialize_structure_crate_model_patch_operation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PatchOperation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_356) = &input.op {
object.key("op").string(var_356.as_str());
}
if let Some(var_357) = &input.path {
object.key("path").string(var_357.as_str());
}
if let Some(var_358) = &input.value {
object.key("value").string(var_358.as_str());
}
if let Some(var_359) = &input.from {
object.key("from").string(var_359.as_str());
}
Ok(())
}