pub fn serialize_structure_crate_input_add_layer_version_permission_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddLayerVersionPermissionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.action {
object.key("Action").string(var_1.as_str());
}
if let Some(var_2) = &input.organization_id {
object.key("OrganizationId").string(var_2.as_str());
}
if let Some(var_3) = &input.principal {
object.key("Principal").string(var_3.as_str());
}
if let Some(var_4) = &input.statement_id {
object.key("StatementId").string(var_4.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_add_permission_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddPermissionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_5) = &input.action {
object.key("Action").string(var_5.as_str());
}
if let Some(var_6) = &input.event_source_token {
object.key("EventSourceToken").string(var_6.as_str());
}
if let Some(var_7) = &input.function_url_auth_type {
object.key("FunctionUrlAuthType").string(var_7.as_str());
}
if let Some(var_8) = &input.principal {
object.key("Principal").string(var_8.as_str());
}
if let Some(var_9) = &input.principal_org_id {
object.key("PrincipalOrgID").string(var_9.as_str());
}
if let Some(var_10) = &input.revision_id {
object.key("RevisionId").string(var_10.as_str());
}
if let Some(var_11) = &input.source_account {
object.key("SourceAccount").string(var_11.as_str());
}
if let Some(var_12) = &input.source_arn {
object.key("SourceArn").string(var_12.as_str());
}
if let Some(var_13) = &input.statement_id {
object.key("StatementId").string(var_13.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_alias_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAliasInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.description {
object.key("Description").string(var_14.as_str());
}
if let Some(var_15) = &input.function_version {
object.key("FunctionVersion").string(var_15.as_str());
}
if let Some(var_16) = &input.name {
object.key("Name").string(var_16.as_str());
}
if let Some(var_17) = &input.routing_config {
#[allow(unused_mut)]
let mut object_18 = object.key("RoutingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_alias_routing_configuration(
&mut object_18,
var_17,
)?;
object_18.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_code_signing_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCodeSigningConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_19) = &input.allowed_publishers {
#[allow(unused_mut)]
let mut object_20 = object.key("AllowedPublishers").start_object();
crate::json_ser::serialize_structure_crate_model_allowed_publishers(
&mut object_20,
var_19,
)?;
object_20.finish();
}
if let Some(var_21) = &input.code_signing_policies {
#[allow(unused_mut)]
let mut object_22 = object.key("CodeSigningPolicies").start_object();
crate::json_ser::serialize_structure_crate_model_code_signing_policies(
&mut object_22,
var_21,
)?;
object_22.finish();
}
if let Some(var_23) = &input.description {
object.key("Description").string(var_23.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_event_source_mapping_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateEventSourceMappingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_24) = &input.amazon_managed_kafka_event_source_config {
#[allow(unused_mut)]
let mut object_25 = object
.key("AmazonManagedKafkaEventSourceConfig")
.start_object();
crate::json_ser::serialize_structure_crate_model_amazon_managed_kafka_event_source_config(
&mut object_25,
var_24,
)?;
object_25.finish();
}
if let Some(var_26) = &input.batch_size {
object.key("BatchSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_26).into()),
);
}
if let Some(var_27) = &input.bisect_batch_on_function_error {
object.key("BisectBatchOnFunctionError").boolean(*var_27);
}
if let Some(var_28) = &input.destination_config {
#[allow(unused_mut)]
let mut object_29 = object.key("DestinationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_destination_config(
&mut object_29,
var_28,
)?;
object_29.finish();
}
if let Some(var_30) = &input.enabled {
object.key("Enabled").boolean(*var_30);
}
if let Some(var_31) = &input.event_source_arn {
object.key("EventSourceArn").string(var_31.as_str());
}
if let Some(var_32) = &input.filter_criteria {
#[allow(unused_mut)]
let mut object_33 = object.key("FilterCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_filter_criteria(&mut object_33, var_32)?;
object_33.finish();
}
if let Some(var_34) = &input.function_name {
object.key("FunctionName").string(var_34.as_str());
}
if let Some(var_35) = &input.function_response_types {
let mut array_36 = object.key("FunctionResponseTypes").start_array();
for item_37 in var_35 {
{
array_36.value().string(item_37.as_str());
}
}
array_36.finish();
}
if let Some(var_38) = &input.maximum_batching_window_in_seconds {
object.key("MaximumBatchingWindowInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_38).into()),
);
}
if let Some(var_39) = &input.maximum_record_age_in_seconds {
object.key("MaximumRecordAgeInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_39).into()),
);
}
if let Some(var_40) = &input.maximum_retry_attempts {
object.key("MaximumRetryAttempts").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_40).into()),
);
}
if let Some(var_41) = &input.parallelization_factor {
object.key("ParallelizationFactor").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_41).into()),
);
}
if let Some(var_42) = &input.queues {
let mut array_43 = object.key("Queues").start_array();
for item_44 in var_42 {
{
array_43.value().string(item_44.as_str());
}
}
array_43.finish();
}
if let Some(var_45) = &input.scaling_config {
#[allow(unused_mut)]
let mut object_46 = object.key("ScalingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_scaling_config(&mut object_46, var_45)?;
object_46.finish();
}
if let Some(var_47) = &input.self_managed_event_source {
#[allow(unused_mut)]
let mut object_48 = object.key("SelfManagedEventSource").start_object();
crate::json_ser::serialize_structure_crate_model_self_managed_event_source(
&mut object_48,
var_47,
)?;
object_48.finish();
}
if let Some(var_49) = &input.self_managed_kafka_event_source_config {
#[allow(unused_mut)]
let mut object_50 = object
.key("SelfManagedKafkaEventSourceConfig")
.start_object();
crate::json_ser::serialize_structure_crate_model_self_managed_kafka_event_source_config(
&mut object_50,
var_49,
)?;
object_50.finish();
}
if let Some(var_51) = &input.source_access_configurations {
let mut array_52 = object.key("SourceAccessConfigurations").start_array();
for item_53 in var_51 {
{
#[allow(unused_mut)]
let mut object_54 = array_52.value().start_object();
crate::json_ser::serialize_structure_crate_model_source_access_configuration(
&mut object_54,
item_53,
)?;
object_54.finish();
}
}
array_52.finish();
}
if let Some(var_55) = &input.starting_position {
object.key("StartingPosition").string(var_55.as_str());
}
if let Some(var_56) = &input.starting_position_timestamp {
object
.key("StartingPositionTimestamp")
.date_time(var_56, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_57) = &input.topics {
let mut array_58 = object.key("Topics").start_array();
for item_59 in var_57 {
{
array_58.value().string(item_59.as_str());
}
}
array_58.finish();
}
if let Some(var_60) = &input.tumbling_window_in_seconds {
object.key("TumblingWindowInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_60).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_function_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFunctionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_61) = &input.architectures {
let mut array_62 = object.key("Architectures").start_array();
for item_63 in var_61 {
{
array_62.value().string(item_63.as_str());
}
}
array_62.finish();
}
if let Some(var_64) = &input.code {
#[allow(unused_mut)]
let mut object_65 = object.key("Code").start_object();
crate::json_ser::serialize_structure_crate_model_function_code(&mut object_65, var_64)?;
object_65.finish();
}
if let Some(var_66) = &input.code_signing_config_arn {
object.key("CodeSigningConfigArn").string(var_66.as_str());
}
if let Some(var_67) = &input.dead_letter_config {
#[allow(unused_mut)]
let mut object_68 = object.key("DeadLetterConfig").start_object();
crate::json_ser::serialize_structure_crate_model_dead_letter_config(
&mut object_68,
var_67,
)?;
object_68.finish();
}
if let Some(var_69) = &input.description {
object.key("Description").string(var_69.as_str());
}
if let Some(var_70) = &input.environment {
#[allow(unused_mut)]
let mut object_71 = object.key("Environment").start_object();
crate::json_ser::serialize_structure_crate_model_environment(&mut object_71, var_70)?;
object_71.finish();
}
if let Some(var_72) = &input.ephemeral_storage {
#[allow(unused_mut)]
let mut object_73 = object.key("EphemeralStorage").start_object();
crate::json_ser::serialize_structure_crate_model_ephemeral_storage(&mut object_73, var_72)?;
object_73.finish();
}
if let Some(var_74) = &input.file_system_configs {
let mut array_75 = object.key("FileSystemConfigs").start_array();
for item_76 in var_74 {
{
#[allow(unused_mut)]
let mut object_77 = array_75.value().start_object();
crate::json_ser::serialize_structure_crate_model_file_system_config(
&mut object_77,
item_76,
)?;
object_77.finish();
}
}
array_75.finish();
}
if let Some(var_78) = &input.function_name {
object.key("FunctionName").string(var_78.as_str());
}
if let Some(var_79) = &input.handler {
object.key("Handler").string(var_79.as_str());
}
if let Some(var_80) = &input.image_config {
#[allow(unused_mut)]
let mut object_81 = object.key("ImageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_image_config(&mut object_81, var_80)?;
object_81.finish();
}
if let Some(var_82) = &input.kms_key_arn {
object.key("KMSKeyArn").string(var_82.as_str());
}
if let Some(var_83) = &input.layers {
let mut array_84 = object.key("Layers").start_array();
for item_85 in var_83 {
{
array_84.value().string(item_85.as_str());
}
}
array_84.finish();
}
if let Some(var_86) = &input.memory_size {
object.key("MemorySize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_86).into()),
);
}
if let Some(var_87) = &input.package_type {
object.key("PackageType").string(var_87.as_str());
}
if input.publish {
object.key("Publish").boolean(input.publish);
}
if let Some(var_88) = &input.role {
object.key("Role").string(var_88.as_str());
}
if let Some(var_89) = &input.runtime {
object.key("Runtime").string(var_89.as_str());
}
if let Some(var_90) = &input.snap_start {
#[allow(unused_mut)]
let mut object_91 = object.key("SnapStart").start_object();
crate::json_ser::serialize_structure_crate_model_snap_start(&mut object_91, var_90)?;
object_91.finish();
}
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 let Some(var_96) = &input.timeout {
object.key("Timeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_96).into()),
);
}
if let Some(var_97) = &input.tracing_config {
#[allow(unused_mut)]
let mut object_98 = object.key("TracingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_tracing_config(&mut object_98, var_97)?;
object_98.finish();
}
if let Some(var_99) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_100 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_100, var_99)?;
object_100.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_function_url_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFunctionUrlConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.auth_type {
object.key("AuthType").string(var_101.as_str());
}
if let Some(var_102) = &input.cors {
#[allow(unused_mut)]
let mut object_103 = object.key("Cors").start_object();
crate::json_ser::serialize_structure_crate_model_cors(&mut object_103, var_102)?;
object_103.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_publish_layer_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PublishLayerVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_104) = &input.compatible_architectures {
let mut array_105 = object.key("CompatibleArchitectures").start_array();
for item_106 in var_104 {
{
array_105.value().string(item_106.as_str());
}
}
array_105.finish();
}
if let Some(var_107) = &input.compatible_runtimes {
let mut array_108 = object.key("CompatibleRuntimes").start_array();
for item_109 in var_107 {
{
array_108.value().string(item_109.as_str());
}
}
array_108.finish();
}
if let Some(var_110) = &input.content {
#[allow(unused_mut)]
let mut object_111 = object.key("Content").start_object();
crate::json_ser::serialize_structure_crate_model_layer_version_content_input(
&mut object_111,
var_110,
)?;
object_111.finish();
}
if let Some(var_112) = &input.description {
object.key("Description").string(var_112.as_str());
}
if let Some(var_113) = &input.license_info {
object.key("LicenseInfo").string(var_113.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_publish_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PublishVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_114) = &input.code_sha256 {
object.key("CodeSha256").string(var_114.as_str());
}
if let Some(var_115) = &input.description {
object.key("Description").string(var_115.as_str());
}
if let Some(var_116) = &input.revision_id {
object.key("RevisionId").string(var_116.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_function_code_signing_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutFunctionCodeSigningConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_117) = &input.code_signing_config_arn {
object.key("CodeSigningConfigArn").string(var_117.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_function_concurrency_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutFunctionConcurrencyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_118) = &input.reserved_concurrent_executions {
object.key("ReservedConcurrentExecutions").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_118).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_function_event_invoke_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutFunctionEventInvokeConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_119) = &input.destination_config {
#[allow(unused_mut)]
let mut object_120 = object.key("DestinationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_destination_config(
&mut object_120,
var_119,
)?;
object_120.finish();
}
if let Some(var_121) = &input.maximum_event_age_in_seconds {
object.key("MaximumEventAgeInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_121).into()),
);
}
if let Some(var_122) = &input.maximum_retry_attempts {
object.key("MaximumRetryAttempts").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_122).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_provisioned_concurrency_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutProvisionedConcurrencyConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_123) = &input.provisioned_concurrent_executions {
object.key("ProvisionedConcurrentExecutions").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_123).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_runtime_management_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutRuntimeManagementConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_124) = &input.runtime_version_arn {
object.key("RuntimeVersionArn").string(var_124.as_str());
}
if let Some(var_125) = &input.update_runtime_on {
object.key("UpdateRuntimeOn").string(var_125.as_str());
}
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_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_update_alias_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAliasInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_130) = &input.description {
object.key("Description").string(var_130.as_str());
}
if let Some(var_131) = &input.function_version {
object.key("FunctionVersion").string(var_131.as_str());
}
if let Some(var_132) = &input.revision_id {
object.key("RevisionId").string(var_132.as_str());
}
if let Some(var_133) = &input.routing_config {
#[allow(unused_mut)]
let mut object_134 = object.key("RoutingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_alias_routing_configuration(
&mut object_134,
var_133,
)?;
object_134.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_code_signing_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateCodeSigningConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_135) = &input.allowed_publishers {
#[allow(unused_mut)]
let mut object_136 = object.key("AllowedPublishers").start_object();
crate::json_ser::serialize_structure_crate_model_allowed_publishers(
&mut object_136,
var_135,
)?;
object_136.finish();
}
if let Some(var_137) = &input.code_signing_policies {
#[allow(unused_mut)]
let mut object_138 = object.key("CodeSigningPolicies").start_object();
crate::json_ser::serialize_structure_crate_model_code_signing_policies(
&mut object_138,
var_137,
)?;
object_138.finish();
}
if let Some(var_139) = &input.description {
object.key("Description").string(var_139.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_event_source_mapping_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateEventSourceMappingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_140) = &input.batch_size {
object.key("BatchSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_140).into()),
);
}
if let Some(var_141) = &input.bisect_batch_on_function_error {
object.key("BisectBatchOnFunctionError").boolean(*var_141);
}
if let Some(var_142) = &input.destination_config {
#[allow(unused_mut)]
let mut object_143 = object.key("DestinationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_destination_config(
&mut object_143,
var_142,
)?;
object_143.finish();
}
if let Some(var_144) = &input.enabled {
object.key("Enabled").boolean(*var_144);
}
if let Some(var_145) = &input.filter_criteria {
#[allow(unused_mut)]
let mut object_146 = object.key("FilterCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_filter_criteria(&mut object_146, var_145)?;
object_146.finish();
}
if let Some(var_147) = &input.function_name {
object.key("FunctionName").string(var_147.as_str());
}
if let Some(var_148) = &input.function_response_types {
let mut array_149 = object.key("FunctionResponseTypes").start_array();
for item_150 in var_148 {
{
array_149.value().string(item_150.as_str());
}
}
array_149.finish();
}
if let Some(var_151) = &input.maximum_batching_window_in_seconds {
object.key("MaximumBatchingWindowInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_151).into()),
);
}
if let Some(var_152) = &input.maximum_record_age_in_seconds {
object.key("MaximumRecordAgeInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_152).into()),
);
}
if let Some(var_153) = &input.maximum_retry_attempts {
object.key("MaximumRetryAttempts").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_153).into()),
);
}
if let Some(var_154) = &input.parallelization_factor {
object.key("ParallelizationFactor").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_154).into()),
);
}
if let Some(var_155) = &input.scaling_config {
#[allow(unused_mut)]
let mut object_156 = object.key("ScalingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_scaling_config(&mut object_156, var_155)?;
object_156.finish();
}
if let Some(var_157) = &input.source_access_configurations {
let mut array_158 = object.key("SourceAccessConfigurations").start_array();
for item_159 in var_157 {
{
#[allow(unused_mut)]
let mut object_160 = array_158.value().start_object();
crate::json_ser::serialize_structure_crate_model_source_access_configuration(
&mut object_160,
item_159,
)?;
object_160.finish();
}
}
array_158.finish();
}
if let Some(var_161) = &input.tumbling_window_in_seconds {
object.key("TumblingWindowInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_161).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_function_code_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFunctionCodeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_162) = &input.architectures {
let mut array_163 = object.key("Architectures").start_array();
for item_164 in var_162 {
{
array_163.value().string(item_164.as_str());
}
}
array_163.finish();
}
if input.dry_run {
object.key("DryRun").boolean(input.dry_run);
}
if let Some(var_165) = &input.image_uri {
object.key("ImageUri").string(var_165.as_str());
}
if input.publish {
object.key("Publish").boolean(input.publish);
}
if let Some(var_166) = &input.revision_id {
object.key("RevisionId").string(var_166.as_str());
}
if let Some(var_167) = &input.s3_bucket {
object.key("S3Bucket").string(var_167.as_str());
}
if let Some(var_168) = &input.s3_key {
object.key("S3Key").string(var_168.as_str());
}
if let Some(var_169) = &input.s3_object_version {
object.key("S3ObjectVersion").string(var_169.as_str());
}
if let Some(var_170) = &input.zip_file {
object
.key("ZipFile")
.string_unchecked(&aws_smithy_types::base64::encode(var_170));
}
Ok(())
}
pub fn serialize_structure_crate_input_update_function_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFunctionConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_171) = &input.dead_letter_config {
#[allow(unused_mut)]
let mut object_172 = object.key("DeadLetterConfig").start_object();
crate::json_ser::serialize_structure_crate_model_dead_letter_config(
&mut object_172,
var_171,
)?;
object_172.finish();
}
if let Some(var_173) = &input.description {
object.key("Description").string(var_173.as_str());
}
if let Some(var_174) = &input.environment {
#[allow(unused_mut)]
let mut object_175 = object.key("Environment").start_object();
crate::json_ser::serialize_structure_crate_model_environment(&mut object_175, var_174)?;
object_175.finish();
}
if let Some(var_176) = &input.ephemeral_storage {
#[allow(unused_mut)]
let mut object_177 = object.key("EphemeralStorage").start_object();
crate::json_ser::serialize_structure_crate_model_ephemeral_storage(
&mut object_177,
var_176,
)?;
object_177.finish();
}
if let Some(var_178) = &input.file_system_configs {
let mut array_179 = object.key("FileSystemConfigs").start_array();
for item_180 in var_178 {
{
#[allow(unused_mut)]
let mut object_181 = array_179.value().start_object();
crate::json_ser::serialize_structure_crate_model_file_system_config(
&mut object_181,
item_180,
)?;
object_181.finish();
}
}
array_179.finish();
}
if let Some(var_182) = &input.handler {
object.key("Handler").string(var_182.as_str());
}
if let Some(var_183) = &input.image_config {
#[allow(unused_mut)]
let mut object_184 = object.key("ImageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_image_config(&mut object_184, var_183)?;
object_184.finish();
}
if let Some(var_185) = &input.kms_key_arn {
object.key("KMSKeyArn").string(var_185.as_str());
}
if let Some(var_186) = &input.layers {
let mut array_187 = object.key("Layers").start_array();
for item_188 in var_186 {
{
array_187.value().string(item_188.as_str());
}
}
array_187.finish();
}
if let Some(var_189) = &input.memory_size {
object.key("MemorySize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_189).into()),
);
}
if let Some(var_190) = &input.revision_id {
object.key("RevisionId").string(var_190.as_str());
}
if let Some(var_191) = &input.role {
object.key("Role").string(var_191.as_str());
}
if let Some(var_192) = &input.runtime {
object.key("Runtime").string(var_192.as_str());
}
if let Some(var_193) = &input.snap_start {
#[allow(unused_mut)]
let mut object_194 = object.key("SnapStart").start_object();
crate::json_ser::serialize_structure_crate_model_snap_start(&mut object_194, var_193)?;
object_194.finish();
}
if let Some(var_195) = &input.timeout {
object.key("Timeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_195).into()),
);
}
if let Some(var_196) = &input.tracing_config {
#[allow(unused_mut)]
let mut object_197 = object.key("TracingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_tracing_config(&mut object_197, var_196)?;
object_197.finish();
}
if let Some(var_198) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_199 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_199, var_198)?;
object_199.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_function_event_invoke_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFunctionEventInvokeConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_200) = &input.destination_config {
#[allow(unused_mut)]
let mut object_201 = object.key("DestinationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_destination_config(
&mut object_201,
var_200,
)?;
object_201.finish();
}
if let Some(var_202) = &input.maximum_event_age_in_seconds {
object.key("MaximumEventAgeInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_202).into()),
);
}
if let Some(var_203) = &input.maximum_retry_attempts {
object.key("MaximumRetryAttempts").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_203).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_function_url_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFunctionUrlConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_204) = &input.auth_type {
object.key("AuthType").string(var_204.as_str());
}
if let Some(var_205) = &input.cors {
#[allow(unused_mut)]
let mut object_206 = object.key("Cors").start_object();
crate::json_ser::serialize_structure_crate_model_cors(&mut object_206, var_205)?;
object_206.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_alias_routing_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AliasRoutingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_207) = &input.additional_version_weights {
#[allow(unused_mut)]
let mut object_208 = object.key("AdditionalVersionWeights").start_object();
for (key_209, value_210) in var_207 {
{
object_208.key(key_209.as_str()).number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*value_210).into()),
);
}
}
object_208.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_allowed_publishers(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AllowedPublishers,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_211) = &input.signing_profile_version_arns {
let mut array_212 = object.key("SigningProfileVersionArns").start_array();
for item_213 in var_211 {
{
array_212.value().string(item_213.as_str());
}
}
array_212.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_code_signing_policies(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CodeSigningPolicies,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_214) = &input.untrusted_artifact_on_deployment {
object
.key("UntrustedArtifactOnDeployment")
.string(var_214.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_amazon_managed_kafka_event_source_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AmazonManagedKafkaEventSourceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_215) = &input.consumer_group_id {
object.key("ConsumerGroupId").string(var_215.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_destination_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DestinationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_216) = &input.on_success {
#[allow(unused_mut)]
let mut object_217 = object.key("OnSuccess").start_object();
crate::json_ser::serialize_structure_crate_model_on_success(&mut object_217, var_216)?;
object_217.finish();
}
if let Some(var_218) = &input.on_failure {
#[allow(unused_mut)]
let mut object_219 = object.key("OnFailure").start_object();
crate::json_ser::serialize_structure_crate_model_on_failure(&mut object_219, var_218)?;
object_219.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_220) = &input.filters {
let mut array_221 = object.key("Filters").start_array();
for item_222 in var_220 {
{
#[allow(unused_mut)]
let mut object_223 = array_221.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_223, item_222)?;
object_223.finish();
}
}
array_221.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_scaling_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScalingConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_224) = &input.maximum_concurrency {
object.key("MaximumConcurrency").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_224).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_self_managed_event_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SelfManagedEventSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_225) = &input.endpoints {
#[allow(unused_mut)]
let mut object_226 = object.key("Endpoints").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();
}
Ok(())
}
pub fn serialize_structure_crate_model_self_managed_kafka_event_source_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SelfManagedKafkaEventSourceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_231) = &input.consumer_group_id {
object.key("ConsumerGroupId").string(var_231.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_source_access_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SourceAccessConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_232) = &input.r#type {
object.key("Type").string(var_232.as_str());
}
if let Some(var_233) = &input.uri {
object.key("URI").string(var_233.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_function_code(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FunctionCode,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_234) = &input.zip_file {
object
.key("ZipFile")
.string_unchecked(&aws_smithy_types::base64::encode(var_234));
}
if let Some(var_235) = &input.s3_bucket {
object.key("S3Bucket").string(var_235.as_str());
}
if let Some(var_236) = &input.s3_key {
object.key("S3Key").string(var_236.as_str());
}
if let Some(var_237) = &input.s3_object_version {
object.key("S3ObjectVersion").string(var_237.as_str());
}
if let Some(var_238) = &input.image_uri {
object.key("ImageUri").string(var_238.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_dead_letter_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeadLetterConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_239) = &input.target_arn {
object.key("TargetArn").string(var_239.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_environment(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Environment,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_240) = &input.variables {
#[allow(unused_mut)]
let mut object_241 = object.key("Variables").start_object();
for (key_242, value_243) in var_240 {
{
object_241.key(key_242.as_str()).string(value_243.as_str());
}
}
object_241.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_ephemeral_storage(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EphemeralStorage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_244) = &input.size {
object.key("Size").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_244).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_file_system_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FileSystemConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_245) = &input.arn {
object.key("Arn").string(var_245.as_str());
}
if let Some(var_246) = &input.local_mount_path {
object.key("LocalMountPath").string(var_246.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_image_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImageConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_247) = &input.entry_point {
let mut array_248 = object.key("EntryPoint").start_array();
for item_249 in var_247 {
{
array_248.value().string(item_249.as_str());
}
}
array_248.finish();
}
if let Some(var_250) = &input.command {
let mut array_251 = object.key("Command").start_array();
for item_252 in var_250 {
{
array_251.value().string(item_252.as_str());
}
}
array_251.finish();
}
if let Some(var_253) = &input.working_directory {
object.key("WorkingDirectory").string(var_253.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_snap_start(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SnapStart,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_254) = &input.apply_on {
object.key("ApplyOn").string(var_254.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tracing_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TracingConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_255) = &input.mode {
object.key("Mode").string(var_255.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_vpc_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VpcConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_256) = &input.subnet_ids {
let mut array_257 = object.key("SubnetIds").start_array();
for item_258 in var_256 {
{
array_257.value().string(item_258.as_str());
}
}
array_257.finish();
}
if let Some(var_259) = &input.security_group_ids {
let mut array_260 = object.key("SecurityGroupIds").start_array();
for item_261 in var_259 {
{
array_260.value().string(item_261.as_str());
}
}
array_260.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_cors(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Cors,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_262) = &input.allow_credentials {
object.key("AllowCredentials").boolean(*var_262);
}
if let Some(var_263) = &input.allow_headers {
let mut array_264 = object.key("AllowHeaders").start_array();
for item_265 in var_263 {
{
array_264.value().string(item_265.as_str());
}
}
array_264.finish();
}
if let Some(var_266) = &input.allow_methods {
let mut array_267 = object.key("AllowMethods").start_array();
for item_268 in var_266 {
{
array_267.value().string(item_268.as_str());
}
}
array_267.finish();
}
if let Some(var_269) = &input.allow_origins {
let mut array_270 = object.key("AllowOrigins").start_array();
for item_271 in var_269 {
{
array_270.value().string(item_271.as_str());
}
}
array_270.finish();
}
if let Some(var_272) = &input.expose_headers {
let mut array_273 = object.key("ExposeHeaders").start_array();
for item_274 in var_272 {
{
array_273.value().string(item_274.as_str());
}
}
array_273.finish();
}
if let Some(var_275) = &input.max_age {
object.key("MaxAge").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_275).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_layer_version_content_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LayerVersionContentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_276) = &input.s3_bucket {
object.key("S3Bucket").string(var_276.as_str());
}
if let Some(var_277) = &input.s3_key {
object.key("S3Key").string(var_277.as_str());
}
if let Some(var_278) = &input.s3_object_version {
object.key("S3ObjectVersion").string(var_278.as_str());
}
if let Some(var_279) = &input.zip_file {
object
.key("ZipFile")
.string_unchecked(&aws_smithy_types::base64::encode(var_279));
}
Ok(())
}
pub fn serialize_structure_crate_model_on_success(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OnSuccess,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_280) = &input.destination {
object.key("Destination").string(var_280.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_on_failure(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OnFailure,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_281) = &input.destination {
object.key("Destination").string(var_281.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Filter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_282) = &input.pattern {
object.key("Pattern").string(var_282.as_str());
}
Ok(())
}