pub fn serialize_structure_crate_input_add_association_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddAssociationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.source_arn {
object.key("SourceArn").string(var_1.as_str());
}
if let Some(var_2) = &input.destination_arn {
object.key("DestinationArn").string(var_2.as_str());
}
if let Some(var_3) = &input.association_type {
object.key("AssociationType").string(var_3.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_add_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_4) = &input.resource_arn {
object.key("ResourceArn").string(var_4.as_str());
}
if let Some(var_5) = &input.tags {
let mut array_6 = object.key("Tags").start_array();
for item_7 in var_5 {
{
#[allow(unused_mut)]
let mut object_8 = array_6.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_8, item_7)?;
object_8.finish();
}
}
array_6.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_trial_component_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateTrialComponentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_9) = &input.trial_component_name {
object.key("TrialComponentName").string(var_9.as_str());
}
if let Some(var_10) = &input.trial_name {
object.key("TrialName").string(var_10.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_describe_model_package_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDescribeModelPackageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_11) = &input.model_package_arn_list {
let mut array_12 = object.key("ModelPackageArnList").start_array();
for item_13 in var_11 {
{
array_12.value().string(item_13.as_str());
}
}
array_12.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_action_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateActionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.action_name {
object.key("ActionName").string(var_14.as_str());
}
if let Some(var_15) = &input.source {
#[allow(unused_mut)]
let mut object_16 = object.key("Source").start_object();
crate::json_ser::serialize_structure_crate_model_action_source(&mut object_16, var_15)?;
object_16.finish();
}
if let Some(var_17) = &input.action_type {
object.key("ActionType").string(var_17.as_str());
}
if let Some(var_18) = &input.description {
object.key("Description").string(var_18.as_str());
}
if let Some(var_19) = &input.status {
object.key("Status").string(var_19.as_str());
}
if let Some(var_20) = &input.properties {
#[allow(unused_mut)]
let mut object_21 = object.key("Properties").start_object();
for (key_22, value_23) in var_20 {
{
object_21.key(key_22.as_str()).string(value_23.as_str());
}
}
object_21.finish();
}
if let Some(var_24) = &input.metadata_properties {
#[allow(unused_mut)]
let mut object_25 = object.key("MetadataProperties").start_object();
crate::json_ser::serialize_structure_crate_model_metadata_properties(
&mut object_25,
var_24,
)?;
object_25.finish();
}
if let Some(var_26) = &input.tags {
let mut array_27 = object.key("Tags").start_array();
for item_28 in var_26 {
{
#[allow(unused_mut)]
let mut object_29 = array_27.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_29, item_28)?;
object_29.finish();
}
}
array_27.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_algorithm_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAlgorithmInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_30) = &input.algorithm_name {
object.key("AlgorithmName").string(var_30.as_str());
}
if let Some(var_31) = &input.algorithm_description {
object.key("AlgorithmDescription").string(var_31.as_str());
}
if let Some(var_32) = &input.training_specification {
#[allow(unused_mut)]
let mut object_33 = object.key("TrainingSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_training_specification(
&mut object_33,
var_32,
)?;
object_33.finish();
}
if let Some(var_34) = &input.inference_specification {
#[allow(unused_mut)]
let mut object_35 = object.key("InferenceSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_inference_specification(
&mut object_35,
var_34,
)?;
object_35.finish();
}
if let Some(var_36) = &input.validation_specification {
#[allow(unused_mut)]
let mut object_37 = object.key("ValidationSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_algorithm_validation_specification(
&mut object_37,
var_36,
)?;
object_37.finish();
}
if input.certify_for_marketplace {
object
.key("CertifyForMarketplace")
.boolean(input.certify_for_marketplace);
}
if let Some(var_38) = &input.tags {
let mut array_39 = object.key("Tags").start_array();
for item_40 in var_38 {
{
#[allow(unused_mut)]
let mut object_41 = array_39.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_41, item_40)?;
object_41.finish();
}
}
array_39.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_app_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAppInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_42) = &input.domain_id {
object.key("DomainId").string(var_42.as_str());
}
if let Some(var_43) = &input.user_profile_name {
object.key("UserProfileName").string(var_43.as_str());
}
if let Some(var_44) = &input.app_type {
object.key("AppType").string(var_44.as_str());
}
if let Some(var_45) = &input.app_name {
object.key("AppName").string(var_45.as_str());
}
if let Some(var_46) = &input.tags {
let mut array_47 = object.key("Tags").start_array();
for item_48 in var_46 {
{
#[allow(unused_mut)]
let mut object_49 = array_47.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_49, item_48)?;
object_49.finish();
}
}
array_47.finish();
}
if let Some(var_50) = &input.resource_spec {
#[allow(unused_mut)]
let mut object_51 = object.key("ResourceSpec").start_object();
crate::json_ser::serialize_structure_crate_model_resource_spec(&mut object_51, var_50)?;
object_51.finish();
}
if let Some(var_52) = &input.space_name {
object.key("SpaceName").string(var_52.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_app_image_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAppImageConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_53) = &input.app_image_config_name {
object.key("AppImageConfigName").string(var_53.as_str());
}
if let Some(var_54) = &input.tags {
let mut array_55 = object.key("Tags").start_array();
for item_56 in var_54 {
{
#[allow(unused_mut)]
let mut object_57 = array_55.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_57, item_56)?;
object_57.finish();
}
}
array_55.finish();
}
if let Some(var_58) = &input.kernel_gateway_image_config {
#[allow(unused_mut)]
let mut object_59 = object.key("KernelGatewayImageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_kernel_gateway_image_config(
&mut object_59,
var_58,
)?;
object_59.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_artifact_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateArtifactInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_60) = &input.artifact_name {
object.key("ArtifactName").string(var_60.as_str());
}
if let Some(var_61) = &input.source {
#[allow(unused_mut)]
let mut object_62 = object.key("Source").start_object();
crate::json_ser::serialize_structure_crate_model_artifact_source(&mut object_62, var_61)?;
object_62.finish();
}
if let Some(var_63) = &input.artifact_type {
object.key("ArtifactType").string(var_63.as_str());
}
if let Some(var_64) = &input.properties {
#[allow(unused_mut)]
let mut object_65 = object.key("Properties").start_object();
for (key_66, value_67) in var_64 {
{
object_65.key(key_66.as_str()).string(value_67.as_str());
}
}
object_65.finish();
}
if let Some(var_68) = &input.metadata_properties {
#[allow(unused_mut)]
let mut object_69 = object.key("MetadataProperties").start_object();
crate::json_ser::serialize_structure_crate_model_metadata_properties(
&mut object_69,
var_68,
)?;
object_69.finish();
}
if let Some(var_70) = &input.tags {
let mut array_71 = object.key("Tags").start_array();
for item_72 in var_70 {
{
#[allow(unused_mut)]
let mut object_73 = array_71.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_73, item_72)?;
object_73.finish();
}
}
array_71.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_auto_ml_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAutoMlJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_74) = &input.auto_ml_job_name {
object.key("AutoMLJobName").string(var_74.as_str());
}
if let Some(var_75) = &input.input_data_config {
let mut array_76 = object.key("InputDataConfig").start_array();
for item_77 in var_75 {
{
#[allow(unused_mut)]
let mut object_78 = array_76.value().start_object();
crate::json_ser::serialize_structure_crate_model_auto_ml_channel(
&mut object_78,
item_77,
)?;
object_78.finish();
}
}
array_76.finish();
}
if let Some(var_79) = &input.output_data_config {
#[allow(unused_mut)]
let mut object_80 = object.key("OutputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_auto_ml_output_data_config(
&mut object_80,
var_79,
)?;
object_80.finish();
}
if let Some(var_81) = &input.problem_type {
object.key("ProblemType").string(var_81.as_str());
}
if let Some(var_82) = &input.auto_ml_job_objective {
#[allow(unused_mut)]
let mut object_83 = object.key("AutoMLJobObjective").start_object();
crate::json_ser::serialize_structure_crate_model_auto_ml_job_objective(
&mut object_83,
var_82,
)?;
object_83.finish();
}
if let Some(var_84) = &input.auto_ml_job_config {
#[allow(unused_mut)]
let mut object_85 = object.key("AutoMLJobConfig").start_object();
crate::json_ser::serialize_structure_crate_model_auto_ml_job_config(
&mut object_85,
var_84,
)?;
object_85.finish();
}
if let Some(var_86) = &input.role_arn {
object.key("RoleArn").string(var_86.as_str());
}
if input.generate_candidate_definitions_only {
object
.key("GenerateCandidateDefinitionsOnly")
.boolean(input.generate_candidate_definitions_only);
}
if let Some(var_87) = &input.tags {
let mut array_88 = object.key("Tags").start_array();
for item_89 in var_87 {
{
#[allow(unused_mut)]
let mut object_90 = array_88.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_90, item_89)?;
object_90.finish();
}
}
array_88.finish();
}
if let Some(var_91) = &input.model_deploy_config {
#[allow(unused_mut)]
let mut object_92 = object.key("ModelDeployConfig").start_object();
crate::json_ser::serialize_structure_crate_model_model_deploy_config(
&mut object_92,
var_91,
)?;
object_92.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_code_repository_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCodeRepositoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.code_repository_name {
object.key("CodeRepositoryName").string(var_93.as_str());
}
if let Some(var_94) = &input.git_config {
#[allow(unused_mut)]
let mut object_95 = object.key("GitConfig").start_object();
crate::json_ser::serialize_structure_crate_model_git_config(&mut object_95, var_94)?;
object_95.finish();
}
if let Some(var_96) = &input.tags {
let mut array_97 = object.key("Tags").start_array();
for item_98 in var_96 {
{
#[allow(unused_mut)]
let mut object_99 = array_97.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_99, item_98)?;
object_99.finish();
}
}
array_97.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_compilation_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCompilationJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_100) = &input.compilation_job_name {
object.key("CompilationJobName").string(var_100.as_str());
}
if let Some(var_101) = &input.role_arn {
object.key("RoleArn").string(var_101.as_str());
}
if let Some(var_102) = &input.model_package_version_arn {
object
.key("ModelPackageVersionArn")
.string(var_102.as_str());
}
if let Some(var_103) = &input.input_config {
#[allow(unused_mut)]
let mut object_104 = object.key("InputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_input_config(&mut object_104, var_103)?;
object_104.finish();
}
if let Some(var_105) = &input.output_config {
#[allow(unused_mut)]
let mut object_106 = object.key("OutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_output_config(&mut object_106, var_105)?;
object_106.finish();
}
if let Some(var_107) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_108 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_neo_vpc_config(&mut object_108, var_107)?;
object_108.finish();
}
if let Some(var_109) = &input.stopping_condition {
#[allow(unused_mut)]
let mut object_110 = object.key("StoppingCondition").start_object();
crate::json_ser::serialize_structure_crate_model_stopping_condition(
&mut object_110,
var_109,
)?;
object_110.finish();
}
if let Some(var_111) = &input.tags {
let mut array_112 = object.key("Tags").start_array();
for item_113 in var_111 {
{
#[allow(unused_mut)]
let mut object_114 = array_112.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_114, item_113)?;
object_114.finish();
}
}
array_112.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_context_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateContextInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_115) = &input.context_name {
object.key("ContextName").string(var_115.as_str());
}
if let Some(var_116) = &input.source {
#[allow(unused_mut)]
let mut object_117 = object.key("Source").start_object();
crate::json_ser::serialize_structure_crate_model_context_source(&mut object_117, var_116)?;
object_117.finish();
}
if let Some(var_118) = &input.context_type {
object.key("ContextType").string(var_118.as_str());
}
if let Some(var_119) = &input.description {
object.key("Description").string(var_119.as_str());
}
if let Some(var_120) = &input.properties {
#[allow(unused_mut)]
let mut object_121 = object.key("Properties").start_object();
for (key_122, value_123) in var_120 {
{
object_121.key(key_122.as_str()).string(value_123.as_str());
}
}
object_121.finish();
}
if let Some(var_124) = &input.tags {
let mut array_125 = object.key("Tags").start_array();
for item_126 in var_124 {
{
#[allow(unused_mut)]
let mut object_127 = array_125.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_127, item_126)?;
object_127.finish();
}
}
array_125.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_data_quality_job_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDataQualityJobDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_128) = &input.job_definition_name {
object.key("JobDefinitionName").string(var_128.as_str());
}
if let Some(var_129) = &input.data_quality_baseline_config {
#[allow(unused_mut)]
let mut object_130 = object.key("DataQualityBaselineConfig").start_object();
crate::json_ser::serialize_structure_crate_model_data_quality_baseline_config(
&mut object_130,
var_129,
)?;
object_130.finish();
}
if let Some(var_131) = &input.data_quality_app_specification {
#[allow(unused_mut)]
let mut object_132 = object.key("DataQualityAppSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_data_quality_app_specification(
&mut object_132,
var_131,
)?;
object_132.finish();
}
if let Some(var_133) = &input.data_quality_job_input {
#[allow(unused_mut)]
let mut object_134 = object.key("DataQualityJobInput").start_object();
crate::json_ser::serialize_structure_crate_model_data_quality_job_input(
&mut object_134,
var_133,
)?;
object_134.finish();
}
if let Some(var_135) = &input.data_quality_job_output_config {
#[allow(unused_mut)]
let mut object_136 = object.key("DataQualityJobOutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_output_config(
&mut object_136,
var_135,
)?;
object_136.finish();
}
if let Some(var_137) = &input.job_resources {
#[allow(unused_mut)]
let mut object_138 = object.key("JobResources").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_resources(
&mut object_138,
var_137,
)?;
object_138.finish();
}
if let Some(var_139) = &input.network_config {
#[allow(unused_mut)]
let mut object_140 = object.key("NetworkConfig").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_network_config(
&mut object_140,
var_139,
)?;
object_140.finish();
}
if let Some(var_141) = &input.role_arn {
object.key("RoleArn").string(var_141.as_str());
}
if let Some(var_142) = &input.stopping_condition {
#[allow(unused_mut)]
let mut object_143 = object.key("StoppingCondition").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_stopping_condition(
&mut object_143,
var_142,
)?;
object_143.finish();
}
if let Some(var_144) = &input.tags {
let mut array_145 = object.key("Tags").start_array();
for item_146 in var_144 {
{
#[allow(unused_mut)]
let mut object_147 = array_145.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_147, item_146)?;
object_147.finish();
}
}
array_145.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_device_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDeviceFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_148) = &input.device_fleet_name {
object.key("DeviceFleetName").string(var_148.as_str());
}
if let Some(var_149) = &input.role_arn {
object.key("RoleArn").string(var_149.as_str());
}
if let Some(var_150) = &input.description {
object.key("Description").string(var_150.as_str());
}
if let Some(var_151) = &input.output_config {
#[allow(unused_mut)]
let mut object_152 = object.key("OutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_edge_output_config(
&mut object_152,
var_151,
)?;
object_152.finish();
}
if let Some(var_153) = &input.tags {
let mut array_154 = object.key("Tags").start_array();
for item_155 in var_153 {
{
#[allow(unused_mut)]
let mut object_156 = array_154.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_156, item_155)?;
object_156.finish();
}
}
array_154.finish();
}
if let Some(var_157) = &input.enable_iot_role_alias {
object.key("EnableIotRoleAlias").boolean(*var_157);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_domain_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDomainInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_158) = &input.domain_name {
object.key("DomainName").string(var_158.as_str());
}
if let Some(var_159) = &input.auth_mode {
object.key("AuthMode").string(var_159.as_str());
}
if let Some(var_160) = &input.default_user_settings {
#[allow(unused_mut)]
let mut object_161 = object.key("DefaultUserSettings").start_object();
crate::json_ser::serialize_structure_crate_model_user_settings(&mut object_161, var_160)?;
object_161.finish();
}
if let Some(var_162) = &input.subnet_ids {
let mut array_163 = object.key("SubnetIds").start_array();
for item_164 in var_162 {
{
array_163.value().string(item_164.as_str());
}
}
array_163.finish();
}
if let Some(var_165) = &input.vpc_id {
object.key("VpcId").string(var_165.as_str());
}
if let Some(var_166) = &input.tags {
let mut array_167 = object.key("Tags").start_array();
for item_168 in var_166 {
{
#[allow(unused_mut)]
let mut object_169 = array_167.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_169, item_168)?;
object_169.finish();
}
}
array_167.finish();
}
if let Some(var_170) = &input.app_network_access_type {
object.key("AppNetworkAccessType").string(var_170.as_str());
}
if let Some(var_171) = &input.home_efs_file_system_kms_key_id {
object
.key("HomeEfsFileSystemKmsKeyId")
.string(var_171.as_str());
}
if let Some(var_172) = &input.kms_key_id {
object.key("KmsKeyId").string(var_172.as_str());
}
if let Some(var_173) = &input.app_security_group_management {
object
.key("AppSecurityGroupManagement")
.string(var_173.as_str());
}
if let Some(var_174) = &input.domain_settings {
#[allow(unused_mut)]
let mut object_175 = object.key("DomainSettings").start_object();
crate::json_ser::serialize_structure_crate_model_domain_settings(&mut object_175, var_174)?;
object_175.finish();
}
if let Some(var_176) = &input.default_space_settings {
#[allow(unused_mut)]
let mut object_177 = object.key("DefaultSpaceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_default_space_settings(
&mut object_177,
var_176,
)?;
object_177.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_edge_deployment_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateEdgeDeploymentPlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_178) = &input.edge_deployment_plan_name {
object
.key("EdgeDeploymentPlanName")
.string(var_178.as_str());
}
if let Some(var_179) = &input.model_configs {
let mut array_180 = object.key("ModelConfigs").start_array();
for item_181 in var_179 {
{
#[allow(unused_mut)]
let mut object_182 = array_180.value().start_object();
crate::json_ser::serialize_structure_crate_model_edge_deployment_model_config(
&mut object_182,
item_181,
)?;
object_182.finish();
}
}
array_180.finish();
}
if let Some(var_183) = &input.device_fleet_name {
object.key("DeviceFleetName").string(var_183.as_str());
}
if let Some(var_184) = &input.stages {
let mut array_185 = object.key("Stages").start_array();
for item_186 in var_184 {
{
#[allow(unused_mut)]
let mut object_187 = array_185.value().start_object();
crate::json_ser::serialize_structure_crate_model_deployment_stage(
&mut object_187,
item_186,
)?;
object_187.finish();
}
}
array_185.finish();
}
if let Some(var_188) = &input.tags {
let mut array_189 = object.key("Tags").start_array();
for item_190 in var_188 {
{
#[allow(unused_mut)]
let mut object_191 = array_189.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_191, item_190)?;
object_191.finish();
}
}
array_189.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_edge_deployment_stage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateEdgeDeploymentStageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_192) = &input.edge_deployment_plan_name {
object
.key("EdgeDeploymentPlanName")
.string(var_192.as_str());
}
if let Some(var_193) = &input.stages {
let mut array_194 = object.key("Stages").start_array();
for item_195 in var_193 {
{
#[allow(unused_mut)]
let mut object_196 = array_194.value().start_object();
crate::json_ser::serialize_structure_crate_model_deployment_stage(
&mut object_196,
item_195,
)?;
object_196.finish();
}
}
array_194.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_edge_packaging_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateEdgePackagingJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_197) = &input.edge_packaging_job_name {
object.key("EdgePackagingJobName").string(var_197.as_str());
}
if let Some(var_198) = &input.compilation_job_name {
object.key("CompilationJobName").string(var_198.as_str());
}
if let Some(var_199) = &input.model_name {
object.key("ModelName").string(var_199.as_str());
}
if let Some(var_200) = &input.model_version {
object.key("ModelVersion").string(var_200.as_str());
}
if let Some(var_201) = &input.role_arn {
object.key("RoleArn").string(var_201.as_str());
}
if let Some(var_202) = &input.output_config {
#[allow(unused_mut)]
let mut object_203 = object.key("OutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_edge_output_config(
&mut object_203,
var_202,
)?;
object_203.finish();
}
if let Some(var_204) = &input.resource_key {
object.key("ResourceKey").string(var_204.as_str());
}
if let Some(var_205) = &input.tags {
let mut array_206 = object.key("Tags").start_array();
for item_207 in var_205 {
{
#[allow(unused_mut)]
let mut object_208 = array_206.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_208, item_207)?;
object_208.finish();
}
}
array_206.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_209) = &input.endpoint_name {
object.key("EndpointName").string(var_209.as_str());
}
if let Some(var_210) = &input.endpoint_config_name {
object.key("EndpointConfigName").string(var_210.as_str());
}
if let Some(var_211) = &input.deployment_config {
#[allow(unused_mut)]
let mut object_212 = object.key("DeploymentConfig").start_object();
crate::json_ser::serialize_structure_crate_model_deployment_config(
&mut object_212,
var_211,
)?;
object_212.finish();
}
if let Some(var_213) = &input.tags {
let mut array_214 = object.key("Tags").start_array();
for item_215 in var_213 {
{
#[allow(unused_mut)]
let mut object_216 = array_214.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_216, item_215)?;
object_216.finish();
}
}
array_214.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_endpoint_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateEndpointConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_217) = &input.endpoint_config_name {
object.key("EndpointConfigName").string(var_217.as_str());
}
if let Some(var_218) = &input.production_variants {
let mut array_219 = object.key("ProductionVariants").start_array();
for item_220 in var_218 {
{
#[allow(unused_mut)]
let mut object_221 = array_219.value().start_object();
crate::json_ser::serialize_structure_crate_model_production_variant(
&mut object_221,
item_220,
)?;
object_221.finish();
}
}
array_219.finish();
}
if let Some(var_222) = &input.data_capture_config {
#[allow(unused_mut)]
let mut object_223 = object.key("DataCaptureConfig").start_object();
crate::json_ser::serialize_structure_crate_model_data_capture_config(
&mut object_223,
var_222,
)?;
object_223.finish();
}
if let Some(var_224) = &input.tags {
let mut array_225 = object.key("Tags").start_array();
for item_226 in var_224 {
{
#[allow(unused_mut)]
let mut object_227 = array_225.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_227, item_226)?;
object_227.finish();
}
}
array_225.finish();
}
if let Some(var_228) = &input.kms_key_id {
object.key("KmsKeyId").string(var_228.as_str());
}
if let Some(var_229) = &input.async_inference_config {
#[allow(unused_mut)]
let mut object_230 = object.key("AsyncInferenceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_async_inference_config(
&mut object_230,
var_229,
)?;
object_230.finish();
}
if let Some(var_231) = &input.explainer_config {
#[allow(unused_mut)]
let mut object_232 = object.key("ExplainerConfig").start_object();
crate::json_ser::serialize_structure_crate_model_explainer_config(
&mut object_232,
var_231,
)?;
object_232.finish();
}
if let Some(var_233) = &input.shadow_production_variants {
let mut array_234 = object.key("ShadowProductionVariants").start_array();
for item_235 in var_233 {
{
#[allow(unused_mut)]
let mut object_236 = array_234.value().start_object();
crate::json_ser::serialize_structure_crate_model_production_variant(
&mut object_236,
item_235,
)?;
object_236.finish();
}
}
array_234.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_experiment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateExperimentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_237) = &input.experiment_name {
object.key("ExperimentName").string(var_237.as_str());
}
if let Some(var_238) = &input.display_name {
object.key("DisplayName").string(var_238.as_str());
}
if let Some(var_239) = &input.description {
object.key("Description").string(var_239.as_str());
}
if let Some(var_240) = &input.tags {
let mut array_241 = object.key("Tags").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_tag(&mut object_243, item_242)?;
object_243.finish();
}
}
array_241.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_feature_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFeatureGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_244) = &input.feature_group_name {
object.key("FeatureGroupName").string(var_244.as_str());
}
if let Some(var_245) = &input.record_identifier_feature_name {
object
.key("RecordIdentifierFeatureName")
.string(var_245.as_str());
}
if let Some(var_246) = &input.event_time_feature_name {
object.key("EventTimeFeatureName").string(var_246.as_str());
}
if let Some(var_247) = &input.feature_definitions {
let mut array_248 = object.key("FeatureDefinitions").start_array();
for item_249 in var_247 {
{
#[allow(unused_mut)]
let mut object_250 = array_248.value().start_object();
crate::json_ser::serialize_structure_crate_model_feature_definition(
&mut object_250,
item_249,
)?;
object_250.finish();
}
}
array_248.finish();
}
if let Some(var_251) = &input.online_store_config {
#[allow(unused_mut)]
let mut object_252 = object.key("OnlineStoreConfig").start_object();
crate::json_ser::serialize_structure_crate_model_online_store_config(
&mut object_252,
var_251,
)?;
object_252.finish();
}
if let Some(var_253) = &input.offline_store_config {
#[allow(unused_mut)]
let mut object_254 = object.key("OfflineStoreConfig").start_object();
crate::json_ser::serialize_structure_crate_model_offline_store_config(
&mut object_254,
var_253,
)?;
object_254.finish();
}
if let Some(var_255) = &input.role_arn {
object.key("RoleArn").string(var_255.as_str());
}
if let Some(var_256) = &input.description {
object.key("Description").string(var_256.as_str());
}
if let Some(var_257) = &input.tags {
let mut array_258 = object.key("Tags").start_array();
for item_259 in var_257 {
{
#[allow(unused_mut)]
let mut object_260 = array_258.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_260, item_259)?;
object_260.finish();
}
}
array_258.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_flow_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFlowDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_261) = &input.flow_definition_name {
object.key("FlowDefinitionName").string(var_261.as_str());
}
if let Some(var_262) = &input.human_loop_request_source {
#[allow(unused_mut)]
let mut object_263 = object.key("HumanLoopRequestSource").start_object();
crate::json_ser::serialize_structure_crate_model_human_loop_request_source(
&mut object_263,
var_262,
)?;
object_263.finish();
}
if let Some(var_264) = &input.human_loop_activation_config {
#[allow(unused_mut)]
let mut object_265 = object.key("HumanLoopActivationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_human_loop_activation_config(
&mut object_265,
var_264,
)?;
object_265.finish();
}
if let Some(var_266) = &input.human_loop_config {
#[allow(unused_mut)]
let mut object_267 = object.key("HumanLoopConfig").start_object();
crate::json_ser::serialize_structure_crate_model_human_loop_config(
&mut object_267,
var_266,
)?;
object_267.finish();
}
if let Some(var_268) = &input.output_config {
#[allow(unused_mut)]
let mut object_269 = object.key("OutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_flow_definition_output_config(
&mut object_269,
var_268,
)?;
object_269.finish();
}
if let Some(var_270) = &input.role_arn {
object.key("RoleArn").string(var_270.as_str());
}
if let Some(var_271) = &input.tags {
let mut array_272 = object.key("Tags").start_array();
for item_273 in var_271 {
{
#[allow(unused_mut)]
let mut object_274 = array_272.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_274, item_273)?;
object_274.finish();
}
}
array_272.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_hub_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateHubInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_275) = &input.hub_name {
object.key("HubName").string(var_275.as_str());
}
if let Some(var_276) = &input.hub_description {
object.key("HubDescription").string(var_276.as_str());
}
if let Some(var_277) = &input.hub_display_name {
object.key("HubDisplayName").string(var_277.as_str());
}
if let Some(var_278) = &input.hub_search_keywords {
let mut array_279 = object.key("HubSearchKeywords").start_array();
for item_280 in var_278 {
{
array_279.value().string(item_280.as_str());
}
}
array_279.finish();
}
if let Some(var_281) = &input.s3_storage_config {
#[allow(unused_mut)]
let mut object_282 = object.key("S3StorageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_hub_s3_storage_config(
&mut object_282,
var_281,
)?;
object_282.finish();
}
if let Some(var_283) = &input.tags {
let mut array_284 = object.key("Tags").start_array();
for item_285 in var_283 {
{
#[allow(unused_mut)]
let mut object_286 = array_284.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_286, item_285)?;
object_286.finish();
}
}
array_284.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_human_task_ui_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateHumanTaskUiInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_287) = &input.human_task_ui_name {
object.key("HumanTaskUiName").string(var_287.as_str());
}
if let Some(var_288) = &input.ui_template {
#[allow(unused_mut)]
let mut object_289 = object.key("UiTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_ui_template(&mut object_289, var_288)?;
object_289.finish();
}
if let Some(var_290) = &input.tags {
let mut array_291 = object.key("Tags").start_array();
for item_292 in var_290 {
{
#[allow(unused_mut)]
let mut object_293 = array_291.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_293, item_292)?;
object_293.finish();
}
}
array_291.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_hyper_parameter_tuning_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateHyperParameterTuningJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_294) = &input.hyper_parameter_tuning_job_name {
object
.key("HyperParameterTuningJobName")
.string(var_294.as_str());
}
if let Some(var_295) = &input.hyper_parameter_tuning_job_config {
#[allow(unused_mut)]
let mut object_296 = object.key("HyperParameterTuningJobConfig").start_object();
crate::json_ser::serialize_structure_crate_model_hyper_parameter_tuning_job_config(
&mut object_296,
var_295,
)?;
object_296.finish();
}
if let Some(var_297) = &input.training_job_definition {
#[allow(unused_mut)]
let mut object_298 = object.key("TrainingJobDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_hyper_parameter_training_job_definition(
&mut object_298,
var_297,
)?;
object_298.finish();
}
if let Some(var_299) = &input.training_job_definitions {
let mut array_300 = object.key("TrainingJobDefinitions").start_array();
for item_301 in var_299 {
{
#[allow(unused_mut)]
let mut object_302 = array_300.value().start_object();
crate::json_ser::serialize_structure_crate_model_hyper_parameter_training_job_definition(&mut object_302, item_301)?;
object_302.finish();
}
}
array_300.finish();
}
if let Some(var_303) = &input.warm_start_config {
#[allow(unused_mut)]
let mut object_304 = object.key("WarmStartConfig").start_object();
crate::json_ser::serialize_structure_crate_model_hyper_parameter_tuning_job_warm_start_config(&mut object_304, var_303)?;
object_304.finish();
}
if let Some(var_305) = &input.tags {
let mut array_306 = object.key("Tags").start_array();
for item_307 in var_305 {
{
#[allow(unused_mut)]
let mut object_308 = array_306.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_308, item_307)?;
object_308.finish();
}
}
array_306.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_image_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateImageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_309) = &input.description {
object.key("Description").string(var_309.as_str());
}
if let Some(var_310) = &input.display_name {
object.key("DisplayName").string(var_310.as_str());
}
if let Some(var_311) = &input.image_name {
object.key("ImageName").string(var_311.as_str());
}
if let Some(var_312) = &input.role_arn {
object.key("RoleArn").string(var_312.as_str());
}
if let Some(var_313) = &input.tags {
let mut array_314 = object.key("Tags").start_array();
for item_315 in var_313 {
{
#[allow(unused_mut)]
let mut object_316 = array_314.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_316, item_315)?;
object_316.finish();
}
}
array_314.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_image_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateImageVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_317) = &input.base_image {
object.key("BaseImage").string(var_317.as_str());
}
if let Some(var_318) = &input.client_token {
object.key("ClientToken").string(var_318.as_str());
}
if let Some(var_319) = &input.image_name {
object.key("ImageName").string(var_319.as_str());
}
if let Some(var_320) = &input.aliases {
let mut array_321 = object.key("Aliases").start_array();
for item_322 in var_320 {
{
array_321.value().string(item_322.as_str());
}
}
array_321.finish();
}
if let Some(var_323) = &input.vendor_guidance {
object.key("VendorGuidance").string(var_323.as_str());
}
if let Some(var_324) = &input.job_type {
object.key("JobType").string(var_324.as_str());
}
if let Some(var_325) = &input.ml_framework {
object.key("MLFramework").string(var_325.as_str());
}
if let Some(var_326) = &input.programming_lang {
object.key("ProgrammingLang").string(var_326.as_str());
}
if let Some(var_327) = &input.processor {
object.key("Processor").string(var_327.as_str());
}
if input.horovod {
object.key("Horovod").boolean(input.horovod);
}
if let Some(var_328) = &input.release_notes {
object.key("ReleaseNotes").string(var_328.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_inference_experiment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateInferenceExperimentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_329) = &input.name {
object.key("Name").string(var_329.as_str());
}
if let Some(var_330) = &input.r#type {
object.key("Type").string(var_330.as_str());
}
if let Some(var_331) = &input.schedule {
#[allow(unused_mut)]
let mut object_332 = object.key("Schedule").start_object();
crate::json_ser::serialize_structure_crate_model_inference_experiment_schedule(
&mut object_332,
var_331,
)?;
object_332.finish();
}
if let Some(var_333) = &input.description {
object.key("Description").string(var_333.as_str());
}
if let Some(var_334) = &input.role_arn {
object.key("RoleArn").string(var_334.as_str());
}
if let Some(var_335) = &input.endpoint_name {
object.key("EndpointName").string(var_335.as_str());
}
if let Some(var_336) = &input.model_variants {
let mut array_337 = object.key("ModelVariants").start_array();
for item_338 in var_336 {
{
#[allow(unused_mut)]
let mut object_339 = array_337.value().start_object();
crate::json_ser::serialize_structure_crate_model_model_variant_config(
&mut object_339,
item_338,
)?;
object_339.finish();
}
}
array_337.finish();
}
if let Some(var_340) = &input.data_storage_config {
#[allow(unused_mut)]
let mut object_341 = object.key("DataStorageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_inference_experiment_data_storage_config(
&mut object_341,
var_340,
)?;
object_341.finish();
}
if let Some(var_342) = &input.shadow_mode_config {
#[allow(unused_mut)]
let mut object_343 = object.key("ShadowModeConfig").start_object();
crate::json_ser::serialize_structure_crate_model_shadow_mode_config(
&mut object_343,
var_342,
)?;
object_343.finish();
}
if let Some(var_344) = &input.kms_key {
object.key("KmsKey").string(var_344.as_str());
}
if let Some(var_345) = &input.tags {
let mut array_346 = object.key("Tags").start_array();
for item_347 in var_345 {
{
#[allow(unused_mut)]
let mut object_348 = array_346.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_348, item_347)?;
object_348.finish();
}
}
array_346.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_inference_recommendations_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateInferenceRecommendationsJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_349) = &input.job_name {
object.key("JobName").string(var_349.as_str());
}
if let Some(var_350) = &input.job_type {
object.key("JobType").string(var_350.as_str());
}
if let Some(var_351) = &input.role_arn {
object.key("RoleArn").string(var_351.as_str());
}
if let Some(var_352) = &input.input_config {
#[allow(unused_mut)]
let mut object_353 = object.key("InputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_recommendation_job_input_config(
&mut object_353,
var_352,
)?;
object_353.finish();
}
if let Some(var_354) = &input.job_description {
object.key("JobDescription").string(var_354.as_str());
}
if let Some(var_355) = &input.stopping_conditions {
#[allow(unused_mut)]
let mut object_356 = object.key("StoppingConditions").start_object();
crate::json_ser::serialize_structure_crate_model_recommendation_job_stopping_conditions(
&mut object_356,
var_355,
)?;
object_356.finish();
}
if let Some(var_357) = &input.output_config {
#[allow(unused_mut)]
let mut object_358 = object.key("OutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_recommendation_job_output_config(
&mut object_358,
var_357,
)?;
object_358.finish();
}
if let Some(var_359) = &input.tags {
let mut array_360 = object.key("Tags").start_array();
for item_361 in var_359 {
{
#[allow(unused_mut)]
let mut object_362 = array_360.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_362, item_361)?;
object_362.finish();
}
}
array_360.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_labeling_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLabelingJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_363) = &input.labeling_job_name {
object.key("LabelingJobName").string(var_363.as_str());
}
if let Some(var_364) = &input.label_attribute_name {
object.key("LabelAttributeName").string(var_364.as_str());
}
if let Some(var_365) = &input.input_config {
#[allow(unused_mut)]
let mut object_366 = object.key("InputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_labeling_job_input_config(
&mut object_366,
var_365,
)?;
object_366.finish();
}
if let Some(var_367) = &input.output_config {
#[allow(unused_mut)]
let mut object_368 = object.key("OutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_labeling_job_output_config(
&mut object_368,
var_367,
)?;
object_368.finish();
}
if let Some(var_369) = &input.role_arn {
object.key("RoleArn").string(var_369.as_str());
}
if let Some(var_370) = &input.label_category_config_s3_uri {
object
.key("LabelCategoryConfigS3Uri")
.string(var_370.as_str());
}
if let Some(var_371) = &input.stopping_conditions {
#[allow(unused_mut)]
let mut object_372 = object.key("StoppingConditions").start_object();
crate::json_ser::serialize_structure_crate_model_labeling_job_stopping_conditions(
&mut object_372,
var_371,
)?;
object_372.finish();
}
if let Some(var_373) = &input.labeling_job_algorithms_config {
#[allow(unused_mut)]
let mut object_374 = object.key("LabelingJobAlgorithmsConfig").start_object();
crate::json_ser::serialize_structure_crate_model_labeling_job_algorithms_config(
&mut object_374,
var_373,
)?;
object_374.finish();
}
if let Some(var_375) = &input.human_task_config {
#[allow(unused_mut)]
let mut object_376 = object.key("HumanTaskConfig").start_object();
crate::json_ser::serialize_structure_crate_model_human_task_config(
&mut object_376,
var_375,
)?;
object_376.finish();
}
if let Some(var_377) = &input.tags {
let mut array_378 = object.key("Tags").start_array();
for item_379 in var_377 {
{
#[allow(unused_mut)]
let mut object_380 = array_378.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_380, item_379)?;
object_380.finish();
}
}
array_378.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_381) = &input.model_name {
object.key("ModelName").string(var_381.as_str());
}
if let Some(var_382) = &input.primary_container {
#[allow(unused_mut)]
let mut object_383 = object.key("PrimaryContainer").start_object();
crate::json_ser::serialize_structure_crate_model_container_definition(
&mut object_383,
var_382,
)?;
object_383.finish();
}
if let Some(var_384) = &input.containers {
let mut array_385 = object.key("Containers").start_array();
for item_386 in var_384 {
{
#[allow(unused_mut)]
let mut object_387 = array_385.value().start_object();
crate::json_ser::serialize_structure_crate_model_container_definition(
&mut object_387,
item_386,
)?;
object_387.finish();
}
}
array_385.finish();
}
if let Some(var_388) = &input.inference_execution_config {
#[allow(unused_mut)]
let mut object_389 = object.key("InferenceExecutionConfig").start_object();
crate::json_ser::serialize_structure_crate_model_inference_execution_config(
&mut object_389,
var_388,
)?;
object_389.finish();
}
if let Some(var_390) = &input.execution_role_arn {
object.key("ExecutionRoleArn").string(var_390.as_str());
}
if let Some(var_391) = &input.tags {
let mut array_392 = object.key("Tags").start_array();
for item_393 in var_391 {
{
#[allow(unused_mut)]
let mut object_394 = array_392.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_394, item_393)?;
object_394.finish();
}
}
array_392.finish();
}
if let Some(var_395) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_396 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_396, var_395)?;
object_396.finish();
}
if input.enable_network_isolation {
object
.key("EnableNetworkIsolation")
.boolean(input.enable_network_isolation);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_model_bias_job_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateModelBiasJobDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_397) = &input.job_definition_name {
object.key("JobDefinitionName").string(var_397.as_str());
}
if let Some(var_398) = &input.model_bias_baseline_config {
#[allow(unused_mut)]
let mut object_399 = object.key("ModelBiasBaselineConfig").start_object();
crate::json_ser::serialize_structure_crate_model_model_bias_baseline_config(
&mut object_399,
var_398,
)?;
object_399.finish();
}
if let Some(var_400) = &input.model_bias_app_specification {
#[allow(unused_mut)]
let mut object_401 = object.key("ModelBiasAppSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_model_bias_app_specification(
&mut object_401,
var_400,
)?;
object_401.finish();
}
if let Some(var_402) = &input.model_bias_job_input {
#[allow(unused_mut)]
let mut object_403 = object.key("ModelBiasJobInput").start_object();
crate::json_ser::serialize_structure_crate_model_model_bias_job_input(
&mut object_403,
var_402,
)?;
object_403.finish();
}
if let Some(var_404) = &input.model_bias_job_output_config {
#[allow(unused_mut)]
let mut object_405 = object.key("ModelBiasJobOutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_output_config(
&mut object_405,
var_404,
)?;
object_405.finish();
}
if let Some(var_406) = &input.job_resources {
#[allow(unused_mut)]
let mut object_407 = object.key("JobResources").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_resources(
&mut object_407,
var_406,
)?;
object_407.finish();
}
if let Some(var_408) = &input.network_config {
#[allow(unused_mut)]
let mut object_409 = object.key("NetworkConfig").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_network_config(
&mut object_409,
var_408,
)?;
object_409.finish();
}
if let Some(var_410) = &input.role_arn {
object.key("RoleArn").string(var_410.as_str());
}
if let Some(var_411) = &input.stopping_condition {
#[allow(unused_mut)]
let mut object_412 = object.key("StoppingCondition").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_stopping_condition(
&mut object_412,
var_411,
)?;
object_412.finish();
}
if let Some(var_413) = &input.tags {
let mut array_414 = object.key("Tags").start_array();
for item_415 in var_413 {
{
#[allow(unused_mut)]
let mut object_416 = array_414.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_416, item_415)?;
object_416.finish();
}
}
array_414.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_model_card_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateModelCardInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_417) = &input.model_card_name {
object.key("ModelCardName").string(var_417.as_str());
}
if let Some(var_418) = &input.security_config {
#[allow(unused_mut)]
let mut object_419 = object.key("SecurityConfig").start_object();
crate::json_ser::serialize_structure_crate_model_model_card_security_config(
&mut object_419,
var_418,
)?;
object_419.finish();
}
if let Some(var_420) = &input.content {
object.key("Content").string(var_420.as_str());
}
if let Some(var_421) = &input.model_card_status {
object.key("ModelCardStatus").string(var_421.as_str());
}
if let Some(var_422) = &input.tags {
let mut array_423 = object.key("Tags").start_array();
for item_424 in var_422 {
{
#[allow(unused_mut)]
let mut object_425 = array_423.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_425, item_424)?;
object_425.finish();
}
}
array_423.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_model_card_export_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateModelCardExportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_426) = &input.model_card_name {
object.key("ModelCardName").string(var_426.as_str());
}
if input.model_card_version != 0 {
object.key("ModelCardVersion").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.model_card_version).into()),
);
}
if let Some(var_427) = &input.model_card_export_job_name {
object
.key("ModelCardExportJobName")
.string(var_427.as_str());
}
if let Some(var_428) = &input.output_config {
#[allow(unused_mut)]
let mut object_429 = object.key("OutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_model_card_export_output_config(
&mut object_429,
var_428,
)?;
object_429.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_model_explainability_job_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateModelExplainabilityJobDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_430) = &input.job_definition_name {
object.key("JobDefinitionName").string(var_430.as_str());
}
if let Some(var_431) = &input.model_explainability_baseline_config {
#[allow(unused_mut)]
let mut object_432 = object
.key("ModelExplainabilityBaselineConfig")
.start_object();
crate::json_ser::serialize_structure_crate_model_model_explainability_baseline_config(
&mut object_432,
var_431,
)?;
object_432.finish();
}
if let Some(var_433) = &input.model_explainability_app_specification {
#[allow(unused_mut)]
let mut object_434 = object
.key("ModelExplainabilityAppSpecification")
.start_object();
crate::json_ser::serialize_structure_crate_model_model_explainability_app_specification(
&mut object_434,
var_433,
)?;
object_434.finish();
}
if let Some(var_435) = &input.model_explainability_job_input {
#[allow(unused_mut)]
let mut object_436 = object.key("ModelExplainabilityJobInput").start_object();
crate::json_ser::serialize_structure_crate_model_model_explainability_job_input(
&mut object_436,
var_435,
)?;
object_436.finish();
}
if let Some(var_437) = &input.model_explainability_job_output_config {
#[allow(unused_mut)]
let mut object_438 = object
.key("ModelExplainabilityJobOutputConfig")
.start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_output_config(
&mut object_438,
var_437,
)?;
object_438.finish();
}
if let Some(var_439) = &input.job_resources {
#[allow(unused_mut)]
let mut object_440 = object.key("JobResources").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_resources(
&mut object_440,
var_439,
)?;
object_440.finish();
}
if let Some(var_441) = &input.network_config {
#[allow(unused_mut)]
let mut object_442 = object.key("NetworkConfig").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_network_config(
&mut object_442,
var_441,
)?;
object_442.finish();
}
if let Some(var_443) = &input.role_arn {
object.key("RoleArn").string(var_443.as_str());
}
if let Some(var_444) = &input.stopping_condition {
#[allow(unused_mut)]
let mut object_445 = object.key("StoppingCondition").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_stopping_condition(
&mut object_445,
var_444,
)?;
object_445.finish();
}
if let Some(var_446) = &input.tags {
let mut array_447 = object.key("Tags").start_array();
for item_448 in var_446 {
{
#[allow(unused_mut)]
let mut object_449 = array_447.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_449, item_448)?;
object_449.finish();
}
}
array_447.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_model_package_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateModelPackageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_450) = &input.model_package_name {
object.key("ModelPackageName").string(var_450.as_str());
}
if let Some(var_451) = &input.model_package_group_name {
object.key("ModelPackageGroupName").string(var_451.as_str());
}
if let Some(var_452) = &input.model_package_description {
object
.key("ModelPackageDescription")
.string(var_452.as_str());
}
if let Some(var_453) = &input.inference_specification {
#[allow(unused_mut)]
let mut object_454 = object.key("InferenceSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_inference_specification(
&mut object_454,
var_453,
)?;
object_454.finish();
}
if let Some(var_455) = &input.validation_specification {
#[allow(unused_mut)]
let mut object_456 = object.key("ValidationSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_model_package_validation_specification(
&mut object_456,
var_455,
)?;
object_456.finish();
}
if let Some(var_457) = &input.source_algorithm_specification {
#[allow(unused_mut)]
let mut object_458 = object.key("SourceAlgorithmSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_source_algorithm_specification(
&mut object_458,
var_457,
)?;
object_458.finish();
}
if input.certify_for_marketplace {
object
.key("CertifyForMarketplace")
.boolean(input.certify_for_marketplace);
}
if let Some(var_459) = &input.tags {
let mut array_460 = object.key("Tags").start_array();
for item_461 in var_459 {
{
#[allow(unused_mut)]
let mut object_462 = array_460.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_462, item_461)?;
object_462.finish();
}
}
array_460.finish();
}
if let Some(var_463) = &input.model_approval_status {
object.key("ModelApprovalStatus").string(var_463.as_str());
}
if let Some(var_464) = &input.metadata_properties {
#[allow(unused_mut)]
let mut object_465 = object.key("MetadataProperties").start_object();
crate::json_ser::serialize_structure_crate_model_metadata_properties(
&mut object_465,
var_464,
)?;
object_465.finish();
}
if let Some(var_466) = &input.model_metrics {
#[allow(unused_mut)]
let mut object_467 = object.key("ModelMetrics").start_object();
crate::json_ser::serialize_structure_crate_model_model_metrics(&mut object_467, var_466)?;
object_467.finish();
}
if let Some(var_468) = &input.client_token {
object.key("ClientToken").string(var_468.as_str());
}
if let Some(var_469) = &input.customer_metadata_properties {
#[allow(unused_mut)]
let mut object_470 = object.key("CustomerMetadataProperties").start_object();
for (key_471, value_472) in var_469 {
{
object_470.key(key_471.as_str()).string(value_472.as_str());
}
}
object_470.finish();
}
if let Some(var_473) = &input.drift_check_baselines {
#[allow(unused_mut)]
let mut object_474 = object.key("DriftCheckBaselines").start_object();
crate::json_ser::serialize_structure_crate_model_drift_check_baselines(
&mut object_474,
var_473,
)?;
object_474.finish();
}
if let Some(var_475) = &input.domain {
object.key("Domain").string(var_475.as_str());
}
if let Some(var_476) = &input.task {
object.key("Task").string(var_476.as_str());
}
if let Some(var_477) = &input.sample_payload_url {
object.key("SamplePayloadUrl").string(var_477.as_str());
}
if let Some(var_478) = &input.additional_inference_specifications {
let mut array_479 = object
.key("AdditionalInferenceSpecifications")
.start_array();
for item_480 in var_478 {
{
#[allow(unused_mut)]
let mut object_481 = array_479.value().start_object();
crate::json_ser::serialize_structure_crate_model_additional_inference_specification_definition(&mut object_481, item_480)?;
object_481.finish();
}
}
array_479.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_model_package_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateModelPackageGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_482) = &input.model_package_group_name {
object.key("ModelPackageGroupName").string(var_482.as_str());
}
if let Some(var_483) = &input.model_package_group_description {
object
.key("ModelPackageGroupDescription")
.string(var_483.as_str());
}
if let Some(var_484) = &input.tags {
let mut array_485 = object.key("Tags").start_array();
for item_486 in var_484 {
{
#[allow(unused_mut)]
let mut object_487 = array_485.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_487, item_486)?;
object_487.finish();
}
}
array_485.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_model_quality_job_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateModelQualityJobDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_488) = &input.job_definition_name {
object.key("JobDefinitionName").string(var_488.as_str());
}
if let Some(var_489) = &input.model_quality_baseline_config {
#[allow(unused_mut)]
let mut object_490 = object.key("ModelQualityBaselineConfig").start_object();
crate::json_ser::serialize_structure_crate_model_model_quality_baseline_config(
&mut object_490,
var_489,
)?;
object_490.finish();
}
if let Some(var_491) = &input.model_quality_app_specification {
#[allow(unused_mut)]
let mut object_492 = object.key("ModelQualityAppSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_model_quality_app_specification(
&mut object_492,
var_491,
)?;
object_492.finish();
}
if let Some(var_493) = &input.model_quality_job_input {
#[allow(unused_mut)]
let mut object_494 = object.key("ModelQualityJobInput").start_object();
crate::json_ser::serialize_structure_crate_model_model_quality_job_input(
&mut object_494,
var_493,
)?;
object_494.finish();
}
if let Some(var_495) = &input.model_quality_job_output_config {
#[allow(unused_mut)]
let mut object_496 = object.key("ModelQualityJobOutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_output_config(
&mut object_496,
var_495,
)?;
object_496.finish();
}
if let Some(var_497) = &input.job_resources {
#[allow(unused_mut)]
let mut object_498 = object.key("JobResources").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_resources(
&mut object_498,
var_497,
)?;
object_498.finish();
}
if let Some(var_499) = &input.network_config {
#[allow(unused_mut)]
let mut object_500 = object.key("NetworkConfig").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_network_config(
&mut object_500,
var_499,
)?;
object_500.finish();
}
if let Some(var_501) = &input.role_arn {
object.key("RoleArn").string(var_501.as_str());
}
if let Some(var_502) = &input.stopping_condition {
#[allow(unused_mut)]
let mut object_503 = object.key("StoppingCondition").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_stopping_condition(
&mut object_503,
var_502,
)?;
object_503.finish();
}
if let Some(var_504) = &input.tags {
let mut array_505 = object.key("Tags").start_array();
for item_506 in var_504 {
{
#[allow(unused_mut)]
let mut object_507 = array_505.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_507, item_506)?;
object_507.finish();
}
}
array_505.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_monitoring_schedule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateMonitoringScheduleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_508) = &input.monitoring_schedule_name {
object
.key("MonitoringScheduleName")
.string(var_508.as_str());
}
if let Some(var_509) = &input.monitoring_schedule_config {
#[allow(unused_mut)]
let mut object_510 = object.key("MonitoringScheduleConfig").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_schedule_config(
&mut object_510,
var_509,
)?;
object_510.finish();
}
if let Some(var_511) = &input.tags {
let mut array_512 = object.key("Tags").start_array();
for item_513 in var_511 {
{
#[allow(unused_mut)]
let mut object_514 = array_512.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_514, item_513)?;
object_514.finish();
}
}
array_512.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_notebook_instance_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateNotebookInstanceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_515) = &input.notebook_instance_name {
object.key("NotebookInstanceName").string(var_515.as_str());
}
if let Some(var_516) = &input.instance_type {
object.key("InstanceType").string(var_516.as_str());
}
if let Some(var_517) = &input.subnet_id {
object.key("SubnetId").string(var_517.as_str());
}
if let Some(var_518) = &input.security_group_ids {
let mut array_519 = object.key("SecurityGroupIds").start_array();
for item_520 in var_518 {
{
array_519.value().string(item_520.as_str());
}
}
array_519.finish();
}
if let Some(var_521) = &input.role_arn {
object.key("RoleArn").string(var_521.as_str());
}
if let Some(var_522) = &input.kms_key_id {
object.key("KmsKeyId").string(var_522.as_str());
}
if let Some(var_523) = &input.tags {
let mut array_524 = object.key("Tags").start_array();
for item_525 in var_523 {
{
#[allow(unused_mut)]
let mut object_526 = array_524.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_526, item_525)?;
object_526.finish();
}
}
array_524.finish();
}
if let Some(var_527) = &input.lifecycle_config_name {
object.key("LifecycleConfigName").string(var_527.as_str());
}
if let Some(var_528) = &input.direct_internet_access {
object.key("DirectInternetAccess").string(var_528.as_str());
}
if let Some(var_529) = &input.volume_size_in_gb {
object.key("VolumeSizeInGB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_529).into()),
);
}
if let Some(var_530) = &input.accelerator_types {
let mut array_531 = object.key("AcceleratorTypes").start_array();
for item_532 in var_530 {
{
array_531.value().string(item_532.as_str());
}
}
array_531.finish();
}
if let Some(var_533) = &input.default_code_repository {
object.key("DefaultCodeRepository").string(var_533.as_str());
}
if let Some(var_534) = &input.additional_code_repositories {
let mut array_535 = object.key("AdditionalCodeRepositories").start_array();
for item_536 in var_534 {
{
array_535.value().string(item_536.as_str());
}
}
array_535.finish();
}
if let Some(var_537) = &input.root_access {
object.key("RootAccess").string(var_537.as_str());
}
if let Some(var_538) = &input.platform_identifier {
object.key("PlatformIdentifier").string(var_538.as_str());
}
if let Some(var_539) = &input.instance_metadata_service_configuration {
#[allow(unused_mut)]
let mut object_540 = object
.key("InstanceMetadataServiceConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_instance_metadata_service_configuration(
&mut object_540,
var_539,
)?;
object_540.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_notebook_instance_lifecycle_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateNotebookInstanceLifecycleConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_541) = &input.notebook_instance_lifecycle_config_name {
object
.key("NotebookInstanceLifecycleConfigName")
.string(var_541.as_str());
}
if let Some(var_542) = &input.on_create {
let mut array_543 = object.key("OnCreate").start_array();
for item_544 in var_542 {
{
#[allow(unused_mut)]
let mut object_545 = array_543.value().start_object();
crate::json_ser::serialize_structure_crate_model_notebook_instance_lifecycle_hook(
&mut object_545,
item_544,
)?;
object_545.finish();
}
}
array_543.finish();
}
if let Some(var_546) = &input.on_start {
let mut array_547 = object.key("OnStart").start_array();
for item_548 in var_546 {
{
#[allow(unused_mut)]
let mut object_549 = array_547.value().start_object();
crate::json_ser::serialize_structure_crate_model_notebook_instance_lifecycle_hook(
&mut object_549,
item_548,
)?;
object_549.finish();
}
}
array_547.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_pipeline_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePipelineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_550) = &input.pipeline_name {
object.key("PipelineName").string(var_550.as_str());
}
if let Some(var_551) = &input.pipeline_display_name {
object.key("PipelineDisplayName").string(var_551.as_str());
}
if let Some(var_552) = &input.pipeline_definition {
object.key("PipelineDefinition").string(var_552.as_str());
}
if let Some(var_553) = &input.pipeline_definition_s3_location {
#[allow(unused_mut)]
let mut object_554 = object.key("PipelineDefinitionS3Location").start_object();
crate::json_ser::serialize_structure_crate_model_pipeline_definition_s3_location(
&mut object_554,
var_553,
)?;
object_554.finish();
}
if let Some(var_555) = &input.pipeline_description {
object.key("PipelineDescription").string(var_555.as_str());
}
if let Some(var_556) = &input.client_request_token {
object.key("ClientRequestToken").string(var_556.as_str());
}
if let Some(var_557) = &input.role_arn {
object.key("RoleArn").string(var_557.as_str());
}
if let Some(var_558) = &input.tags {
let mut array_559 = object.key("Tags").start_array();
for item_560 in var_558 {
{
#[allow(unused_mut)]
let mut object_561 = array_559.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_561, item_560)?;
object_561.finish();
}
}
array_559.finish();
}
if let Some(var_562) = &input.parallelism_configuration {
#[allow(unused_mut)]
let mut object_563 = object.key("ParallelismConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_parallelism_configuration(
&mut object_563,
var_562,
)?;
object_563.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_presigned_domain_url_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePresignedDomainUrlInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_564) = &input.domain_id {
object.key("DomainId").string(var_564.as_str());
}
if let Some(var_565) = &input.user_profile_name {
object.key("UserProfileName").string(var_565.as_str());
}
if let Some(var_566) = &input.session_expiration_duration_in_seconds {
object.key("SessionExpirationDurationInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_566).into()),
);
}
if let Some(var_567) = &input.expires_in_seconds {
object.key("ExpiresInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_567).into()),
);
}
if let Some(var_568) = &input.space_name {
object.key("SpaceName").string(var_568.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_presigned_notebook_instance_url_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePresignedNotebookInstanceUrlInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_569) = &input.notebook_instance_name {
object.key("NotebookInstanceName").string(var_569.as_str());
}
if let Some(var_570) = &input.session_expiration_duration_in_seconds {
object.key("SessionExpirationDurationInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_570).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_processing_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateProcessingJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_571) = &input.processing_inputs {
let mut array_572 = object.key("ProcessingInputs").start_array();
for item_573 in var_571 {
{
#[allow(unused_mut)]
let mut object_574 = array_572.value().start_object();
crate::json_ser::serialize_structure_crate_model_processing_input(
&mut object_574,
item_573,
)?;
object_574.finish();
}
}
array_572.finish();
}
if let Some(var_575) = &input.processing_output_config {
#[allow(unused_mut)]
let mut object_576 = object.key("ProcessingOutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_processing_output_config(
&mut object_576,
var_575,
)?;
object_576.finish();
}
if let Some(var_577) = &input.processing_job_name {
object.key("ProcessingJobName").string(var_577.as_str());
}
if let Some(var_578) = &input.processing_resources {
#[allow(unused_mut)]
let mut object_579 = object.key("ProcessingResources").start_object();
crate::json_ser::serialize_structure_crate_model_processing_resources(
&mut object_579,
var_578,
)?;
object_579.finish();
}
if let Some(var_580) = &input.stopping_condition {
#[allow(unused_mut)]
let mut object_581 = object.key("StoppingCondition").start_object();
crate::json_ser::serialize_structure_crate_model_processing_stopping_condition(
&mut object_581,
var_580,
)?;
object_581.finish();
}
if let Some(var_582) = &input.app_specification {
#[allow(unused_mut)]
let mut object_583 = object.key("AppSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_app_specification(
&mut object_583,
var_582,
)?;
object_583.finish();
}
if let Some(var_584) = &input.environment {
#[allow(unused_mut)]
let mut object_585 = object.key("Environment").start_object();
for (key_586, value_587) in var_584 {
{
object_585.key(key_586.as_str()).string(value_587.as_str());
}
}
object_585.finish();
}
if let Some(var_588) = &input.network_config {
#[allow(unused_mut)]
let mut object_589 = object.key("NetworkConfig").start_object();
crate::json_ser::serialize_structure_crate_model_network_config(&mut object_589, var_588)?;
object_589.finish();
}
if let Some(var_590) = &input.role_arn {
object.key("RoleArn").string(var_590.as_str());
}
if let Some(var_591) = &input.tags {
let mut array_592 = object.key("Tags").start_array();
for item_593 in var_591 {
{
#[allow(unused_mut)]
let mut object_594 = array_592.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_594, item_593)?;
object_594.finish();
}
}
array_592.finish();
}
if let Some(var_595) = &input.experiment_config {
#[allow(unused_mut)]
let mut object_596 = object.key("ExperimentConfig").start_object();
crate::json_ser::serialize_structure_crate_model_experiment_config(
&mut object_596,
var_595,
)?;
object_596.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_project_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateProjectInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_597) = &input.project_name {
object.key("ProjectName").string(var_597.as_str());
}
if let Some(var_598) = &input.project_description {
object.key("ProjectDescription").string(var_598.as_str());
}
if let Some(var_599) = &input.service_catalog_provisioning_details {
#[allow(unused_mut)]
let mut object_600 = object
.key("ServiceCatalogProvisioningDetails")
.start_object();
crate::json_ser::serialize_structure_crate_model_service_catalog_provisioning_details(
&mut object_600,
var_599,
)?;
object_600.finish();
}
if let Some(var_601) = &input.tags {
let mut array_602 = object.key("Tags").start_array();
for item_603 in var_601 {
{
#[allow(unused_mut)]
let mut object_604 = array_602.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_604, item_603)?;
object_604.finish();
}
}
array_602.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_space_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSpaceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_605) = &input.domain_id {
object.key("DomainId").string(var_605.as_str());
}
if let Some(var_606) = &input.space_name {
object.key("SpaceName").string(var_606.as_str());
}
if let Some(var_607) = &input.tags {
let mut array_608 = object.key("Tags").start_array();
for item_609 in var_607 {
{
#[allow(unused_mut)]
let mut object_610 = array_608.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_610, item_609)?;
object_610.finish();
}
}
array_608.finish();
}
if let Some(var_611) = &input.space_settings {
#[allow(unused_mut)]
let mut object_612 = object.key("SpaceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_space_settings(&mut object_612, var_611)?;
object_612.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_studio_lifecycle_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateStudioLifecycleConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_613) = &input.studio_lifecycle_config_name {
object
.key("StudioLifecycleConfigName")
.string(var_613.as_str());
}
if let Some(var_614) = &input.studio_lifecycle_config_content {
object
.key("StudioLifecycleConfigContent")
.string(var_614.as_str());
}
if let Some(var_615) = &input.studio_lifecycle_config_app_type {
object
.key("StudioLifecycleConfigAppType")
.string(var_615.as_str());
}
if let Some(var_616) = &input.tags {
let mut array_617 = object.key("Tags").start_array();
for item_618 in var_616 {
{
#[allow(unused_mut)]
let mut object_619 = array_617.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_619, item_618)?;
object_619.finish();
}
}
array_617.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_training_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTrainingJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_620) = &input.training_job_name {
object.key("TrainingJobName").string(var_620.as_str());
}
if let Some(var_621) = &input.hyper_parameters {
#[allow(unused_mut)]
let mut object_622 = object.key("HyperParameters").start_object();
for (key_623, value_624) in var_621 {
{
object_622.key(key_623.as_str()).string(value_624.as_str());
}
}
object_622.finish();
}
if let Some(var_625) = &input.algorithm_specification {
#[allow(unused_mut)]
let mut object_626 = object.key("AlgorithmSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_algorithm_specification(
&mut object_626,
var_625,
)?;
object_626.finish();
}
if let Some(var_627) = &input.role_arn {
object.key("RoleArn").string(var_627.as_str());
}
if let Some(var_628) = &input.input_data_config {
let mut array_629 = object.key("InputDataConfig").start_array();
for item_630 in var_628 {
{
#[allow(unused_mut)]
let mut object_631 = array_629.value().start_object();
crate::json_ser::serialize_structure_crate_model_channel(
&mut object_631,
item_630,
)?;
object_631.finish();
}
}
array_629.finish();
}
if let Some(var_632) = &input.output_data_config {
#[allow(unused_mut)]
let mut object_633 = object.key("OutputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_output_data_config(
&mut object_633,
var_632,
)?;
object_633.finish();
}
if let Some(var_634) = &input.resource_config {
#[allow(unused_mut)]
let mut object_635 = object.key("ResourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_resource_config(&mut object_635, var_634)?;
object_635.finish();
}
if let Some(var_636) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_637 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_637, var_636)?;
object_637.finish();
}
if let Some(var_638) = &input.stopping_condition {
#[allow(unused_mut)]
let mut object_639 = object.key("StoppingCondition").start_object();
crate::json_ser::serialize_structure_crate_model_stopping_condition(
&mut object_639,
var_638,
)?;
object_639.finish();
}
if let Some(var_640) = &input.tags {
let mut array_641 = object.key("Tags").start_array();
for item_642 in var_640 {
{
#[allow(unused_mut)]
let mut object_643 = array_641.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_643, item_642)?;
object_643.finish();
}
}
array_641.finish();
}
if input.enable_network_isolation {
object
.key("EnableNetworkIsolation")
.boolean(input.enable_network_isolation);
}
if input.enable_inter_container_traffic_encryption {
object
.key("EnableInterContainerTrafficEncryption")
.boolean(input.enable_inter_container_traffic_encryption);
}
if input.enable_managed_spot_training {
object
.key("EnableManagedSpotTraining")
.boolean(input.enable_managed_spot_training);
}
if let Some(var_644) = &input.checkpoint_config {
#[allow(unused_mut)]
let mut object_645 = object.key("CheckpointConfig").start_object();
crate::json_ser::serialize_structure_crate_model_checkpoint_config(
&mut object_645,
var_644,
)?;
object_645.finish();
}
if let Some(var_646) = &input.debug_hook_config {
#[allow(unused_mut)]
let mut object_647 = object.key("DebugHookConfig").start_object();
crate::json_ser::serialize_structure_crate_model_debug_hook_config(
&mut object_647,
var_646,
)?;
object_647.finish();
}
if let Some(var_648) = &input.debug_rule_configurations {
let mut array_649 = object.key("DebugRuleConfigurations").start_array();
for item_650 in var_648 {
{
#[allow(unused_mut)]
let mut object_651 = array_649.value().start_object();
crate::json_ser::serialize_structure_crate_model_debug_rule_configuration(
&mut object_651,
item_650,
)?;
object_651.finish();
}
}
array_649.finish();
}
if let Some(var_652) = &input.tensor_board_output_config {
#[allow(unused_mut)]
let mut object_653 = object.key("TensorBoardOutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_tensor_board_output_config(
&mut object_653,
var_652,
)?;
object_653.finish();
}
if let Some(var_654) = &input.experiment_config {
#[allow(unused_mut)]
let mut object_655 = object.key("ExperimentConfig").start_object();
crate::json_ser::serialize_structure_crate_model_experiment_config(
&mut object_655,
var_654,
)?;
object_655.finish();
}
if let Some(var_656) = &input.profiler_config {
#[allow(unused_mut)]
let mut object_657 = object.key("ProfilerConfig").start_object();
crate::json_ser::serialize_structure_crate_model_profiler_config(&mut object_657, var_656)?;
object_657.finish();
}
if let Some(var_658) = &input.profiler_rule_configurations {
let mut array_659 = object.key("ProfilerRuleConfigurations").start_array();
for item_660 in var_658 {
{
#[allow(unused_mut)]
let mut object_661 = array_659.value().start_object();
crate::json_ser::serialize_structure_crate_model_profiler_rule_configuration(
&mut object_661,
item_660,
)?;
object_661.finish();
}
}
array_659.finish();
}
if let Some(var_662) = &input.environment {
#[allow(unused_mut)]
let mut object_663 = object.key("Environment").start_object();
for (key_664, value_665) in var_662 {
{
object_663.key(key_664.as_str()).string(value_665.as_str());
}
}
object_663.finish();
}
if let Some(var_666) = &input.retry_strategy {
#[allow(unused_mut)]
let mut object_667 = object.key("RetryStrategy").start_object();
crate::json_ser::serialize_structure_crate_model_retry_strategy(&mut object_667, var_666)?;
object_667.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_transform_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTransformJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_668) = &input.transform_job_name {
object.key("TransformJobName").string(var_668.as_str());
}
if let Some(var_669) = &input.model_name {
object.key("ModelName").string(var_669.as_str());
}
if let Some(var_670) = &input.max_concurrent_transforms {
object.key("MaxConcurrentTransforms").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_670).into()),
);
}
if let Some(var_671) = &input.model_client_config {
#[allow(unused_mut)]
let mut object_672 = object.key("ModelClientConfig").start_object();
crate::json_ser::serialize_structure_crate_model_model_client_config(
&mut object_672,
var_671,
)?;
object_672.finish();
}
if let Some(var_673) = &input.max_payload_in_mb {
object.key("MaxPayloadInMB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_673).into()),
);
}
if let Some(var_674) = &input.batch_strategy {
object.key("BatchStrategy").string(var_674.as_str());
}
if let Some(var_675) = &input.environment {
#[allow(unused_mut)]
let mut object_676 = object.key("Environment").start_object();
for (key_677, value_678) in var_675 {
{
object_676.key(key_677.as_str()).string(value_678.as_str());
}
}
object_676.finish();
}
if let Some(var_679) = &input.transform_input {
#[allow(unused_mut)]
let mut object_680 = object.key("TransformInput").start_object();
crate::json_ser::serialize_structure_crate_model_transform_input(&mut object_680, var_679)?;
object_680.finish();
}
if let Some(var_681) = &input.transform_output {
#[allow(unused_mut)]
let mut object_682 = object.key("TransformOutput").start_object();
crate::json_ser::serialize_structure_crate_model_transform_output(
&mut object_682,
var_681,
)?;
object_682.finish();
}
if let Some(var_683) = &input.data_capture_config {
#[allow(unused_mut)]
let mut object_684 = object.key("DataCaptureConfig").start_object();
crate::json_ser::serialize_structure_crate_model_batch_data_capture_config(
&mut object_684,
var_683,
)?;
object_684.finish();
}
if let Some(var_685) = &input.transform_resources {
#[allow(unused_mut)]
let mut object_686 = object.key("TransformResources").start_object();
crate::json_ser::serialize_structure_crate_model_transform_resources(
&mut object_686,
var_685,
)?;
object_686.finish();
}
if let Some(var_687) = &input.data_processing {
#[allow(unused_mut)]
let mut object_688 = object.key("DataProcessing").start_object();
crate::json_ser::serialize_structure_crate_model_data_processing(&mut object_688, var_687)?;
object_688.finish();
}
if let Some(var_689) = &input.tags {
let mut array_690 = object.key("Tags").start_array();
for item_691 in var_689 {
{
#[allow(unused_mut)]
let mut object_692 = array_690.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_692, item_691)?;
object_692.finish();
}
}
array_690.finish();
}
if let Some(var_693) = &input.experiment_config {
#[allow(unused_mut)]
let mut object_694 = object.key("ExperimentConfig").start_object();
crate::json_ser::serialize_structure_crate_model_experiment_config(
&mut object_694,
var_693,
)?;
object_694.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_trial_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTrialInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_695) = &input.trial_name {
object.key("TrialName").string(var_695.as_str());
}
if let Some(var_696) = &input.display_name {
object.key("DisplayName").string(var_696.as_str());
}
if let Some(var_697) = &input.experiment_name {
object.key("ExperimentName").string(var_697.as_str());
}
if let Some(var_698) = &input.metadata_properties {
#[allow(unused_mut)]
let mut object_699 = object.key("MetadataProperties").start_object();
crate::json_ser::serialize_structure_crate_model_metadata_properties(
&mut object_699,
var_698,
)?;
object_699.finish();
}
if let Some(var_700) = &input.tags {
let mut array_701 = object.key("Tags").start_array();
for item_702 in var_700 {
{
#[allow(unused_mut)]
let mut object_703 = array_701.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_703, item_702)?;
object_703.finish();
}
}
array_701.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_trial_component_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTrialComponentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_704) = &input.trial_component_name {
object.key("TrialComponentName").string(var_704.as_str());
}
if let Some(var_705) = &input.display_name {
object.key("DisplayName").string(var_705.as_str());
}
if let Some(var_706) = &input.status {
#[allow(unused_mut)]
let mut object_707 = object.key("Status").start_object();
crate::json_ser::serialize_structure_crate_model_trial_component_status(
&mut object_707,
var_706,
)?;
object_707.finish();
}
if let Some(var_708) = &input.start_time {
object
.key("StartTime")
.date_time(var_708, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_709) = &input.end_time {
object
.key("EndTime")
.date_time(var_709, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_710) = &input.parameters {
#[allow(unused_mut)]
let mut object_711 = object.key("Parameters").start_object();
for (key_712, value_713) in var_710 {
{
#[allow(unused_mut)]
let mut object_714 = object_711.key(key_712.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_trial_component_parameter_value(
&mut object_714,
value_713,
)?;
object_714.finish();
}
}
object_711.finish();
}
if let Some(var_715) = &input.input_artifacts {
#[allow(unused_mut)]
let mut object_716 = object.key("InputArtifacts").start_object();
for (key_717, value_718) in var_715 {
{
#[allow(unused_mut)]
let mut object_719 = object_716.key(key_717.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_trial_component_artifact(
&mut object_719,
value_718,
)?;
object_719.finish();
}
}
object_716.finish();
}
if let Some(var_720) = &input.output_artifacts {
#[allow(unused_mut)]
let mut object_721 = object.key("OutputArtifacts").start_object();
for (key_722, value_723) in var_720 {
{
#[allow(unused_mut)]
let mut object_724 = object_721.key(key_722.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_trial_component_artifact(
&mut object_724,
value_723,
)?;
object_724.finish();
}
}
object_721.finish();
}
if let Some(var_725) = &input.metadata_properties {
#[allow(unused_mut)]
let mut object_726 = object.key("MetadataProperties").start_object();
crate::json_ser::serialize_structure_crate_model_metadata_properties(
&mut object_726,
var_725,
)?;
object_726.finish();
}
if let Some(var_727) = &input.tags {
let mut array_728 = object.key("Tags").start_array();
for item_729 in var_727 {
{
#[allow(unused_mut)]
let mut object_730 = array_728.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_730, item_729)?;
object_730.finish();
}
}
array_728.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_user_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateUserProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_731) = &input.domain_id {
object.key("DomainId").string(var_731.as_str());
}
if let Some(var_732) = &input.user_profile_name {
object.key("UserProfileName").string(var_732.as_str());
}
if let Some(var_733) = &input.single_sign_on_user_identifier {
object
.key("SingleSignOnUserIdentifier")
.string(var_733.as_str());
}
if let Some(var_734) = &input.single_sign_on_user_value {
object.key("SingleSignOnUserValue").string(var_734.as_str());
}
if let Some(var_735) = &input.tags {
let mut array_736 = object.key("Tags").start_array();
for item_737 in var_735 {
{
#[allow(unused_mut)]
let mut object_738 = array_736.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_738, item_737)?;
object_738.finish();
}
}
array_736.finish();
}
if let Some(var_739) = &input.user_settings {
#[allow(unused_mut)]
let mut object_740 = object.key("UserSettings").start_object();
crate::json_ser::serialize_structure_crate_model_user_settings(&mut object_740, var_739)?;
object_740.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_workforce_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateWorkforceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_741) = &input.cognito_config {
#[allow(unused_mut)]
let mut object_742 = object.key("CognitoConfig").start_object();
crate::json_ser::serialize_structure_crate_model_cognito_config(&mut object_742, var_741)?;
object_742.finish();
}
if let Some(var_743) = &input.oidc_config {
#[allow(unused_mut)]
let mut object_744 = object.key("OidcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_oidc_config(&mut object_744, var_743)?;
object_744.finish();
}
if let Some(var_745) = &input.source_ip_config {
#[allow(unused_mut)]
let mut object_746 = object.key("SourceIpConfig").start_object();
crate::json_ser::serialize_structure_crate_model_source_ip_config(
&mut object_746,
var_745,
)?;
object_746.finish();
}
if let Some(var_747) = &input.workforce_name {
object.key("WorkforceName").string(var_747.as_str());
}
if let Some(var_748) = &input.tags {
let mut array_749 = object.key("Tags").start_array();
for item_750 in var_748 {
{
#[allow(unused_mut)]
let mut object_751 = array_749.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_751, item_750)?;
object_751.finish();
}
}
array_749.finish();
}
if let Some(var_752) = &input.workforce_vpc_config {
#[allow(unused_mut)]
let mut object_753 = object.key("WorkforceVpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_workforce_vpc_config_request(
&mut object_753,
var_752,
)?;
object_753.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_workteam_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateWorkteamInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_754) = &input.workteam_name {
object.key("WorkteamName").string(var_754.as_str());
}
if let Some(var_755) = &input.workforce_name {
object.key("WorkforceName").string(var_755.as_str());
}
if let Some(var_756) = &input.member_definitions {
let mut array_757 = object.key("MemberDefinitions").start_array();
for item_758 in var_756 {
{
#[allow(unused_mut)]
let mut object_759 = array_757.value().start_object();
crate::json_ser::serialize_structure_crate_model_member_definition(
&mut object_759,
item_758,
)?;
object_759.finish();
}
}
array_757.finish();
}
if let Some(var_760) = &input.description {
object.key("Description").string(var_760.as_str());
}
if let Some(var_761) = &input.notification_configuration {
#[allow(unused_mut)]
let mut object_762 = object.key("NotificationConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_notification_configuration(
&mut object_762,
var_761,
)?;
object_762.finish();
}
if let Some(var_763) = &input.tags {
let mut array_764 = object.key("Tags").start_array();
for item_765 in var_763 {
{
#[allow(unused_mut)]
let mut object_766 = array_764.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_766, item_765)?;
object_766.finish();
}
}
array_764.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_action_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteActionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_767) = &input.action_name {
object.key("ActionName").string(var_767.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_algorithm_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAlgorithmInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_768) = &input.algorithm_name {
object.key("AlgorithmName").string(var_768.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_app_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAppInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_769) = &input.domain_id {
object.key("DomainId").string(var_769.as_str());
}
if let Some(var_770) = &input.user_profile_name {
object.key("UserProfileName").string(var_770.as_str());
}
if let Some(var_771) = &input.app_type {
object.key("AppType").string(var_771.as_str());
}
if let Some(var_772) = &input.app_name {
object.key("AppName").string(var_772.as_str());
}
if let Some(var_773) = &input.space_name {
object.key("SpaceName").string(var_773.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_app_image_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAppImageConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_774) = &input.app_image_config_name {
object.key("AppImageConfigName").string(var_774.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_artifact_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteArtifactInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_775) = &input.artifact_arn {
object.key("ArtifactArn").string(var_775.as_str());
}
if let Some(var_776) = &input.source {
#[allow(unused_mut)]
let mut object_777 = object.key("Source").start_object();
crate::json_ser::serialize_structure_crate_model_artifact_source(&mut object_777, var_776)?;
object_777.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_association_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAssociationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_778) = &input.source_arn {
object.key("SourceArn").string(var_778.as_str());
}
if let Some(var_779) = &input.destination_arn {
object.key("DestinationArn").string(var_779.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_code_repository_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteCodeRepositoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_780) = &input.code_repository_name {
object.key("CodeRepositoryName").string(var_780.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_context_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteContextInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_781) = &input.context_name {
object.key("ContextName").string(var_781.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_data_quality_job_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDataQualityJobDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_782) = &input.job_definition_name {
object.key("JobDefinitionName").string(var_782.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_device_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDeviceFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_783) = &input.device_fleet_name {
object.key("DeviceFleetName").string(var_783.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_domain_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDomainInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_784) = &input.domain_id {
object.key("DomainId").string(var_784.as_str());
}
if let Some(var_785) = &input.retention_policy {
#[allow(unused_mut)]
let mut object_786 = object.key("RetentionPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_retention_policy(
&mut object_786,
var_785,
)?;
object_786.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_edge_deployment_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteEdgeDeploymentPlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_787) = &input.edge_deployment_plan_name {
object
.key("EdgeDeploymentPlanName")
.string(var_787.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_edge_deployment_stage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteEdgeDeploymentStageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_788) = &input.edge_deployment_plan_name {
object
.key("EdgeDeploymentPlanName")
.string(var_788.as_str());
}
if let Some(var_789) = &input.stage_name {
object.key("StageName").string(var_789.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_790) = &input.endpoint_name {
object.key("EndpointName").string(var_790.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_endpoint_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteEndpointConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_791) = &input.endpoint_config_name {
object.key("EndpointConfigName").string(var_791.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_experiment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteExperimentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_792) = &input.experiment_name {
object.key("ExperimentName").string(var_792.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_feature_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteFeatureGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_793) = &input.feature_group_name {
object.key("FeatureGroupName").string(var_793.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_flow_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteFlowDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_794) = &input.flow_definition_name {
object.key("FlowDefinitionName").string(var_794.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_hub_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteHubInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_795) = &input.hub_name {
object.key("HubName").string(var_795.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_hub_content_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteHubContentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_796) = &input.hub_name {
object.key("HubName").string(var_796.as_str());
}
if let Some(var_797) = &input.hub_content_type {
object.key("HubContentType").string(var_797.as_str());
}
if let Some(var_798) = &input.hub_content_name {
object.key("HubContentName").string(var_798.as_str());
}
if let Some(var_799) = &input.hub_content_version {
object.key("HubContentVersion").string(var_799.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_human_task_ui_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteHumanTaskUiInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_800) = &input.human_task_ui_name {
object.key("HumanTaskUiName").string(var_800.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_image_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteImageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_801) = &input.image_name {
object.key("ImageName").string(var_801.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_image_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteImageVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_802) = &input.image_name {
object.key("ImageName").string(var_802.as_str());
}
if let Some(var_803) = &input.version {
object.key("Version").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_803).into()),
);
}
if let Some(var_804) = &input.alias {
object.key("Alias").string(var_804.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_inference_experiment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteInferenceExperimentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_805) = &input.name {
object.key("Name").string(var_805.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_806) = &input.model_name {
object.key("ModelName").string(var_806.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_model_bias_job_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteModelBiasJobDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_807) = &input.job_definition_name {
object.key("JobDefinitionName").string(var_807.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_model_card_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteModelCardInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_808) = &input.model_card_name {
object.key("ModelCardName").string(var_808.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_model_explainability_job_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteModelExplainabilityJobDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_809) = &input.job_definition_name {
object.key("JobDefinitionName").string(var_809.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_model_package_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteModelPackageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_810) = &input.model_package_name {
object.key("ModelPackageName").string(var_810.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_model_package_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteModelPackageGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_811) = &input.model_package_group_name {
object.key("ModelPackageGroupName").string(var_811.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_model_package_group_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteModelPackageGroupPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_812) = &input.model_package_group_name {
object.key("ModelPackageGroupName").string(var_812.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_model_quality_job_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteModelQualityJobDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_813) = &input.job_definition_name {
object.key("JobDefinitionName").string(var_813.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_monitoring_schedule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteMonitoringScheduleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_814) = &input.monitoring_schedule_name {
object
.key("MonitoringScheduleName")
.string(var_814.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_notebook_instance_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteNotebookInstanceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_815) = &input.notebook_instance_name {
object.key("NotebookInstanceName").string(var_815.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_notebook_instance_lifecycle_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteNotebookInstanceLifecycleConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_816) = &input.notebook_instance_lifecycle_config_name {
object
.key("NotebookInstanceLifecycleConfigName")
.string(var_816.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_pipeline_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeletePipelineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_817) = &input.pipeline_name {
object.key("PipelineName").string(var_817.as_str());
}
if let Some(var_818) = &input.client_request_token {
object.key("ClientRequestToken").string(var_818.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_project_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteProjectInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_819) = &input.project_name {
object.key("ProjectName").string(var_819.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_space_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteSpaceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_820) = &input.domain_id {
object.key("DomainId").string(var_820.as_str());
}
if let Some(var_821) = &input.space_name {
object.key("SpaceName").string(var_821.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_studio_lifecycle_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteStudioLifecycleConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_822) = &input.studio_lifecycle_config_name {
object
.key("StudioLifecycleConfigName")
.string(var_822.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_823) = &input.resource_arn {
object.key("ResourceArn").string(var_823.as_str());
}
if let Some(var_824) = &input.tag_keys {
let mut array_825 = object.key("TagKeys").start_array();
for item_826 in var_824 {
{
array_825.value().string(item_826.as_str());
}
}
array_825.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_trial_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteTrialInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_827) = &input.trial_name {
object.key("TrialName").string(var_827.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_trial_component_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteTrialComponentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_828) = &input.trial_component_name {
object.key("TrialComponentName").string(var_828.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_user_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteUserProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_829) = &input.domain_id {
object.key("DomainId").string(var_829.as_str());
}
if let Some(var_830) = &input.user_profile_name {
object.key("UserProfileName").string(var_830.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_workforce_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteWorkforceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_831) = &input.workforce_name {
object.key("WorkforceName").string(var_831.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_workteam_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteWorkteamInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_832) = &input.workteam_name {
object.key("WorkteamName").string(var_832.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_deregister_devices_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeregisterDevicesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_833) = &input.device_fleet_name {
object.key("DeviceFleetName").string(var_833.as_str());
}
if let Some(var_834) = &input.device_names {
let mut array_835 = object.key("DeviceNames").start_array();
for item_836 in var_834 {
{
array_835.value().string(item_836.as_str());
}
}
array_835.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_action_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeActionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_837) = &input.action_name {
object.key("ActionName").string(var_837.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_algorithm_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAlgorithmInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_838) = &input.algorithm_name {
object.key("AlgorithmName").string(var_838.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_app_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAppInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_839) = &input.domain_id {
object.key("DomainId").string(var_839.as_str());
}
if let Some(var_840) = &input.user_profile_name {
object.key("UserProfileName").string(var_840.as_str());
}
if let Some(var_841) = &input.app_type {
object.key("AppType").string(var_841.as_str());
}
if let Some(var_842) = &input.app_name {
object.key("AppName").string(var_842.as_str());
}
if let Some(var_843) = &input.space_name {
object.key("SpaceName").string(var_843.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_app_image_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAppImageConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_844) = &input.app_image_config_name {
object.key("AppImageConfigName").string(var_844.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_artifact_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeArtifactInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_845) = &input.artifact_arn {
object.key("ArtifactArn").string(var_845.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_auto_ml_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAutoMlJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_846) = &input.auto_ml_job_name {
object.key("AutoMLJobName").string(var_846.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_code_repository_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeCodeRepositoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_847) = &input.code_repository_name {
object.key("CodeRepositoryName").string(var_847.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_compilation_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeCompilationJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_848) = &input.compilation_job_name {
object.key("CompilationJobName").string(var_848.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_context_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeContextInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_849) = &input.context_name {
object.key("ContextName").string(var_849.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_data_quality_job_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDataQualityJobDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_850) = &input.job_definition_name {
object.key("JobDefinitionName").string(var_850.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_device_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDeviceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_851) = &input.next_token {
object.key("NextToken").string(var_851.as_str());
}
if let Some(var_852) = &input.device_name {
object.key("DeviceName").string(var_852.as_str());
}
if let Some(var_853) = &input.device_fleet_name {
object.key("DeviceFleetName").string(var_853.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_device_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDeviceFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_854) = &input.device_fleet_name {
object.key("DeviceFleetName").string(var_854.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_domain_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDomainInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_855) = &input.domain_id {
object.key("DomainId").string(var_855.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_edge_deployment_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEdgeDeploymentPlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_856) = &input.edge_deployment_plan_name {
object
.key("EdgeDeploymentPlanName")
.string(var_856.as_str());
}
if let Some(var_857) = &input.next_token {
object.key("NextToken").string(var_857.as_str());
}
if input.max_results != 0 {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_edge_packaging_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEdgePackagingJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_858) = &input.edge_packaging_job_name {
object.key("EdgePackagingJobName").string(var_858.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_859) = &input.endpoint_name {
object.key("EndpointName").string(var_859.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_endpoint_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEndpointConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_860) = &input.endpoint_config_name {
object.key("EndpointConfigName").string(var_860.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_experiment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeExperimentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_861) = &input.experiment_name {
object.key("ExperimentName").string(var_861.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_feature_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFeatureGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_862) = &input.feature_group_name {
object.key("FeatureGroupName").string(var_862.as_str());
}
if let Some(var_863) = &input.next_token {
object.key("NextToken").string(var_863.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_feature_metadata_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFeatureMetadataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_864) = &input.feature_group_name {
object.key("FeatureGroupName").string(var_864.as_str());
}
if let Some(var_865) = &input.feature_name {
object.key("FeatureName").string(var_865.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_flow_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFlowDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_866) = &input.flow_definition_name {
object.key("FlowDefinitionName").string(var_866.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_hub_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeHubInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_867) = &input.hub_name {
object.key("HubName").string(var_867.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_hub_content_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeHubContentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_868) = &input.hub_name {
object.key("HubName").string(var_868.as_str());
}
if let Some(var_869) = &input.hub_content_type {
object.key("HubContentType").string(var_869.as_str());
}
if let Some(var_870) = &input.hub_content_name {
object.key("HubContentName").string(var_870.as_str());
}
if let Some(var_871) = &input.hub_content_version {
object.key("HubContentVersion").string(var_871.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_human_task_ui_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeHumanTaskUiInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_872) = &input.human_task_ui_name {
object.key("HumanTaskUiName").string(var_872.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_hyper_parameter_tuning_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeHyperParameterTuningJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_873) = &input.hyper_parameter_tuning_job_name {
object
.key("HyperParameterTuningJobName")
.string(var_873.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_image_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeImageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_874) = &input.image_name {
object.key("ImageName").string(var_874.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_image_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeImageVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_875) = &input.image_name {
object.key("ImageName").string(var_875.as_str());
}
if let Some(var_876) = &input.version {
object.key("Version").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_876).into()),
);
}
if let Some(var_877) = &input.alias {
object.key("Alias").string(var_877.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_inference_experiment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeInferenceExperimentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_878) = &input.name {
object.key("Name").string(var_878.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_inference_recommendations_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeInferenceRecommendationsJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_879) = &input.job_name {
object.key("JobName").string(var_879.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_labeling_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeLabelingJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_880) = &input.labeling_job_name {
object.key("LabelingJobName").string(var_880.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_lineage_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeLineageGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_881) = &input.lineage_group_name {
object.key("LineageGroupName").string(var_881.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_882) = &input.model_name {
object.key("ModelName").string(var_882.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_model_bias_job_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeModelBiasJobDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_883) = &input.job_definition_name {
object.key("JobDefinitionName").string(var_883.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_model_card_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeModelCardInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_884) = &input.model_card_name {
object.key("ModelCardName").string(var_884.as_str());
}
if input.model_card_version != 0 {
object.key("ModelCardVersion").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.model_card_version).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_model_card_export_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeModelCardExportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_885) = &input.model_card_export_job_arn {
object.key("ModelCardExportJobArn").string(var_885.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_model_explainability_job_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeModelExplainabilityJobDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_886) = &input.job_definition_name {
object.key("JobDefinitionName").string(var_886.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_model_package_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeModelPackageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_887) = &input.model_package_name {
object.key("ModelPackageName").string(var_887.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_model_package_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeModelPackageGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_888) = &input.model_package_group_name {
object.key("ModelPackageGroupName").string(var_888.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_model_quality_job_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeModelQualityJobDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_889) = &input.job_definition_name {
object.key("JobDefinitionName").string(var_889.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_monitoring_schedule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeMonitoringScheduleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_890) = &input.monitoring_schedule_name {
object
.key("MonitoringScheduleName")
.string(var_890.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_notebook_instance_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeNotebookInstanceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_891) = &input.notebook_instance_name {
object.key("NotebookInstanceName").string(var_891.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_notebook_instance_lifecycle_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeNotebookInstanceLifecycleConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_892) = &input.notebook_instance_lifecycle_config_name {
object
.key("NotebookInstanceLifecycleConfigName")
.string(var_892.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_pipeline_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribePipelineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_893) = &input.pipeline_name {
object.key("PipelineName").string(var_893.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_pipeline_definition_for_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribePipelineDefinitionForExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_894) = &input.pipeline_execution_arn {
object.key("PipelineExecutionArn").string(var_894.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_pipeline_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribePipelineExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_895) = &input.pipeline_execution_arn {
object.key("PipelineExecutionArn").string(var_895.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_processing_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeProcessingJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_896) = &input.processing_job_name {
object.key("ProcessingJobName").string(var_896.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_project_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeProjectInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_897) = &input.project_name {
object.key("ProjectName").string(var_897.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_space_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeSpaceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_898) = &input.domain_id {
object.key("DomainId").string(var_898.as_str());
}
if let Some(var_899) = &input.space_name {
object.key("SpaceName").string(var_899.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_studio_lifecycle_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeStudioLifecycleConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_900) = &input.studio_lifecycle_config_name {
object
.key("StudioLifecycleConfigName")
.string(var_900.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_subscribed_workteam_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeSubscribedWorkteamInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_901) = &input.workteam_arn {
object.key("WorkteamArn").string(var_901.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_training_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTrainingJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_902) = &input.training_job_name {
object.key("TrainingJobName").string(var_902.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_transform_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTransformJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_903) = &input.transform_job_name {
object.key("TransformJobName").string(var_903.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_trial_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTrialInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_904) = &input.trial_name {
object.key("TrialName").string(var_904.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_trial_component_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTrialComponentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_905) = &input.trial_component_name {
object.key("TrialComponentName").string(var_905.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_user_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeUserProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_906) = &input.domain_id {
object.key("DomainId").string(var_906.as_str());
}
if let Some(var_907) = &input.user_profile_name {
object.key("UserProfileName").string(var_907.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_workforce_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeWorkforceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_908) = &input.workforce_name {
object.key("WorkforceName").string(var_908.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_workteam_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeWorkteamInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_909) = &input.workteam_name {
object.key("WorkteamName").string(var_909.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_trial_component_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateTrialComponentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_910) = &input.trial_component_name {
object.key("TrialComponentName").string(var_910.as_str());
}
if let Some(var_911) = &input.trial_name {
object.key("TrialName").string(var_911.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_device_fleet_report_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetDeviceFleetReportInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_912) = &input.device_fleet_name {
object.key("DeviceFleetName").string(var_912.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_lineage_group_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetLineageGroupPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_913) = &input.lineage_group_name {
object.key("LineageGroupName").string(var_913.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_model_package_group_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetModelPackageGroupPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_914) = &input.model_package_group_name {
object.key("ModelPackageGroupName").string(var_914.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_search_suggestions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetSearchSuggestionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_915) = &input.resource {
object.key("Resource").string(var_915.as_str());
}
if let Some(var_916) = &input.suggestion_query {
#[allow(unused_mut)]
let mut object_917 = object.key("SuggestionQuery").start_object();
crate::json_ser::serialize_structure_crate_model_suggestion_query(
&mut object_917,
var_916,
)?;
object_917.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_import_hub_content_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ImportHubContentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_918) = &input.hub_content_name {
object.key("HubContentName").string(var_918.as_str());
}
if let Some(var_919) = &input.hub_content_version {
object.key("HubContentVersion").string(var_919.as_str());
}
if let Some(var_920) = &input.hub_content_type {
object.key("HubContentType").string(var_920.as_str());
}
if let Some(var_921) = &input.document_schema_version {
object.key("DocumentSchemaVersion").string(var_921.as_str());
}
if let Some(var_922) = &input.hub_name {
object.key("HubName").string(var_922.as_str());
}
if let Some(var_923) = &input.hub_content_display_name {
object.key("HubContentDisplayName").string(var_923.as_str());
}
if let Some(var_924) = &input.hub_content_description {
object.key("HubContentDescription").string(var_924.as_str());
}
if let Some(var_925) = &input.hub_content_markdown {
object.key("HubContentMarkdown").string(var_925.as_str());
}
if let Some(var_926) = &input.hub_content_document {
object.key("HubContentDocument").string(var_926.as_str());
}
if let Some(var_927) = &input.hub_content_search_keywords {
let mut array_928 = object.key("HubContentSearchKeywords").start_array();
for item_929 in var_927 {
{
array_928.value().string(item_929.as_str());
}
}
array_928.finish();
}
if let Some(var_930) = &input.tags {
let mut array_931 = object.key("Tags").start_array();
for item_932 in var_930 {
{
#[allow(unused_mut)]
let mut object_933 = array_931.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_933, item_932)?;
object_933.finish();
}
}
array_931.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_actions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListActionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_934) = &input.source_uri {
object.key("SourceUri").string(var_934.as_str());
}
if let Some(var_935) = &input.action_type {
object.key("ActionType").string(var_935.as_str());
}
if let Some(var_936) = &input.created_after {
object
.key("CreatedAfter")
.date_time(var_936, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_937) = &input.created_before {
object
.key("CreatedBefore")
.date_time(var_937, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_938) = &input.sort_by {
object.key("SortBy").string(var_938.as_str());
}
if let Some(var_939) = &input.sort_order {
object.key("SortOrder").string(var_939.as_str());
}
if let Some(var_940) = &input.next_token {
object.key("NextToken").string(var_940.as_str());
}
if let Some(var_941) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_941).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_algorithms_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAlgorithmsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_942) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_942, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_943) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_943, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_944) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_944).into()),
);
}
if let Some(var_945) = &input.name_contains {
object.key("NameContains").string(var_945.as_str());
}
if let Some(var_946) = &input.next_token {
object.key("NextToken").string(var_946.as_str());
}
if let Some(var_947) = &input.sort_by {
object.key("SortBy").string(var_947.as_str());
}
if let Some(var_948) = &input.sort_order {
object.key("SortOrder").string(var_948.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_aliases_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAliasesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_949) = &input.image_name {
object.key("ImageName").string(var_949.as_str());
}
if let Some(var_950) = &input.alias {
object.key("Alias").string(var_950.as_str());
}
if let Some(var_951) = &input.version {
object.key("Version").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_951).into()),
);
}
if let Some(var_952) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_952).into()),
);
}
if let Some(var_953) = &input.next_token {
object.key("NextToken").string(var_953.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_app_image_configs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAppImageConfigsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_954) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_954).into()),
);
}
if let Some(var_955) = &input.next_token {
object.key("NextToken").string(var_955.as_str());
}
if let Some(var_956) = &input.name_contains {
object.key("NameContains").string(var_956.as_str());
}
if let Some(var_957) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_957, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_958) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_958, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_959) = &input.modified_time_before {
object
.key("ModifiedTimeBefore")
.date_time(var_959, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_960) = &input.modified_time_after {
object
.key("ModifiedTimeAfter")
.date_time(var_960, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_961) = &input.sort_by {
object.key("SortBy").string(var_961.as_str());
}
if let Some(var_962) = &input.sort_order {
object.key("SortOrder").string(var_962.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_apps_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAppsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_963) = &input.next_token {
object.key("NextToken").string(var_963.as_str());
}
if let Some(var_964) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_964).into()),
);
}
if let Some(var_965) = &input.sort_order {
object.key("SortOrder").string(var_965.as_str());
}
if let Some(var_966) = &input.sort_by {
object.key("SortBy").string(var_966.as_str());
}
if let Some(var_967) = &input.domain_id_equals {
object.key("DomainIdEquals").string(var_967.as_str());
}
if let Some(var_968) = &input.user_profile_name_equals {
object.key("UserProfileNameEquals").string(var_968.as_str());
}
if let Some(var_969) = &input.space_name_equals {
object.key("SpaceNameEquals").string(var_969.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_artifacts_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListArtifactsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_970) = &input.source_uri {
object.key("SourceUri").string(var_970.as_str());
}
if let Some(var_971) = &input.artifact_type {
object.key("ArtifactType").string(var_971.as_str());
}
if let Some(var_972) = &input.created_after {
object
.key("CreatedAfter")
.date_time(var_972, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_973) = &input.created_before {
object
.key("CreatedBefore")
.date_time(var_973, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_974) = &input.sort_by {
object.key("SortBy").string(var_974.as_str());
}
if let Some(var_975) = &input.sort_order {
object.key("SortOrder").string(var_975.as_str());
}
if let Some(var_976) = &input.next_token {
object.key("NextToken").string(var_976.as_str());
}
if let Some(var_977) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_977).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_associations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAssociationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_978) = &input.source_arn {
object.key("SourceArn").string(var_978.as_str());
}
if let Some(var_979) = &input.destination_arn {
object.key("DestinationArn").string(var_979.as_str());
}
if let Some(var_980) = &input.source_type {
object.key("SourceType").string(var_980.as_str());
}
if let Some(var_981) = &input.destination_type {
object.key("DestinationType").string(var_981.as_str());
}
if let Some(var_982) = &input.association_type {
object.key("AssociationType").string(var_982.as_str());
}
if let Some(var_983) = &input.created_after {
object
.key("CreatedAfter")
.date_time(var_983, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_984) = &input.created_before {
object
.key("CreatedBefore")
.date_time(var_984, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_985) = &input.sort_by {
object.key("SortBy").string(var_985.as_str());
}
if let Some(var_986) = &input.sort_order {
object.key("SortOrder").string(var_986.as_str());
}
if let Some(var_987) = &input.next_token {
object.key("NextToken").string(var_987.as_str());
}
if let Some(var_988) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_988).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_auto_ml_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAutoMlJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_989) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_989, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_990) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_990, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_991) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_991, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_992) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_992, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_993) = &input.name_contains {
object.key("NameContains").string(var_993.as_str());
}
if let Some(var_994) = &input.status_equals {
object.key("StatusEquals").string(var_994.as_str());
}
if let Some(var_995) = &input.sort_order {
object.key("SortOrder").string(var_995.as_str());
}
if let Some(var_996) = &input.sort_by {
object.key("SortBy").string(var_996.as_str());
}
if let Some(var_997) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_997).into()),
);
}
if let Some(var_998) = &input.next_token {
object.key("NextToken").string(var_998.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_candidates_for_auto_ml_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListCandidatesForAutoMlJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_999) = &input.auto_ml_job_name {
object.key("AutoMLJobName").string(var_999.as_str());
}
if let Some(var_1000) = &input.status_equals {
object.key("StatusEquals").string(var_1000.as_str());
}
if let Some(var_1001) = &input.candidate_name_equals {
object.key("CandidateNameEquals").string(var_1001.as_str());
}
if let Some(var_1002) = &input.sort_order {
object.key("SortOrder").string(var_1002.as_str());
}
if let Some(var_1003) = &input.sort_by {
object.key("SortBy").string(var_1003.as_str());
}
if let Some(var_1004) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1004).into()),
);
}
if let Some(var_1005) = &input.next_token {
object.key("NextToken").string(var_1005.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_code_repositories_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListCodeRepositoriesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1006) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1006, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1007) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1007, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1008) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_1008, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1009) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_1009, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1010) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1010).into()),
);
}
if let Some(var_1011) = &input.name_contains {
object.key("NameContains").string(var_1011.as_str());
}
if let Some(var_1012) = &input.next_token {
object.key("NextToken").string(var_1012.as_str());
}
if let Some(var_1013) = &input.sort_by {
object.key("SortBy").string(var_1013.as_str());
}
if let Some(var_1014) = &input.sort_order {
object.key("SortOrder").string(var_1014.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_compilation_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListCompilationJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1015) = &input.next_token {
object.key("NextToken").string(var_1015.as_str());
}
if let Some(var_1016) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1016).into()),
);
}
if let Some(var_1017) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1017, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1018) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1018, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1019) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_1019, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1020) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_1020, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1021) = &input.name_contains {
object.key("NameContains").string(var_1021.as_str());
}
if let Some(var_1022) = &input.status_equals {
object.key("StatusEquals").string(var_1022.as_str());
}
if let Some(var_1023) = &input.sort_by {
object.key("SortBy").string(var_1023.as_str());
}
if let Some(var_1024) = &input.sort_order {
object.key("SortOrder").string(var_1024.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_contexts_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListContextsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1025) = &input.source_uri {
object.key("SourceUri").string(var_1025.as_str());
}
if let Some(var_1026) = &input.context_type {
object.key("ContextType").string(var_1026.as_str());
}
if let Some(var_1027) = &input.created_after {
object
.key("CreatedAfter")
.date_time(var_1027, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1028) = &input.created_before {
object
.key("CreatedBefore")
.date_time(var_1028, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1029) = &input.sort_by {
object.key("SortBy").string(var_1029.as_str());
}
if let Some(var_1030) = &input.sort_order {
object.key("SortOrder").string(var_1030.as_str());
}
if let Some(var_1031) = &input.next_token {
object.key("NextToken").string(var_1031.as_str());
}
if let Some(var_1032) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1032).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_data_quality_job_definitions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDataQualityJobDefinitionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1033) = &input.endpoint_name {
object.key("EndpointName").string(var_1033.as_str());
}
if let Some(var_1034) = &input.sort_by {
object.key("SortBy").string(var_1034.as_str());
}
if let Some(var_1035) = &input.sort_order {
object.key("SortOrder").string(var_1035.as_str());
}
if let Some(var_1036) = &input.next_token {
object.key("NextToken").string(var_1036.as_str());
}
if let Some(var_1037) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1037).into()),
);
}
if let Some(var_1038) = &input.name_contains {
object.key("NameContains").string(var_1038.as_str());
}
if let Some(var_1039) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1039, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1040) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1040, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_input_list_device_fleets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDeviceFleetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1041) = &input.next_token {
object.key("NextToken").string(var_1041.as_str());
}
if let Some(var_1042) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1042).into()),
);
}
if let Some(var_1043) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1043, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1044) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1044, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1045) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_1045, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1046) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_1046, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1047) = &input.name_contains {
object.key("NameContains").string(var_1047.as_str());
}
if let Some(var_1048) = &input.sort_by {
object.key("SortBy").string(var_1048.as_str());
}
if let Some(var_1049) = &input.sort_order {
object.key("SortOrder").string(var_1049.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_devices_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDevicesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1050) = &input.next_token {
object.key("NextToken").string(var_1050.as_str());
}
if let Some(var_1051) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1051).into()),
);
}
if let Some(var_1052) = &input.latest_heartbeat_after {
object
.key("LatestHeartbeatAfter")
.date_time(var_1052, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1053) = &input.model_name {
object.key("ModelName").string(var_1053.as_str());
}
if let Some(var_1054) = &input.device_fleet_name {
object.key("DeviceFleetName").string(var_1054.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_domains_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDomainsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1055) = &input.next_token {
object.key("NextToken").string(var_1055.as_str());
}
if let Some(var_1056) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1056).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_edge_deployment_plans_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListEdgeDeploymentPlansInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1057) = &input.next_token {
object.key("NextToken").string(var_1057.as_str());
}
if let Some(var_1058) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1058).into()),
);
}
if let Some(var_1059) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1059, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1060) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1060, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1061) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_1061, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1062) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_1062, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1063) = &input.name_contains {
object.key("NameContains").string(var_1063.as_str());
}
if let Some(var_1064) = &input.device_fleet_name_contains {
object
.key("DeviceFleetNameContains")
.string(var_1064.as_str());
}
if let Some(var_1065) = &input.sort_by {
object.key("SortBy").string(var_1065.as_str());
}
if let Some(var_1066) = &input.sort_order {
object.key("SortOrder").string(var_1066.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_edge_packaging_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListEdgePackagingJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1067) = &input.next_token {
object.key("NextToken").string(var_1067.as_str());
}
if let Some(var_1068) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1068).into()),
);
}
if let Some(var_1069) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1069, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1070) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1070, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1071) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_1071, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1072) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_1072, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1073) = &input.name_contains {
object.key("NameContains").string(var_1073.as_str());
}
if let Some(var_1074) = &input.model_name_contains {
object.key("ModelNameContains").string(var_1074.as_str());
}
if let Some(var_1075) = &input.status_equals {
object.key("StatusEquals").string(var_1075.as_str());
}
if let Some(var_1076) = &input.sort_by {
object.key("SortBy").string(var_1076.as_str());
}
if let Some(var_1077) = &input.sort_order {
object.key("SortOrder").string(var_1077.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_endpoint_configs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListEndpointConfigsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1078) = &input.sort_by {
object.key("SortBy").string(var_1078.as_str());
}
if let Some(var_1079) = &input.sort_order {
object.key("SortOrder").string(var_1079.as_str());
}
if let Some(var_1080) = &input.next_token {
object.key("NextToken").string(var_1080.as_str());
}
if let Some(var_1081) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1081).into()),
);
}
if let Some(var_1082) = &input.name_contains {
object.key("NameContains").string(var_1082.as_str());
}
if let Some(var_1083) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1083, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1084) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1084, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_input_list_endpoints_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListEndpointsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1085) = &input.sort_by {
object.key("SortBy").string(var_1085.as_str());
}
if let Some(var_1086) = &input.sort_order {
object.key("SortOrder").string(var_1086.as_str());
}
if let Some(var_1087) = &input.next_token {
object.key("NextToken").string(var_1087.as_str());
}
if let Some(var_1088) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1088).into()),
);
}
if let Some(var_1089) = &input.name_contains {
object.key("NameContains").string(var_1089.as_str());
}
if let Some(var_1090) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1090, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1091) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1091, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1092) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_1092, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1093) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_1093, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1094) = &input.status_equals {
object.key("StatusEquals").string(var_1094.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_experiments_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListExperimentsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1095) = &input.created_after {
object
.key("CreatedAfter")
.date_time(var_1095, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1096) = &input.created_before {
object
.key("CreatedBefore")
.date_time(var_1096, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1097) = &input.sort_by {
object.key("SortBy").string(var_1097.as_str());
}
if let Some(var_1098) = &input.sort_order {
object.key("SortOrder").string(var_1098.as_str());
}
if let Some(var_1099) = &input.next_token {
object.key("NextToken").string(var_1099.as_str());
}
if let Some(var_1100) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1100).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_feature_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFeatureGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1101) = &input.name_contains {
object.key("NameContains").string(var_1101.as_str());
}
if let Some(var_1102) = &input.feature_group_status_equals {
object
.key("FeatureGroupStatusEquals")
.string(var_1102.as_str());
}
if let Some(var_1103) = &input.offline_store_status_equals {
object
.key("OfflineStoreStatusEquals")
.string(var_1103.as_str());
}
if let Some(var_1104) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1104, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1105) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1105, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1106) = &input.sort_order {
object.key("SortOrder").string(var_1106.as_str());
}
if let Some(var_1107) = &input.sort_by {
object.key("SortBy").string(var_1107.as_str());
}
if let Some(var_1108) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1108).into()),
);
}
if let Some(var_1109) = &input.next_token {
object.key("NextToken").string(var_1109.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_flow_definitions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFlowDefinitionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1110) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1110, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1111) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1111, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1112) = &input.sort_order {
object.key("SortOrder").string(var_1112.as_str());
}
if let Some(var_1113) = &input.next_token {
object.key("NextToken").string(var_1113.as_str());
}
if let Some(var_1114) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1114).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_hub_contents_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListHubContentsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1115) = &input.hub_name {
object.key("HubName").string(var_1115.as_str());
}
if let Some(var_1116) = &input.hub_content_type {
object.key("HubContentType").string(var_1116.as_str());
}
if let Some(var_1117) = &input.name_contains {
object.key("NameContains").string(var_1117.as_str());
}
if let Some(var_1118) = &input.max_schema_version {
object.key("MaxSchemaVersion").string(var_1118.as_str());
}
if let Some(var_1119) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1119, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1120) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1120, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1121) = &input.sort_by {
object.key("SortBy").string(var_1121.as_str());
}
if let Some(var_1122) = &input.sort_order {
object.key("SortOrder").string(var_1122.as_str());
}
if let Some(var_1123) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1123).into()),
);
}
if let Some(var_1124) = &input.next_token {
object.key("NextToken").string(var_1124.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_hub_content_versions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListHubContentVersionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1125) = &input.hub_name {
object.key("HubName").string(var_1125.as_str());
}
if let Some(var_1126) = &input.hub_content_type {
object.key("HubContentType").string(var_1126.as_str());
}
if let Some(var_1127) = &input.hub_content_name {
object.key("HubContentName").string(var_1127.as_str());
}
if let Some(var_1128) = &input.min_version {
object.key("MinVersion").string(var_1128.as_str());
}
if let Some(var_1129) = &input.max_schema_version {
object.key("MaxSchemaVersion").string(var_1129.as_str());
}
if let Some(var_1130) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1130, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1131) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1131, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1132) = &input.sort_by {
object.key("SortBy").string(var_1132.as_str());
}
if let Some(var_1133) = &input.sort_order {
object.key("SortOrder").string(var_1133.as_str());
}
if let Some(var_1134) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1134).into()),
);
}
if let Some(var_1135) = &input.next_token {
object.key("NextToken").string(var_1135.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_hubs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListHubsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1136) = &input.name_contains {
object.key("NameContains").string(var_1136.as_str());
}
if let Some(var_1137) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1137, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1138) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1138, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1139) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_1139, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1140) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_1140, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1141) = &input.sort_by {
object.key("SortBy").string(var_1141.as_str());
}
if let Some(var_1142) = &input.sort_order {
object.key("SortOrder").string(var_1142.as_str());
}
if let Some(var_1143) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1143).into()),
);
}
if let Some(var_1144) = &input.next_token {
object.key("NextToken").string(var_1144.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_human_task_uis_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListHumanTaskUisInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1145) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1145, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1146) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1146, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1147) = &input.sort_order {
object.key("SortOrder").string(var_1147.as_str());
}
if let Some(var_1148) = &input.next_token {
object.key("NextToken").string(var_1148.as_str());
}
if let Some(var_1149) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1149).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_hyper_parameter_tuning_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListHyperParameterTuningJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1150) = &input.next_token {
object.key("NextToken").string(var_1150.as_str());
}
if let Some(var_1151) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1151).into()),
);
}
if let Some(var_1152) = &input.sort_by {
object.key("SortBy").string(var_1152.as_str());
}
if let Some(var_1153) = &input.sort_order {
object.key("SortOrder").string(var_1153.as_str());
}
if let Some(var_1154) = &input.name_contains {
object.key("NameContains").string(var_1154.as_str());
}
if let Some(var_1155) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1155, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1156) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1156, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1157) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_1157, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1158) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_1158, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1159) = &input.status_equals {
object.key("StatusEquals").string(var_1159.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_images_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListImagesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1160) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1160, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1161) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1161, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1162) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_1162, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1163) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_1163, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1164) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1164).into()),
);
}
if let Some(var_1165) = &input.name_contains {
object.key("NameContains").string(var_1165.as_str());
}
if let Some(var_1166) = &input.next_token {
object.key("NextToken").string(var_1166.as_str());
}
if let Some(var_1167) = &input.sort_by {
object.key("SortBy").string(var_1167.as_str());
}
if let Some(var_1168) = &input.sort_order {
object.key("SortOrder").string(var_1168.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_image_versions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListImageVersionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1169) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1169, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1170) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1170, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1171) = &input.image_name {
object.key("ImageName").string(var_1171.as_str());
}
if let Some(var_1172) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_1172, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1173) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_1173, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1174) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1174).into()),
);
}
if let Some(var_1175) = &input.next_token {
object.key("NextToken").string(var_1175.as_str());
}
if let Some(var_1176) = &input.sort_by {
object.key("SortBy").string(var_1176.as_str());
}
if let Some(var_1177) = &input.sort_order {
object.key("SortOrder").string(var_1177.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_inference_experiments_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListInferenceExperimentsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1178) = &input.name_contains {
object.key("NameContains").string(var_1178.as_str());
}
if let Some(var_1179) = &input.r#type {
object.key("Type").string(var_1179.as_str());
}
if let Some(var_1180) = &input.status_equals {
object.key("StatusEquals").string(var_1180.as_str());
}
if let Some(var_1181) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1181, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1182) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1182, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1183) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_1183, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1184) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_1184, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1185) = &input.sort_by {
object.key("SortBy").string(var_1185.as_str());
}
if let Some(var_1186) = &input.sort_order {
object.key("SortOrder").string(var_1186.as_str());
}
if let Some(var_1187) = &input.next_token {
object.key("NextToken").string(var_1187.as_str());
}
if let Some(var_1188) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1188).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_inference_recommendations_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListInferenceRecommendationsJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1189) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1189, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1190) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1190, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1191) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_1191, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1192) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_1192, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1193) = &input.name_contains {
object.key("NameContains").string(var_1193.as_str());
}
if let Some(var_1194) = &input.status_equals {
object.key("StatusEquals").string(var_1194.as_str());
}
if let Some(var_1195) = &input.sort_by {
object.key("SortBy").string(var_1195.as_str());
}
if let Some(var_1196) = &input.sort_order {
object.key("SortOrder").string(var_1196.as_str());
}
if let Some(var_1197) = &input.next_token {
object.key("NextToken").string(var_1197.as_str());
}
if let Some(var_1198) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1198).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_inference_recommendations_job_steps_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListInferenceRecommendationsJobStepsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1199) = &input.job_name {
object.key("JobName").string(var_1199.as_str());
}
if let Some(var_1200) = &input.status {
object.key("Status").string(var_1200.as_str());
}
if let Some(var_1201) = &input.step_type {
object.key("StepType").string(var_1201.as_str());
}
if let Some(var_1202) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1202).into()),
);
}
if let Some(var_1203) = &input.next_token {
object.key("NextToken").string(var_1203.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_labeling_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListLabelingJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1204) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1204, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1205) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1205, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1206) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_1206, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1207) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_1207, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1208) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1208).into()),
);
}
if let Some(var_1209) = &input.next_token {
object.key("NextToken").string(var_1209.as_str());
}
if let Some(var_1210) = &input.name_contains {
object.key("NameContains").string(var_1210.as_str());
}
if let Some(var_1211) = &input.sort_by {
object.key("SortBy").string(var_1211.as_str());
}
if let Some(var_1212) = &input.sort_order {
object.key("SortOrder").string(var_1212.as_str());
}
if let Some(var_1213) = &input.status_equals {
object.key("StatusEquals").string(var_1213.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_labeling_jobs_for_workteam_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListLabelingJobsForWorkteamInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1214) = &input.workteam_arn {
object.key("WorkteamArn").string(var_1214.as_str());
}
if let Some(var_1215) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1215).into()),
);
}
if let Some(var_1216) = &input.next_token {
object.key("NextToken").string(var_1216.as_str());
}
if let Some(var_1217) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1217, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1218) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1218, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1219) = &input.job_reference_code_contains {
object
.key("JobReferenceCodeContains")
.string(var_1219.as_str());
}
if let Some(var_1220) = &input.sort_by {
object.key("SortBy").string(var_1220.as_str());
}
if let Some(var_1221) = &input.sort_order {
object.key("SortOrder").string(var_1221.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_lineage_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListLineageGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1222) = &input.created_after {
object
.key("CreatedAfter")
.date_time(var_1222, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1223) = &input.created_before {
object
.key("CreatedBefore")
.date_time(var_1223, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1224) = &input.sort_by {
object.key("SortBy").string(var_1224.as_str());
}
if let Some(var_1225) = &input.sort_order {
object.key("SortOrder").string(var_1225.as_str());
}
if let Some(var_1226) = &input.next_token {
object.key("NextToken").string(var_1226.as_str());
}
if let Some(var_1227) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1227).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_model_bias_job_definitions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListModelBiasJobDefinitionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1228) = &input.endpoint_name {
object.key("EndpointName").string(var_1228.as_str());
}
if let Some(var_1229) = &input.sort_by {
object.key("SortBy").string(var_1229.as_str());
}
if let Some(var_1230) = &input.sort_order {
object.key("SortOrder").string(var_1230.as_str());
}
if let Some(var_1231) = &input.next_token {
object.key("NextToken").string(var_1231.as_str());
}
if let Some(var_1232) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1232).into()),
);
}
if let Some(var_1233) = &input.name_contains {
object.key("NameContains").string(var_1233.as_str());
}
if let Some(var_1234) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1234, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1235) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1235, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_input_list_model_card_export_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListModelCardExportJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1236) = &input.model_card_name {
object.key("ModelCardName").string(var_1236.as_str());
}
if input.model_card_version != 0 {
object.key("ModelCardVersion").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.model_card_version).into()),
);
}
if let Some(var_1237) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1237, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1238) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1238, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1239) = &input.model_card_export_job_name_contains {
object
.key("ModelCardExportJobNameContains")
.string(var_1239.as_str());
}
if let Some(var_1240) = &input.status_equals {
object.key("StatusEquals").string(var_1240.as_str());
}
if let Some(var_1241) = &input.sort_by {
object.key("SortBy").string(var_1241.as_str());
}
if let Some(var_1242) = &input.sort_order {
object.key("SortOrder").string(var_1242.as_str());
}
if let Some(var_1243) = &input.next_token {
object.key("NextToken").string(var_1243.as_str());
}
if let Some(var_1244) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1244).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_model_cards_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListModelCardsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1245) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1245, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1246) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1246, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1247) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1247).into()),
);
}
if let Some(var_1248) = &input.name_contains {
object.key("NameContains").string(var_1248.as_str());
}
if let Some(var_1249) = &input.model_card_status {
object.key("ModelCardStatus").string(var_1249.as_str());
}
if let Some(var_1250) = &input.next_token {
object.key("NextToken").string(var_1250.as_str());
}
if let Some(var_1251) = &input.sort_by {
object.key("SortBy").string(var_1251.as_str());
}
if let Some(var_1252) = &input.sort_order {
object.key("SortOrder").string(var_1252.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_model_card_versions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListModelCardVersionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1253) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1253, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1254) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1254, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1255) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1255).into()),
);
}
if let Some(var_1256) = &input.model_card_name {
object.key("ModelCardName").string(var_1256.as_str());
}
if let Some(var_1257) = &input.model_card_status {
object.key("ModelCardStatus").string(var_1257.as_str());
}
if let Some(var_1258) = &input.next_token {
object.key("NextToken").string(var_1258.as_str());
}
if let Some(var_1259) = &input.sort_by {
object.key("SortBy").string(var_1259.as_str());
}
if let Some(var_1260) = &input.sort_order {
object.key("SortOrder").string(var_1260.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_model_explainability_job_definitions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListModelExplainabilityJobDefinitionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1261) = &input.endpoint_name {
object.key("EndpointName").string(var_1261.as_str());
}
if let Some(var_1262) = &input.sort_by {
object.key("SortBy").string(var_1262.as_str());
}
if let Some(var_1263) = &input.sort_order {
object.key("SortOrder").string(var_1263.as_str());
}
if let Some(var_1264) = &input.next_token {
object.key("NextToken").string(var_1264.as_str());
}
if let Some(var_1265) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1265).into()),
);
}
if let Some(var_1266) = &input.name_contains {
object.key("NameContains").string(var_1266.as_str());
}
if let Some(var_1267) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1267, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1268) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1268, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_input_list_model_metadata_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListModelMetadataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1269) = &input.search_expression {
#[allow(unused_mut)]
let mut object_1270 = object.key("SearchExpression").start_object();
crate::json_ser::serialize_structure_crate_model_model_metadata_search_expression(
&mut object_1270,
var_1269,
)?;
object_1270.finish();
}
if let Some(var_1271) = &input.next_token {
object.key("NextToken").string(var_1271.as_str());
}
if let Some(var_1272) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1272).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_model_package_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListModelPackageGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1273) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1273, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1274) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1274, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1275) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1275).into()),
);
}
if let Some(var_1276) = &input.name_contains {
object.key("NameContains").string(var_1276.as_str());
}
if let Some(var_1277) = &input.next_token {
object.key("NextToken").string(var_1277.as_str());
}
if let Some(var_1278) = &input.sort_by {
object.key("SortBy").string(var_1278.as_str());
}
if let Some(var_1279) = &input.sort_order {
object.key("SortOrder").string(var_1279.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_model_packages_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListModelPackagesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1280) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1280, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1281) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1281, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1282) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1282).into()),
);
}
if let Some(var_1283) = &input.name_contains {
object.key("NameContains").string(var_1283.as_str());
}
if let Some(var_1284) = &input.model_approval_status {
object.key("ModelApprovalStatus").string(var_1284.as_str());
}
if let Some(var_1285) = &input.model_package_group_name {
object
.key("ModelPackageGroupName")
.string(var_1285.as_str());
}
if let Some(var_1286) = &input.model_package_type {
object.key("ModelPackageType").string(var_1286.as_str());
}
if let Some(var_1287) = &input.next_token {
object.key("NextToken").string(var_1287.as_str());
}
if let Some(var_1288) = &input.sort_by {
object.key("SortBy").string(var_1288.as_str());
}
if let Some(var_1289) = &input.sort_order {
object.key("SortOrder").string(var_1289.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_model_quality_job_definitions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListModelQualityJobDefinitionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1290) = &input.endpoint_name {
object.key("EndpointName").string(var_1290.as_str());
}
if let Some(var_1291) = &input.sort_by {
object.key("SortBy").string(var_1291.as_str());
}
if let Some(var_1292) = &input.sort_order {
object.key("SortOrder").string(var_1292.as_str());
}
if let Some(var_1293) = &input.next_token {
object.key("NextToken").string(var_1293.as_str());
}
if let Some(var_1294) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1294).into()),
);
}
if let Some(var_1295) = &input.name_contains {
object.key("NameContains").string(var_1295.as_str());
}
if let Some(var_1296) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1296, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1297) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1297, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_input_list_models_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListModelsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1298) = &input.sort_by {
object.key("SortBy").string(var_1298.as_str());
}
if let Some(var_1299) = &input.sort_order {
object.key("SortOrder").string(var_1299.as_str());
}
if let Some(var_1300) = &input.next_token {
object.key("NextToken").string(var_1300.as_str());
}
if let Some(var_1301) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1301).into()),
);
}
if let Some(var_1302) = &input.name_contains {
object.key("NameContains").string(var_1302.as_str());
}
if let Some(var_1303) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1303, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1304) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1304, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_input_list_monitoring_alert_history_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListMonitoringAlertHistoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1305) = &input.monitoring_schedule_name {
object
.key("MonitoringScheduleName")
.string(var_1305.as_str());
}
if let Some(var_1306) = &input.monitoring_alert_name {
object.key("MonitoringAlertName").string(var_1306.as_str());
}
if let Some(var_1307) = &input.sort_by {
object.key("SortBy").string(var_1307.as_str());
}
if let Some(var_1308) = &input.sort_order {
object.key("SortOrder").string(var_1308.as_str());
}
if let Some(var_1309) = &input.next_token {
object.key("NextToken").string(var_1309.as_str());
}
if let Some(var_1310) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1310).into()),
);
}
if let Some(var_1311) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1311, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1312) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1312, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1313) = &input.status_equals {
object.key("StatusEquals").string(var_1313.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_monitoring_alerts_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListMonitoringAlertsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1314) = &input.monitoring_schedule_name {
object
.key("MonitoringScheduleName")
.string(var_1314.as_str());
}
if let Some(var_1315) = &input.next_token {
object.key("NextToken").string(var_1315.as_str());
}
if let Some(var_1316) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1316).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_monitoring_executions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListMonitoringExecutionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1317) = &input.monitoring_schedule_name {
object
.key("MonitoringScheduleName")
.string(var_1317.as_str());
}
if let Some(var_1318) = &input.endpoint_name {
object.key("EndpointName").string(var_1318.as_str());
}
if let Some(var_1319) = &input.sort_by {
object.key("SortBy").string(var_1319.as_str());
}
if let Some(var_1320) = &input.sort_order {
object.key("SortOrder").string(var_1320.as_str());
}
if let Some(var_1321) = &input.next_token {
object.key("NextToken").string(var_1321.as_str());
}
if let Some(var_1322) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1322).into()),
);
}
if let Some(var_1323) = &input.scheduled_time_before {
object
.key("ScheduledTimeBefore")
.date_time(var_1323, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1324) = &input.scheduled_time_after {
object
.key("ScheduledTimeAfter")
.date_time(var_1324, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1325) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1325, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1326) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1326, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1327) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_1327, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1328) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_1328, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1329) = &input.status_equals {
object.key("StatusEquals").string(var_1329.as_str());
}
if let Some(var_1330) = &input.monitoring_job_definition_name {
object
.key("MonitoringJobDefinitionName")
.string(var_1330.as_str());
}
if let Some(var_1331) = &input.monitoring_type_equals {
object.key("MonitoringTypeEquals").string(var_1331.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_monitoring_schedules_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListMonitoringSchedulesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1332) = &input.endpoint_name {
object.key("EndpointName").string(var_1332.as_str());
}
if let Some(var_1333) = &input.sort_by {
object.key("SortBy").string(var_1333.as_str());
}
if let Some(var_1334) = &input.sort_order {
object.key("SortOrder").string(var_1334.as_str());
}
if let Some(var_1335) = &input.next_token {
object.key("NextToken").string(var_1335.as_str());
}
if let Some(var_1336) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1336).into()),
);
}
if let Some(var_1337) = &input.name_contains {
object.key("NameContains").string(var_1337.as_str());
}
if let Some(var_1338) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1338, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1339) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1339, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1340) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_1340, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1341) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_1341, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1342) = &input.status_equals {
object.key("StatusEquals").string(var_1342.as_str());
}
if let Some(var_1343) = &input.monitoring_job_definition_name {
object
.key("MonitoringJobDefinitionName")
.string(var_1343.as_str());
}
if let Some(var_1344) = &input.monitoring_type_equals {
object.key("MonitoringTypeEquals").string(var_1344.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_notebook_instance_lifecycle_configs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListNotebookInstanceLifecycleConfigsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1345) = &input.next_token {
object.key("NextToken").string(var_1345.as_str());
}
if let Some(var_1346) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1346).into()),
);
}
if let Some(var_1347) = &input.sort_by {
object.key("SortBy").string(var_1347.as_str());
}
if let Some(var_1348) = &input.sort_order {
object.key("SortOrder").string(var_1348.as_str());
}
if let Some(var_1349) = &input.name_contains {
object.key("NameContains").string(var_1349.as_str());
}
if let Some(var_1350) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1350, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1351) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1351, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1352) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_1352, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1353) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_1353, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_input_list_notebook_instances_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListNotebookInstancesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1354) = &input.next_token {
object.key("NextToken").string(var_1354.as_str());
}
if let Some(var_1355) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1355).into()),
);
}
if let Some(var_1356) = &input.sort_by {
object.key("SortBy").string(var_1356.as_str());
}
if let Some(var_1357) = &input.sort_order {
object.key("SortOrder").string(var_1357.as_str());
}
if let Some(var_1358) = &input.name_contains {
object.key("NameContains").string(var_1358.as_str());
}
if let Some(var_1359) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1359, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1360) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1360, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1361) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_1361, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1362) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_1362, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1363) = &input.status_equals {
object.key("StatusEquals").string(var_1363.as_str());
}
if let Some(var_1364) = &input.notebook_instance_lifecycle_config_name_contains {
object
.key("NotebookInstanceLifecycleConfigNameContains")
.string(var_1364.as_str());
}
if let Some(var_1365) = &input.default_code_repository_contains {
object
.key("DefaultCodeRepositoryContains")
.string(var_1365.as_str());
}
if let Some(var_1366) = &input.additional_code_repository_equals {
object
.key("AdditionalCodeRepositoryEquals")
.string(var_1366.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_pipeline_executions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPipelineExecutionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1367) = &input.pipeline_name {
object.key("PipelineName").string(var_1367.as_str());
}
if let Some(var_1368) = &input.created_after {
object
.key("CreatedAfter")
.date_time(var_1368, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1369) = &input.created_before {
object
.key("CreatedBefore")
.date_time(var_1369, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1370) = &input.sort_by {
object.key("SortBy").string(var_1370.as_str());
}
if let Some(var_1371) = &input.sort_order {
object.key("SortOrder").string(var_1371.as_str());
}
if let Some(var_1372) = &input.next_token {
object.key("NextToken").string(var_1372.as_str());
}
if let Some(var_1373) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1373).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_pipeline_execution_steps_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPipelineExecutionStepsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1374) = &input.pipeline_execution_arn {
object.key("PipelineExecutionArn").string(var_1374.as_str());
}
if let Some(var_1375) = &input.next_token {
object.key("NextToken").string(var_1375.as_str());
}
if let Some(var_1376) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1376).into()),
);
}
if let Some(var_1377) = &input.sort_order {
object.key("SortOrder").string(var_1377.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_pipeline_parameters_for_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPipelineParametersForExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1378) = &input.pipeline_execution_arn {
object.key("PipelineExecutionArn").string(var_1378.as_str());
}
if let Some(var_1379) = &input.next_token {
object.key("NextToken").string(var_1379.as_str());
}
if let Some(var_1380) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1380).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_pipelines_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPipelinesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1381) = &input.pipeline_name_prefix {
object.key("PipelineNamePrefix").string(var_1381.as_str());
}
if let Some(var_1382) = &input.created_after {
object
.key("CreatedAfter")
.date_time(var_1382, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1383) = &input.created_before {
object
.key("CreatedBefore")
.date_time(var_1383, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1384) = &input.sort_by {
object.key("SortBy").string(var_1384.as_str());
}
if let Some(var_1385) = &input.sort_order {
object.key("SortOrder").string(var_1385.as_str());
}
if let Some(var_1386) = &input.next_token {
object.key("NextToken").string(var_1386.as_str());
}
if let Some(var_1387) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1387).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_processing_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListProcessingJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1388) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1388, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1389) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1389, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1390) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_1390, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1391) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_1391, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1392) = &input.name_contains {
object.key("NameContains").string(var_1392.as_str());
}
if let Some(var_1393) = &input.status_equals {
object.key("StatusEquals").string(var_1393.as_str());
}
if let Some(var_1394) = &input.sort_by {
object.key("SortBy").string(var_1394.as_str());
}
if let Some(var_1395) = &input.sort_order {
object.key("SortOrder").string(var_1395.as_str());
}
if let Some(var_1396) = &input.next_token {
object.key("NextToken").string(var_1396.as_str());
}
if let Some(var_1397) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1397).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_projects_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListProjectsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1398) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1398, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1399) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1399, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1400) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1400).into()),
);
}
if let Some(var_1401) = &input.name_contains {
object.key("NameContains").string(var_1401.as_str());
}
if let Some(var_1402) = &input.next_token {
object.key("NextToken").string(var_1402.as_str());
}
if let Some(var_1403) = &input.sort_by {
object.key("SortBy").string(var_1403.as_str());
}
if let Some(var_1404) = &input.sort_order {
object.key("SortOrder").string(var_1404.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_spaces_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSpacesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1405) = &input.next_token {
object.key("NextToken").string(var_1405.as_str());
}
if let Some(var_1406) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1406).into()),
);
}
if let Some(var_1407) = &input.sort_order {
object.key("SortOrder").string(var_1407.as_str());
}
if let Some(var_1408) = &input.sort_by {
object.key("SortBy").string(var_1408.as_str());
}
if let Some(var_1409) = &input.domain_id_equals {
object.key("DomainIdEquals").string(var_1409.as_str());
}
if let Some(var_1410) = &input.space_name_contains {
object.key("SpaceNameContains").string(var_1410.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_stage_devices_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListStageDevicesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1411) = &input.next_token {
object.key("NextToken").string(var_1411.as_str());
}
if let Some(var_1412) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1412).into()),
);
}
if let Some(var_1413) = &input.edge_deployment_plan_name {
object
.key("EdgeDeploymentPlanName")
.string(var_1413.as_str());
}
if input.exclude_devices_deployed_in_other_stage {
object
.key("ExcludeDevicesDeployedInOtherStage")
.boolean(input.exclude_devices_deployed_in_other_stage);
}
if let Some(var_1414) = &input.stage_name {
object.key("StageName").string(var_1414.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_studio_lifecycle_configs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListStudioLifecycleConfigsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1415) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1415).into()),
);
}
if let Some(var_1416) = &input.next_token {
object.key("NextToken").string(var_1416.as_str());
}
if let Some(var_1417) = &input.name_contains {
object.key("NameContains").string(var_1417.as_str());
}
if let Some(var_1418) = &input.app_type_equals {
object.key("AppTypeEquals").string(var_1418.as_str());
}
if let Some(var_1419) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1419, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1420) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1420, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1421) = &input.modified_time_before {
object
.key("ModifiedTimeBefore")
.date_time(var_1421, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1422) = &input.modified_time_after {
object
.key("ModifiedTimeAfter")
.date_time(var_1422, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1423) = &input.sort_by {
object.key("SortBy").string(var_1423.as_str());
}
if let Some(var_1424) = &input.sort_order {
object.key("SortOrder").string(var_1424.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_subscribed_workteams_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSubscribedWorkteamsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1425) = &input.name_contains {
object.key("NameContains").string(var_1425.as_str());
}
if let Some(var_1426) = &input.next_token {
object.key("NextToken").string(var_1426.as_str());
}
if let Some(var_1427) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1427).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1428) = &input.resource_arn {
object.key("ResourceArn").string(var_1428.as_str());
}
if let Some(var_1429) = &input.next_token {
object.key("NextToken").string(var_1429.as_str());
}
if let Some(var_1430) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1430).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_training_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTrainingJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1431) = &input.next_token {
object.key("NextToken").string(var_1431.as_str());
}
if let Some(var_1432) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1432).into()),
);
}
if let Some(var_1433) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1433, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1434) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1434, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1435) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_1435, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1436) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_1436, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1437) = &input.name_contains {
object.key("NameContains").string(var_1437.as_str());
}
if let Some(var_1438) = &input.status_equals {
object.key("StatusEquals").string(var_1438.as_str());
}
if let Some(var_1439) = &input.sort_by {
object.key("SortBy").string(var_1439.as_str());
}
if let Some(var_1440) = &input.sort_order {
object.key("SortOrder").string(var_1440.as_str());
}
if let Some(var_1441) = &input.warm_pool_status_equals {
object.key("WarmPoolStatusEquals").string(var_1441.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_training_jobs_for_hyper_parameter_tuning_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTrainingJobsForHyperParameterTuningJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1442) = &input.hyper_parameter_tuning_job_name {
object
.key("HyperParameterTuningJobName")
.string(var_1442.as_str());
}
if let Some(var_1443) = &input.next_token {
object.key("NextToken").string(var_1443.as_str());
}
if let Some(var_1444) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1444).into()),
);
}
if let Some(var_1445) = &input.status_equals {
object.key("StatusEquals").string(var_1445.as_str());
}
if let Some(var_1446) = &input.sort_by {
object.key("SortBy").string(var_1446.as_str());
}
if let Some(var_1447) = &input.sort_order {
object.key("SortOrder").string(var_1447.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_transform_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTransformJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1448) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_1448, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1449) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_1449, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1450) = &input.last_modified_time_after {
object
.key("LastModifiedTimeAfter")
.date_time(var_1450, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1451) = &input.last_modified_time_before {
object
.key("LastModifiedTimeBefore")
.date_time(var_1451, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1452) = &input.name_contains {
object.key("NameContains").string(var_1452.as_str());
}
if let Some(var_1453) = &input.status_equals {
object.key("StatusEquals").string(var_1453.as_str());
}
if let Some(var_1454) = &input.sort_by {
object.key("SortBy").string(var_1454.as_str());
}
if let Some(var_1455) = &input.sort_order {
object.key("SortOrder").string(var_1455.as_str());
}
if let Some(var_1456) = &input.next_token {
object.key("NextToken").string(var_1456.as_str());
}
if let Some(var_1457) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1457).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_trial_components_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTrialComponentsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1458) = &input.experiment_name {
object.key("ExperimentName").string(var_1458.as_str());
}
if let Some(var_1459) = &input.trial_name {
object.key("TrialName").string(var_1459.as_str());
}
if let Some(var_1460) = &input.source_arn {
object.key("SourceArn").string(var_1460.as_str());
}
if let Some(var_1461) = &input.created_after {
object
.key("CreatedAfter")
.date_time(var_1461, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1462) = &input.created_before {
object
.key("CreatedBefore")
.date_time(var_1462, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1463) = &input.sort_by {
object.key("SortBy").string(var_1463.as_str());
}
if let Some(var_1464) = &input.sort_order {
object.key("SortOrder").string(var_1464.as_str());
}
if let Some(var_1465) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1465).into()),
);
}
if let Some(var_1466) = &input.next_token {
object.key("NextToken").string(var_1466.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_trials_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTrialsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1467) = &input.experiment_name {
object.key("ExperimentName").string(var_1467.as_str());
}
if let Some(var_1468) = &input.trial_component_name {
object.key("TrialComponentName").string(var_1468.as_str());
}
if let Some(var_1469) = &input.created_after {
object
.key("CreatedAfter")
.date_time(var_1469, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1470) = &input.created_before {
object
.key("CreatedBefore")
.date_time(var_1470, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1471) = &input.sort_by {
object.key("SortBy").string(var_1471.as_str());
}
if let Some(var_1472) = &input.sort_order {
object.key("SortOrder").string(var_1472.as_str());
}
if let Some(var_1473) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1473).into()),
);
}
if let Some(var_1474) = &input.next_token {
object.key("NextToken").string(var_1474.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_user_profiles_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListUserProfilesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1475) = &input.next_token {
object.key("NextToken").string(var_1475.as_str());
}
if let Some(var_1476) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1476).into()),
);
}
if let Some(var_1477) = &input.sort_order {
object.key("SortOrder").string(var_1477.as_str());
}
if let Some(var_1478) = &input.sort_by {
object.key("SortBy").string(var_1478.as_str());
}
if let Some(var_1479) = &input.domain_id_equals {
object.key("DomainIdEquals").string(var_1479.as_str());
}
if let Some(var_1480) = &input.user_profile_name_contains {
object
.key("UserProfileNameContains")
.string(var_1480.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_workforces_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListWorkforcesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1481) = &input.sort_by {
object.key("SortBy").string(var_1481.as_str());
}
if let Some(var_1482) = &input.sort_order {
object.key("SortOrder").string(var_1482.as_str());
}
if let Some(var_1483) = &input.name_contains {
object.key("NameContains").string(var_1483.as_str());
}
if let Some(var_1484) = &input.next_token {
object.key("NextToken").string(var_1484.as_str());
}
if let Some(var_1485) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1485).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_workteams_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListWorkteamsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1486) = &input.sort_by {
object.key("SortBy").string(var_1486.as_str());
}
if let Some(var_1487) = &input.sort_order {
object.key("SortOrder").string(var_1487.as_str());
}
if let Some(var_1488) = &input.name_contains {
object.key("NameContains").string(var_1488.as_str());
}
if let Some(var_1489) = &input.next_token {
object.key("NextToken").string(var_1489.as_str());
}
if let Some(var_1490) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1490).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_model_package_group_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutModelPackageGroupPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1491) = &input.model_package_group_name {
object
.key("ModelPackageGroupName")
.string(var_1491.as_str());
}
if let Some(var_1492) = &input.resource_policy {
object.key("ResourcePolicy").string(var_1492.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_query_lineage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::QueryLineageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1493) = &input.start_arns {
let mut array_1494 = object.key("StartArns").start_array();
for item_1495 in var_1493 {
{
array_1494.value().string(item_1495.as_str());
}
}
array_1494.finish();
}
if let Some(var_1496) = &input.direction {
object.key("Direction").string(var_1496.as_str());
}
if input.include_edges {
object.key("IncludeEdges").boolean(input.include_edges);
}
if let Some(var_1497) = &input.filters {
#[allow(unused_mut)]
let mut object_1498 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_query_filters(&mut object_1498, var_1497)?;
object_1498.finish();
}
if let Some(var_1499) = &input.max_depth {
object.key("MaxDepth").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1499).into()),
);
}
if let Some(var_1500) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1500).into()),
);
}
if let Some(var_1501) = &input.next_token {
object.key("NextToken").string(var_1501.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_register_devices_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterDevicesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1502) = &input.device_fleet_name {
object.key("DeviceFleetName").string(var_1502.as_str());
}
if let Some(var_1503) = &input.devices {
let mut array_1504 = object.key("Devices").start_array();
for item_1505 in var_1503 {
{
#[allow(unused_mut)]
let mut object_1506 = array_1504.value().start_object();
crate::json_ser::serialize_structure_crate_model_device(
&mut object_1506,
item_1505,
)?;
object_1506.finish();
}
}
array_1504.finish();
}
if let Some(var_1507) = &input.tags {
let mut array_1508 = object.key("Tags").start_array();
for item_1509 in var_1507 {
{
#[allow(unused_mut)]
let mut object_1510 = array_1508.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_1510, item_1509)?;
object_1510.finish();
}
}
array_1508.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_render_ui_template_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RenderUiTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1511) = &input.ui_template {
#[allow(unused_mut)]
let mut object_1512 = object.key("UiTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_ui_template(&mut object_1512, var_1511)?;
object_1512.finish();
}
if let Some(var_1513) = &input.task {
#[allow(unused_mut)]
let mut object_1514 = object.key("Task").start_object();
crate::json_ser::serialize_structure_crate_model_renderable_task(
&mut object_1514,
var_1513,
)?;
object_1514.finish();
}
if let Some(var_1515) = &input.role_arn {
object.key("RoleArn").string(var_1515.as_str());
}
if let Some(var_1516) = &input.human_task_ui_arn {
object.key("HumanTaskUiArn").string(var_1516.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_retry_pipeline_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RetryPipelineExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1517) = &input.pipeline_execution_arn {
object.key("PipelineExecutionArn").string(var_1517.as_str());
}
if let Some(var_1518) = &input.client_request_token {
object.key("ClientRequestToken").string(var_1518.as_str());
}
if let Some(var_1519) = &input.parallelism_configuration {
#[allow(unused_mut)]
let mut object_1520 = object.key("ParallelismConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_parallelism_configuration(
&mut object_1520,
var_1519,
)?;
object_1520.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_search_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1521) = &input.resource {
object.key("Resource").string(var_1521.as_str());
}
if let Some(var_1522) = &input.search_expression {
#[allow(unused_mut)]
let mut object_1523 = object.key("SearchExpression").start_object();
crate::json_ser::serialize_structure_crate_model_search_expression(
&mut object_1523,
var_1522,
)?;
object_1523.finish();
}
if let Some(var_1524) = &input.sort_by {
object.key("SortBy").string(var_1524.as_str());
}
if let Some(var_1525) = &input.sort_order {
object.key("SortOrder").string(var_1525.as_str());
}
if let Some(var_1526) = &input.next_token {
object.key("NextToken").string(var_1526.as_str());
}
if let Some(var_1527) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1527).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_send_pipeline_execution_step_failure_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SendPipelineExecutionStepFailureInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1528) = &input.callback_token {
object.key("CallbackToken").string(var_1528.as_str());
}
if let Some(var_1529) = &input.failure_reason {
object.key("FailureReason").string(var_1529.as_str());
}
if let Some(var_1530) = &input.client_request_token {
object.key("ClientRequestToken").string(var_1530.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_send_pipeline_execution_step_success_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SendPipelineExecutionStepSuccessInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1531) = &input.callback_token {
object.key("CallbackToken").string(var_1531.as_str());
}
if let Some(var_1532) = &input.output_parameters {
let mut array_1533 = object.key("OutputParameters").start_array();
for item_1534 in var_1532 {
{
#[allow(unused_mut)]
let mut object_1535 = array_1533.value().start_object();
crate::json_ser::serialize_structure_crate_model_output_parameter(
&mut object_1535,
item_1534,
)?;
object_1535.finish();
}
}
array_1533.finish();
}
if let Some(var_1536) = &input.client_request_token {
object.key("ClientRequestToken").string(var_1536.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_edge_deployment_stage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartEdgeDeploymentStageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1537) = &input.edge_deployment_plan_name {
object
.key("EdgeDeploymentPlanName")
.string(var_1537.as_str());
}
if let Some(var_1538) = &input.stage_name {
object.key("StageName").string(var_1538.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_inference_experiment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartInferenceExperimentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1539) = &input.name {
object.key("Name").string(var_1539.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_monitoring_schedule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartMonitoringScheduleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1540) = &input.monitoring_schedule_name {
object
.key("MonitoringScheduleName")
.string(var_1540.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_notebook_instance_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartNotebookInstanceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1541) = &input.notebook_instance_name {
object.key("NotebookInstanceName").string(var_1541.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_pipeline_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartPipelineExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1542) = &input.pipeline_name {
object.key("PipelineName").string(var_1542.as_str());
}
if let Some(var_1543) = &input.pipeline_execution_display_name {
object
.key("PipelineExecutionDisplayName")
.string(var_1543.as_str());
}
if let Some(var_1544) = &input.pipeline_parameters {
let mut array_1545 = object.key("PipelineParameters").start_array();
for item_1546 in var_1544 {
{
#[allow(unused_mut)]
let mut object_1547 = array_1545.value().start_object();
crate::json_ser::serialize_structure_crate_model_parameter(
&mut object_1547,
item_1546,
)?;
object_1547.finish();
}
}
array_1545.finish();
}
if let Some(var_1548) = &input.pipeline_execution_description {
object
.key("PipelineExecutionDescription")
.string(var_1548.as_str());
}
if let Some(var_1549) = &input.client_request_token {
object.key("ClientRequestToken").string(var_1549.as_str());
}
if let Some(var_1550) = &input.parallelism_configuration {
#[allow(unused_mut)]
let mut object_1551 = object.key("ParallelismConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_parallelism_configuration(
&mut object_1551,
var_1550,
)?;
object_1551.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_auto_ml_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopAutoMlJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1552) = &input.auto_ml_job_name {
object.key("AutoMLJobName").string(var_1552.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_compilation_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopCompilationJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1553) = &input.compilation_job_name {
object.key("CompilationJobName").string(var_1553.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_edge_deployment_stage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopEdgeDeploymentStageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1554) = &input.edge_deployment_plan_name {
object
.key("EdgeDeploymentPlanName")
.string(var_1554.as_str());
}
if let Some(var_1555) = &input.stage_name {
object.key("StageName").string(var_1555.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_edge_packaging_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopEdgePackagingJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1556) = &input.edge_packaging_job_name {
object.key("EdgePackagingJobName").string(var_1556.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_hyper_parameter_tuning_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopHyperParameterTuningJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1557) = &input.hyper_parameter_tuning_job_name {
object
.key("HyperParameterTuningJobName")
.string(var_1557.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_inference_experiment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopInferenceExperimentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1558) = &input.name {
object.key("Name").string(var_1558.as_str());
}
if let Some(var_1559) = &input.model_variant_actions {
#[allow(unused_mut)]
let mut object_1560 = object.key("ModelVariantActions").start_object();
for (key_1561, value_1562) in var_1559 {
{
object_1560
.key(key_1561.as_str())
.string(value_1562.as_str());
}
}
object_1560.finish();
}
if let Some(var_1563) = &input.desired_model_variants {
let mut array_1564 = object.key("DesiredModelVariants").start_array();
for item_1565 in var_1563 {
{
#[allow(unused_mut)]
let mut object_1566 = array_1564.value().start_object();
crate::json_ser::serialize_structure_crate_model_model_variant_config(
&mut object_1566,
item_1565,
)?;
object_1566.finish();
}
}
array_1564.finish();
}
if let Some(var_1567) = &input.desired_state {
object.key("DesiredState").string(var_1567.as_str());
}
if let Some(var_1568) = &input.reason {
object.key("Reason").string(var_1568.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_inference_recommendations_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopInferenceRecommendationsJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1569) = &input.job_name {
object.key("JobName").string(var_1569.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_labeling_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopLabelingJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1570) = &input.labeling_job_name {
object.key("LabelingJobName").string(var_1570.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_monitoring_schedule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopMonitoringScheduleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1571) = &input.monitoring_schedule_name {
object
.key("MonitoringScheduleName")
.string(var_1571.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_notebook_instance_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopNotebookInstanceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1572) = &input.notebook_instance_name {
object.key("NotebookInstanceName").string(var_1572.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_pipeline_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopPipelineExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1573) = &input.pipeline_execution_arn {
object.key("PipelineExecutionArn").string(var_1573.as_str());
}
if let Some(var_1574) = &input.client_request_token {
object.key("ClientRequestToken").string(var_1574.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_processing_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopProcessingJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1575) = &input.processing_job_name {
object.key("ProcessingJobName").string(var_1575.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_training_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopTrainingJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1576) = &input.training_job_name {
object.key("TrainingJobName").string(var_1576.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_transform_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopTransformJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1577) = &input.transform_job_name {
object.key("TransformJobName").string(var_1577.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_action_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateActionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1578) = &input.action_name {
object.key("ActionName").string(var_1578.as_str());
}
if let Some(var_1579) = &input.description {
object.key("Description").string(var_1579.as_str());
}
if let Some(var_1580) = &input.status {
object.key("Status").string(var_1580.as_str());
}
if let Some(var_1581) = &input.properties {
#[allow(unused_mut)]
let mut object_1582 = object.key("Properties").start_object();
for (key_1583, value_1584) in var_1581 {
{
object_1582
.key(key_1583.as_str())
.string(value_1584.as_str());
}
}
object_1582.finish();
}
if let Some(var_1585) = &input.properties_to_remove {
let mut array_1586 = object.key("PropertiesToRemove").start_array();
for item_1587 in var_1585 {
{
array_1586.value().string(item_1587.as_str());
}
}
array_1586.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_app_image_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAppImageConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1588) = &input.app_image_config_name {
object.key("AppImageConfigName").string(var_1588.as_str());
}
if let Some(var_1589) = &input.kernel_gateway_image_config {
#[allow(unused_mut)]
let mut object_1590 = object.key("KernelGatewayImageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_kernel_gateway_image_config(
&mut object_1590,
var_1589,
)?;
object_1590.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_artifact_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateArtifactInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1591) = &input.artifact_arn {
object.key("ArtifactArn").string(var_1591.as_str());
}
if let Some(var_1592) = &input.artifact_name {
object.key("ArtifactName").string(var_1592.as_str());
}
if let Some(var_1593) = &input.properties {
#[allow(unused_mut)]
let mut object_1594 = object.key("Properties").start_object();
for (key_1595, value_1596) in var_1593 {
{
object_1594
.key(key_1595.as_str())
.string(value_1596.as_str());
}
}
object_1594.finish();
}
if let Some(var_1597) = &input.properties_to_remove {
let mut array_1598 = object.key("PropertiesToRemove").start_array();
for item_1599 in var_1597 {
{
array_1598.value().string(item_1599.as_str());
}
}
array_1598.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_code_repository_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateCodeRepositoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1600) = &input.code_repository_name {
object.key("CodeRepositoryName").string(var_1600.as_str());
}
if let Some(var_1601) = &input.git_config {
#[allow(unused_mut)]
let mut object_1602 = object.key("GitConfig").start_object();
crate::json_ser::serialize_structure_crate_model_git_config_for_update(
&mut object_1602,
var_1601,
)?;
object_1602.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_context_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateContextInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1603) = &input.context_name {
object.key("ContextName").string(var_1603.as_str());
}
if let Some(var_1604) = &input.description {
object.key("Description").string(var_1604.as_str());
}
if let Some(var_1605) = &input.properties {
#[allow(unused_mut)]
let mut object_1606 = object.key("Properties").start_object();
for (key_1607, value_1608) in var_1605 {
{
object_1606
.key(key_1607.as_str())
.string(value_1608.as_str());
}
}
object_1606.finish();
}
if let Some(var_1609) = &input.properties_to_remove {
let mut array_1610 = object.key("PropertiesToRemove").start_array();
for item_1611 in var_1609 {
{
array_1610.value().string(item_1611.as_str());
}
}
array_1610.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_device_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDeviceFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1612) = &input.device_fleet_name {
object.key("DeviceFleetName").string(var_1612.as_str());
}
if let Some(var_1613) = &input.role_arn {
object.key("RoleArn").string(var_1613.as_str());
}
if let Some(var_1614) = &input.description {
object.key("Description").string(var_1614.as_str());
}
if let Some(var_1615) = &input.output_config {
#[allow(unused_mut)]
let mut object_1616 = object.key("OutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_edge_output_config(
&mut object_1616,
var_1615,
)?;
object_1616.finish();
}
if let Some(var_1617) = &input.enable_iot_role_alias {
object.key("EnableIotRoleAlias").boolean(*var_1617);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_devices_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDevicesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1618) = &input.device_fleet_name {
object.key("DeviceFleetName").string(var_1618.as_str());
}
if let Some(var_1619) = &input.devices {
let mut array_1620 = object.key("Devices").start_array();
for item_1621 in var_1619 {
{
#[allow(unused_mut)]
let mut object_1622 = array_1620.value().start_object();
crate::json_ser::serialize_structure_crate_model_device(
&mut object_1622,
item_1621,
)?;
object_1622.finish();
}
}
array_1620.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_domain_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDomainInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1623) = &input.domain_id {
object.key("DomainId").string(var_1623.as_str());
}
if let Some(var_1624) = &input.default_user_settings {
#[allow(unused_mut)]
let mut object_1625 = object.key("DefaultUserSettings").start_object();
crate::json_ser::serialize_structure_crate_model_user_settings(&mut object_1625, var_1624)?;
object_1625.finish();
}
if let Some(var_1626) = &input.domain_settings_for_update {
#[allow(unused_mut)]
let mut object_1627 = object.key("DomainSettingsForUpdate").start_object();
crate::json_ser::serialize_structure_crate_model_domain_settings_for_update(
&mut object_1627,
var_1626,
)?;
object_1627.finish();
}
if let Some(var_1628) = &input.default_space_settings {
#[allow(unused_mut)]
let mut object_1629 = object.key("DefaultSpaceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_default_space_settings(
&mut object_1629,
var_1628,
)?;
object_1629.finish();
}
if let Some(var_1630) = &input.app_security_group_management {
object
.key("AppSecurityGroupManagement")
.string(var_1630.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1631) = &input.endpoint_name {
object.key("EndpointName").string(var_1631.as_str());
}
if let Some(var_1632) = &input.endpoint_config_name {
object.key("EndpointConfigName").string(var_1632.as_str());
}
if input.retain_all_variant_properties {
object
.key("RetainAllVariantProperties")
.boolean(input.retain_all_variant_properties);
}
if let Some(var_1633) = &input.exclude_retained_variant_properties {
let mut array_1634 = object.key("ExcludeRetainedVariantProperties").start_array();
for item_1635 in var_1633 {
{
#[allow(unused_mut)]
let mut object_1636 = array_1634.value().start_object();
crate::json_ser::serialize_structure_crate_model_variant_property(
&mut object_1636,
item_1635,
)?;
object_1636.finish();
}
}
array_1634.finish();
}
if let Some(var_1637) = &input.deployment_config {
#[allow(unused_mut)]
let mut object_1638 = object.key("DeploymentConfig").start_object();
crate::json_ser::serialize_structure_crate_model_deployment_config(
&mut object_1638,
var_1637,
)?;
object_1638.finish();
}
if input.retain_deployment_config {
object
.key("RetainDeploymentConfig")
.boolean(input.retain_deployment_config);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_endpoint_weights_and_capacities_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateEndpointWeightsAndCapacitiesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1639) = &input.endpoint_name {
object.key("EndpointName").string(var_1639.as_str());
}
if let Some(var_1640) = &input.desired_weights_and_capacities {
let mut array_1641 = object.key("DesiredWeightsAndCapacities").start_array();
for item_1642 in var_1640 {
{
#[allow(unused_mut)]
let mut object_1643 = array_1641.value().start_object();
crate::json_ser::serialize_structure_crate_model_desired_weight_and_capacity(
&mut object_1643,
item_1642,
)?;
object_1643.finish();
}
}
array_1641.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_experiment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateExperimentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1644) = &input.experiment_name {
object.key("ExperimentName").string(var_1644.as_str());
}
if let Some(var_1645) = &input.display_name {
object.key("DisplayName").string(var_1645.as_str());
}
if let Some(var_1646) = &input.description {
object.key("Description").string(var_1646.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_feature_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFeatureGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1647) = &input.feature_group_name {
object.key("FeatureGroupName").string(var_1647.as_str());
}
if let Some(var_1648) = &input.feature_additions {
let mut array_1649 = object.key("FeatureAdditions").start_array();
for item_1650 in var_1648 {
{
#[allow(unused_mut)]
let mut object_1651 = array_1649.value().start_object();
crate::json_ser::serialize_structure_crate_model_feature_definition(
&mut object_1651,
item_1650,
)?;
object_1651.finish();
}
}
array_1649.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_feature_metadata_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFeatureMetadataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1652) = &input.feature_group_name {
object.key("FeatureGroupName").string(var_1652.as_str());
}
if let Some(var_1653) = &input.feature_name {
object.key("FeatureName").string(var_1653.as_str());
}
if let Some(var_1654) = &input.description {
object.key("Description").string(var_1654.as_str());
}
if let Some(var_1655) = &input.parameter_additions {
let mut array_1656 = object.key("ParameterAdditions").start_array();
for item_1657 in var_1655 {
{
#[allow(unused_mut)]
let mut object_1658 = array_1656.value().start_object();
crate::json_ser::serialize_structure_crate_model_feature_parameter(
&mut object_1658,
item_1657,
)?;
object_1658.finish();
}
}
array_1656.finish();
}
if let Some(var_1659) = &input.parameter_removals {
let mut array_1660 = object.key("ParameterRemovals").start_array();
for item_1661 in var_1659 {
{
array_1660.value().string(item_1661.as_str());
}
}
array_1660.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_hub_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateHubInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1662) = &input.hub_name {
object.key("HubName").string(var_1662.as_str());
}
if let Some(var_1663) = &input.hub_description {
object.key("HubDescription").string(var_1663.as_str());
}
if let Some(var_1664) = &input.hub_display_name {
object.key("HubDisplayName").string(var_1664.as_str());
}
if let Some(var_1665) = &input.hub_search_keywords {
let mut array_1666 = object.key("HubSearchKeywords").start_array();
for item_1667 in var_1665 {
{
array_1666.value().string(item_1667.as_str());
}
}
array_1666.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_image_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateImageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1668) = &input.delete_properties {
let mut array_1669 = object.key("DeleteProperties").start_array();
for item_1670 in var_1668 {
{
array_1669.value().string(item_1670.as_str());
}
}
array_1669.finish();
}
if let Some(var_1671) = &input.description {
object.key("Description").string(var_1671.as_str());
}
if let Some(var_1672) = &input.display_name {
object.key("DisplayName").string(var_1672.as_str());
}
if let Some(var_1673) = &input.image_name {
object.key("ImageName").string(var_1673.as_str());
}
if let Some(var_1674) = &input.role_arn {
object.key("RoleArn").string(var_1674.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_image_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateImageVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1675) = &input.image_name {
object.key("ImageName").string(var_1675.as_str());
}
if let Some(var_1676) = &input.alias {
object.key("Alias").string(var_1676.as_str());
}
if let Some(var_1677) = &input.version {
object.key("Version").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1677).into()),
);
}
if let Some(var_1678) = &input.aliases_to_add {
let mut array_1679 = object.key("AliasesToAdd").start_array();
for item_1680 in var_1678 {
{
array_1679.value().string(item_1680.as_str());
}
}
array_1679.finish();
}
if let Some(var_1681) = &input.aliases_to_delete {
let mut array_1682 = object.key("AliasesToDelete").start_array();
for item_1683 in var_1681 {
{
array_1682.value().string(item_1683.as_str());
}
}
array_1682.finish();
}
if let Some(var_1684) = &input.vendor_guidance {
object.key("VendorGuidance").string(var_1684.as_str());
}
if let Some(var_1685) = &input.job_type {
object.key("JobType").string(var_1685.as_str());
}
if let Some(var_1686) = &input.ml_framework {
object.key("MLFramework").string(var_1686.as_str());
}
if let Some(var_1687) = &input.programming_lang {
object.key("ProgrammingLang").string(var_1687.as_str());
}
if let Some(var_1688) = &input.processor {
object.key("Processor").string(var_1688.as_str());
}
if input.horovod {
object.key("Horovod").boolean(input.horovod);
}
if let Some(var_1689) = &input.release_notes {
object.key("ReleaseNotes").string(var_1689.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_inference_experiment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateInferenceExperimentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1690) = &input.name {
object.key("Name").string(var_1690.as_str());
}
if let Some(var_1691) = &input.schedule {
#[allow(unused_mut)]
let mut object_1692 = object.key("Schedule").start_object();
crate::json_ser::serialize_structure_crate_model_inference_experiment_schedule(
&mut object_1692,
var_1691,
)?;
object_1692.finish();
}
if let Some(var_1693) = &input.description {
object.key("Description").string(var_1693.as_str());
}
if let Some(var_1694) = &input.model_variants {
let mut array_1695 = object.key("ModelVariants").start_array();
for item_1696 in var_1694 {
{
#[allow(unused_mut)]
let mut object_1697 = array_1695.value().start_object();
crate::json_ser::serialize_structure_crate_model_model_variant_config(
&mut object_1697,
item_1696,
)?;
object_1697.finish();
}
}
array_1695.finish();
}
if let Some(var_1698) = &input.data_storage_config {
#[allow(unused_mut)]
let mut object_1699 = object.key("DataStorageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_inference_experiment_data_storage_config(
&mut object_1699,
var_1698,
)?;
object_1699.finish();
}
if let Some(var_1700) = &input.shadow_mode_config {
#[allow(unused_mut)]
let mut object_1701 = object.key("ShadowModeConfig").start_object();
crate::json_ser::serialize_structure_crate_model_shadow_mode_config(
&mut object_1701,
var_1700,
)?;
object_1701.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_model_card_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateModelCardInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1702) = &input.model_card_name {
object.key("ModelCardName").string(var_1702.as_str());
}
if let Some(var_1703) = &input.content {
object.key("Content").string(var_1703.as_str());
}
if let Some(var_1704) = &input.model_card_status {
object.key("ModelCardStatus").string(var_1704.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_model_package_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateModelPackageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1705) = &input.model_package_arn {
object.key("ModelPackageArn").string(var_1705.as_str());
}
if let Some(var_1706) = &input.model_approval_status {
object.key("ModelApprovalStatus").string(var_1706.as_str());
}
if let Some(var_1707) = &input.approval_description {
object.key("ApprovalDescription").string(var_1707.as_str());
}
if let Some(var_1708) = &input.customer_metadata_properties {
#[allow(unused_mut)]
let mut object_1709 = object.key("CustomerMetadataProperties").start_object();
for (key_1710, value_1711) in var_1708 {
{
object_1709
.key(key_1710.as_str())
.string(value_1711.as_str());
}
}
object_1709.finish();
}
if let Some(var_1712) = &input.customer_metadata_properties_to_remove {
let mut array_1713 = object
.key("CustomerMetadataPropertiesToRemove")
.start_array();
for item_1714 in var_1712 {
{
array_1713.value().string(item_1714.as_str());
}
}
array_1713.finish();
}
if let Some(var_1715) = &input.additional_inference_specifications_to_add {
let mut array_1716 = object
.key("AdditionalInferenceSpecificationsToAdd")
.start_array();
for item_1717 in var_1715 {
{
#[allow(unused_mut)]
let mut object_1718 = array_1716.value().start_object();
crate::json_ser::serialize_structure_crate_model_additional_inference_specification_definition(&mut object_1718, item_1717)?;
object_1718.finish();
}
}
array_1716.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_monitoring_alert_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateMonitoringAlertInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1719) = &input.monitoring_schedule_name {
object
.key("MonitoringScheduleName")
.string(var_1719.as_str());
}
if let Some(var_1720) = &input.monitoring_alert_name {
object.key("MonitoringAlertName").string(var_1720.as_str());
}
if let Some(var_1721) = &input.datapoints_to_alert {
object.key("DatapointsToAlert").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1721).into()),
);
}
if let Some(var_1722) = &input.evaluation_period {
object.key("EvaluationPeriod").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1722).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_monitoring_schedule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateMonitoringScheduleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1723) = &input.monitoring_schedule_name {
object
.key("MonitoringScheduleName")
.string(var_1723.as_str());
}
if let Some(var_1724) = &input.monitoring_schedule_config {
#[allow(unused_mut)]
let mut object_1725 = object.key("MonitoringScheduleConfig").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_schedule_config(
&mut object_1725,
var_1724,
)?;
object_1725.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_notebook_instance_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateNotebookInstanceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1726) = &input.notebook_instance_name {
object.key("NotebookInstanceName").string(var_1726.as_str());
}
if let Some(var_1727) = &input.instance_type {
object.key("InstanceType").string(var_1727.as_str());
}
if let Some(var_1728) = &input.role_arn {
object.key("RoleArn").string(var_1728.as_str());
}
if let Some(var_1729) = &input.lifecycle_config_name {
object.key("LifecycleConfigName").string(var_1729.as_str());
}
if input.disassociate_lifecycle_config {
object
.key("DisassociateLifecycleConfig")
.boolean(input.disassociate_lifecycle_config);
}
if let Some(var_1730) = &input.volume_size_in_gb {
object.key("VolumeSizeInGB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1730).into()),
);
}
if let Some(var_1731) = &input.default_code_repository {
object
.key("DefaultCodeRepository")
.string(var_1731.as_str());
}
if let Some(var_1732) = &input.additional_code_repositories {
let mut array_1733 = object.key("AdditionalCodeRepositories").start_array();
for item_1734 in var_1732 {
{
array_1733.value().string(item_1734.as_str());
}
}
array_1733.finish();
}
if let Some(var_1735) = &input.accelerator_types {
let mut array_1736 = object.key("AcceleratorTypes").start_array();
for item_1737 in var_1735 {
{
array_1736.value().string(item_1737.as_str());
}
}
array_1736.finish();
}
if input.disassociate_accelerator_types {
object
.key("DisassociateAcceleratorTypes")
.boolean(input.disassociate_accelerator_types);
}
if input.disassociate_default_code_repository {
object
.key("DisassociateDefaultCodeRepository")
.boolean(input.disassociate_default_code_repository);
}
if input.disassociate_additional_code_repositories {
object
.key("DisassociateAdditionalCodeRepositories")
.boolean(input.disassociate_additional_code_repositories);
}
if let Some(var_1738) = &input.root_access {
object.key("RootAccess").string(var_1738.as_str());
}
if let Some(var_1739) = &input.instance_metadata_service_configuration {
#[allow(unused_mut)]
let mut object_1740 = object
.key("InstanceMetadataServiceConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_instance_metadata_service_configuration(
&mut object_1740,
var_1739,
)?;
object_1740.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_notebook_instance_lifecycle_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateNotebookInstanceLifecycleConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1741) = &input.notebook_instance_lifecycle_config_name {
object
.key("NotebookInstanceLifecycleConfigName")
.string(var_1741.as_str());
}
if let Some(var_1742) = &input.on_create {
let mut array_1743 = object.key("OnCreate").start_array();
for item_1744 in var_1742 {
{
#[allow(unused_mut)]
let mut object_1745 = array_1743.value().start_object();
crate::json_ser::serialize_structure_crate_model_notebook_instance_lifecycle_hook(
&mut object_1745,
item_1744,
)?;
object_1745.finish();
}
}
array_1743.finish();
}
if let Some(var_1746) = &input.on_start {
let mut array_1747 = object.key("OnStart").start_array();
for item_1748 in var_1746 {
{
#[allow(unused_mut)]
let mut object_1749 = array_1747.value().start_object();
crate::json_ser::serialize_structure_crate_model_notebook_instance_lifecycle_hook(
&mut object_1749,
item_1748,
)?;
object_1749.finish();
}
}
array_1747.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_pipeline_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePipelineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1750) = &input.pipeline_name {
object.key("PipelineName").string(var_1750.as_str());
}
if let Some(var_1751) = &input.pipeline_display_name {
object.key("PipelineDisplayName").string(var_1751.as_str());
}
if let Some(var_1752) = &input.pipeline_definition {
object.key("PipelineDefinition").string(var_1752.as_str());
}
if let Some(var_1753) = &input.pipeline_definition_s3_location {
#[allow(unused_mut)]
let mut object_1754 = object.key("PipelineDefinitionS3Location").start_object();
crate::json_ser::serialize_structure_crate_model_pipeline_definition_s3_location(
&mut object_1754,
var_1753,
)?;
object_1754.finish();
}
if let Some(var_1755) = &input.pipeline_description {
object.key("PipelineDescription").string(var_1755.as_str());
}
if let Some(var_1756) = &input.role_arn {
object.key("RoleArn").string(var_1756.as_str());
}
if let Some(var_1757) = &input.parallelism_configuration {
#[allow(unused_mut)]
let mut object_1758 = object.key("ParallelismConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_parallelism_configuration(
&mut object_1758,
var_1757,
)?;
object_1758.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_pipeline_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePipelineExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1759) = &input.pipeline_execution_arn {
object.key("PipelineExecutionArn").string(var_1759.as_str());
}
if let Some(var_1760) = &input.pipeline_execution_description {
object
.key("PipelineExecutionDescription")
.string(var_1760.as_str());
}
if let Some(var_1761) = &input.pipeline_execution_display_name {
object
.key("PipelineExecutionDisplayName")
.string(var_1761.as_str());
}
if let Some(var_1762) = &input.parallelism_configuration {
#[allow(unused_mut)]
let mut object_1763 = object.key("ParallelismConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_parallelism_configuration(
&mut object_1763,
var_1762,
)?;
object_1763.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_project_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateProjectInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1764) = &input.project_name {
object.key("ProjectName").string(var_1764.as_str());
}
if let Some(var_1765) = &input.project_description {
object.key("ProjectDescription").string(var_1765.as_str());
}
if let Some(var_1766) = &input.service_catalog_provisioning_update_details {
#[allow(unused_mut)]
let mut object_1767 = object
.key("ServiceCatalogProvisioningUpdateDetails")
.start_object();
crate::json_ser::serialize_structure_crate_model_service_catalog_provisioning_update_details(&mut object_1767, var_1766)?;
object_1767.finish();
}
if let Some(var_1768) = &input.tags {
let mut array_1769 = object.key("Tags").start_array();
for item_1770 in var_1768 {
{
#[allow(unused_mut)]
let mut object_1771 = array_1769.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_1771, item_1770)?;
object_1771.finish();
}
}
array_1769.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_space_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSpaceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1772) = &input.domain_id {
object.key("DomainId").string(var_1772.as_str());
}
if let Some(var_1773) = &input.space_name {
object.key("SpaceName").string(var_1773.as_str());
}
if let Some(var_1774) = &input.space_settings {
#[allow(unused_mut)]
let mut object_1775 = object.key("SpaceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_space_settings(
&mut object_1775,
var_1774,
)?;
object_1775.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_training_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTrainingJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1776) = &input.training_job_name {
object.key("TrainingJobName").string(var_1776.as_str());
}
if let Some(var_1777) = &input.profiler_config {
#[allow(unused_mut)]
let mut object_1778 = object.key("ProfilerConfig").start_object();
crate::json_ser::serialize_structure_crate_model_profiler_config_for_update(
&mut object_1778,
var_1777,
)?;
object_1778.finish();
}
if let Some(var_1779) = &input.profiler_rule_configurations {
let mut array_1780 = object.key("ProfilerRuleConfigurations").start_array();
for item_1781 in var_1779 {
{
#[allow(unused_mut)]
let mut object_1782 = array_1780.value().start_object();
crate::json_ser::serialize_structure_crate_model_profiler_rule_configuration(
&mut object_1782,
item_1781,
)?;
object_1782.finish();
}
}
array_1780.finish();
}
if let Some(var_1783) = &input.resource_config {
#[allow(unused_mut)]
let mut object_1784 = object.key("ResourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_resource_config_for_update(
&mut object_1784,
var_1783,
)?;
object_1784.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_trial_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTrialInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1785) = &input.trial_name {
object.key("TrialName").string(var_1785.as_str());
}
if let Some(var_1786) = &input.display_name {
object.key("DisplayName").string(var_1786.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_trial_component_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTrialComponentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1787) = &input.trial_component_name {
object.key("TrialComponentName").string(var_1787.as_str());
}
if let Some(var_1788) = &input.display_name {
object.key("DisplayName").string(var_1788.as_str());
}
if let Some(var_1789) = &input.status {
#[allow(unused_mut)]
let mut object_1790 = object.key("Status").start_object();
crate::json_ser::serialize_structure_crate_model_trial_component_status(
&mut object_1790,
var_1789,
)?;
object_1790.finish();
}
if let Some(var_1791) = &input.start_time {
object
.key("StartTime")
.date_time(var_1791, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1792) = &input.end_time {
object
.key("EndTime")
.date_time(var_1792, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_1793) = &input.parameters {
#[allow(unused_mut)]
let mut object_1794 = object.key("Parameters").start_object();
for (key_1795, value_1796) in var_1793 {
{
#[allow(unused_mut)]
let mut object_1797 = object_1794.key(key_1795.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_trial_component_parameter_value(
&mut object_1797,
value_1796,
)?;
object_1797.finish();
}
}
object_1794.finish();
}
if let Some(var_1798) = &input.parameters_to_remove {
let mut array_1799 = object.key("ParametersToRemove").start_array();
for item_1800 in var_1798 {
{
array_1799.value().string(item_1800.as_str());
}
}
array_1799.finish();
}
if let Some(var_1801) = &input.input_artifacts {
#[allow(unused_mut)]
let mut object_1802 = object.key("InputArtifacts").start_object();
for (key_1803, value_1804) in var_1801 {
{
#[allow(unused_mut)]
let mut object_1805 = object_1802.key(key_1803.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_trial_component_artifact(
&mut object_1805,
value_1804,
)?;
object_1805.finish();
}
}
object_1802.finish();
}
if let Some(var_1806) = &input.input_artifacts_to_remove {
let mut array_1807 = object.key("InputArtifactsToRemove").start_array();
for item_1808 in var_1806 {
{
array_1807.value().string(item_1808.as_str());
}
}
array_1807.finish();
}
if let Some(var_1809) = &input.output_artifacts {
#[allow(unused_mut)]
let mut object_1810 = object.key("OutputArtifacts").start_object();
for (key_1811, value_1812) in var_1809 {
{
#[allow(unused_mut)]
let mut object_1813 = object_1810.key(key_1811.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_trial_component_artifact(
&mut object_1813,
value_1812,
)?;
object_1813.finish();
}
}
object_1810.finish();
}
if let Some(var_1814) = &input.output_artifacts_to_remove {
let mut array_1815 = object.key("OutputArtifactsToRemove").start_array();
for item_1816 in var_1814 {
{
array_1815.value().string(item_1816.as_str());
}
}
array_1815.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_user_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateUserProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1817) = &input.domain_id {
object.key("DomainId").string(var_1817.as_str());
}
if let Some(var_1818) = &input.user_profile_name {
object.key("UserProfileName").string(var_1818.as_str());
}
if let Some(var_1819) = &input.user_settings {
#[allow(unused_mut)]
let mut object_1820 = object.key("UserSettings").start_object();
crate::json_ser::serialize_structure_crate_model_user_settings(&mut object_1820, var_1819)?;
object_1820.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_workforce_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateWorkforceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1821) = &input.workforce_name {
object.key("WorkforceName").string(var_1821.as_str());
}
if let Some(var_1822) = &input.source_ip_config {
#[allow(unused_mut)]
let mut object_1823 = object.key("SourceIpConfig").start_object();
crate::json_ser::serialize_structure_crate_model_source_ip_config(
&mut object_1823,
var_1822,
)?;
object_1823.finish();
}
if let Some(var_1824) = &input.oidc_config {
#[allow(unused_mut)]
let mut object_1825 = object.key("OidcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_oidc_config(&mut object_1825, var_1824)?;
object_1825.finish();
}
if let Some(var_1826) = &input.workforce_vpc_config {
#[allow(unused_mut)]
let mut object_1827 = object.key("WorkforceVpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_workforce_vpc_config_request(
&mut object_1827,
var_1826,
)?;
object_1827.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_workteam_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateWorkteamInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1828) = &input.workteam_name {
object.key("WorkteamName").string(var_1828.as_str());
}
if let Some(var_1829) = &input.member_definitions {
let mut array_1830 = object.key("MemberDefinitions").start_array();
for item_1831 in var_1829 {
{
#[allow(unused_mut)]
let mut object_1832 = array_1830.value().start_object();
crate::json_ser::serialize_structure_crate_model_member_definition(
&mut object_1832,
item_1831,
)?;
object_1832.finish();
}
}
array_1830.finish();
}
if let Some(var_1833) = &input.description {
object.key("Description").string(var_1833.as_str());
}
if let Some(var_1834) = &input.notification_configuration {
#[allow(unused_mut)]
let mut object_1835 = object.key("NotificationConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_notification_configuration(
&mut object_1835,
var_1834,
)?;
object_1835.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1836) = &input.key {
object.key("Key").string(var_1836.as_str());
}
if let Some(var_1837) = &input.value {
object.key("Value").string(var_1837.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_action_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1838) = &input.source_uri {
object.key("SourceUri").string(var_1838.as_str());
}
if let Some(var_1839) = &input.source_type {
object.key("SourceType").string(var_1839.as_str());
}
if let Some(var_1840) = &input.source_id {
object.key("SourceId").string(var_1840.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_metadata_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MetadataProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1841) = &input.commit_id {
object.key("CommitId").string(var_1841.as_str());
}
if let Some(var_1842) = &input.repository {
object.key("Repository").string(var_1842.as_str());
}
if let Some(var_1843) = &input.generated_by {
object.key("GeneratedBy").string(var_1843.as_str());
}
if let Some(var_1844) = &input.project_id {
object.key("ProjectId").string(var_1844.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_training_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TrainingSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1845) = &input.training_image {
object.key("TrainingImage").string(var_1845.as_str());
}
if let Some(var_1846) = &input.training_image_digest {
object.key("TrainingImageDigest").string(var_1846.as_str());
}
if let Some(var_1847) = &input.supported_hyper_parameters {
let mut array_1848 = object.key("SupportedHyperParameters").start_array();
for item_1849 in var_1847 {
{
#[allow(unused_mut)]
let mut object_1850 = array_1848.value().start_object();
crate::json_ser::serialize_structure_crate_model_hyper_parameter_specification(
&mut object_1850,
item_1849,
)?;
object_1850.finish();
}
}
array_1848.finish();
}
if let Some(var_1851) = &input.supported_training_instance_types {
let mut array_1852 = object.key("SupportedTrainingInstanceTypes").start_array();
for item_1853 in var_1851 {
{
array_1852.value().string(item_1853.as_str());
}
}
array_1852.finish();
}
if input.supports_distributed_training {
object
.key("SupportsDistributedTraining")
.boolean(input.supports_distributed_training);
}
if let Some(var_1854) = &input.metric_definitions {
let mut array_1855 = object.key("MetricDefinitions").start_array();
for item_1856 in var_1854 {
{
#[allow(unused_mut)]
let mut object_1857 = array_1855.value().start_object();
crate::json_ser::serialize_structure_crate_model_metric_definition(
&mut object_1857,
item_1856,
)?;
object_1857.finish();
}
}
array_1855.finish();
}
if let Some(var_1858) = &input.training_channels {
let mut array_1859 = object.key("TrainingChannels").start_array();
for item_1860 in var_1858 {
{
#[allow(unused_mut)]
let mut object_1861 = array_1859.value().start_object();
crate::json_ser::serialize_structure_crate_model_channel_specification(
&mut object_1861,
item_1860,
)?;
object_1861.finish();
}
}
array_1859.finish();
}
if let Some(var_1862) = &input.supported_tuning_job_objective_metrics {
let mut array_1863 = object
.key("SupportedTuningJobObjectiveMetrics")
.start_array();
for item_1864 in var_1862 {
{
#[allow(unused_mut)]
let mut object_1865 = array_1863.value().start_object();
crate::json_ser::serialize_structure_crate_model_hyper_parameter_tuning_job_objective(&mut object_1865, item_1864)?;
object_1865.finish();
}
}
array_1863.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_inference_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InferenceSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1866) = &input.containers {
let mut array_1867 = object.key("Containers").start_array();
for item_1868 in var_1866 {
{
#[allow(unused_mut)]
let mut object_1869 = array_1867.value().start_object();
crate::json_ser::serialize_structure_crate_model_model_package_container_definition(&mut object_1869, item_1868)?;
object_1869.finish();
}
}
array_1867.finish();
}
if let Some(var_1870) = &input.supported_transform_instance_types {
let mut array_1871 = object.key("SupportedTransformInstanceTypes").start_array();
for item_1872 in var_1870 {
{
array_1871.value().string(item_1872.as_str());
}
}
array_1871.finish();
}
if let Some(var_1873) = &input.supported_realtime_inference_instance_types {
let mut array_1874 = object
.key("SupportedRealtimeInferenceInstanceTypes")
.start_array();
for item_1875 in var_1873 {
{
array_1874.value().string(item_1875.as_str());
}
}
array_1874.finish();
}
if let Some(var_1876) = &input.supported_content_types {
let mut array_1877 = object.key("SupportedContentTypes").start_array();
for item_1878 in var_1876 {
{
array_1877.value().string(item_1878.as_str());
}
}
array_1877.finish();
}
if let Some(var_1879) = &input.supported_response_mime_types {
let mut array_1880 = object.key("SupportedResponseMIMETypes").start_array();
for item_1881 in var_1879 {
{
array_1880.value().string(item_1881.as_str());
}
}
array_1880.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_algorithm_validation_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AlgorithmValidationSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1882) = &input.validation_role {
object.key("ValidationRole").string(var_1882.as_str());
}
if let Some(var_1883) = &input.validation_profiles {
let mut array_1884 = object.key("ValidationProfiles").start_array();
for item_1885 in var_1883 {
{
#[allow(unused_mut)]
let mut object_1886 = array_1884.value().start_object();
crate::json_ser::serialize_structure_crate_model_algorithm_validation_profile(
&mut object_1886,
item_1885,
)?;
object_1886.finish();
}
}
array_1884.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_spec(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceSpec,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1887) = &input.sage_maker_image_arn {
object.key("SageMakerImageArn").string(var_1887.as_str());
}
if let Some(var_1888) = &input.sage_maker_image_version_arn {
object
.key("SageMakerImageVersionArn")
.string(var_1888.as_str());
}
if let Some(var_1889) = &input.instance_type {
object.key("InstanceType").string(var_1889.as_str());
}
if let Some(var_1890) = &input.lifecycle_config_arn {
object.key("LifecycleConfigArn").string(var_1890.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_kernel_gateway_image_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KernelGatewayImageConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1891) = &input.kernel_specs {
let mut array_1892 = object.key("KernelSpecs").start_array();
for item_1893 in var_1891 {
{
#[allow(unused_mut)]
let mut object_1894 = array_1892.value().start_object();
crate::json_ser::serialize_structure_crate_model_kernel_spec(
&mut object_1894,
item_1893,
)?;
object_1894.finish();
}
}
array_1892.finish();
}
if let Some(var_1895) = &input.file_system_config {
#[allow(unused_mut)]
let mut object_1896 = object.key("FileSystemConfig").start_object();
crate::json_ser::serialize_structure_crate_model_file_system_config(
&mut object_1896,
var_1895,
)?;
object_1896.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_artifact_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ArtifactSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1897) = &input.source_uri {
object.key("SourceUri").string(var_1897.as_str());
}
if let Some(var_1898) = &input.source_types {
let mut array_1899 = object.key("SourceTypes").start_array();
for item_1900 in var_1898 {
{
#[allow(unused_mut)]
let mut object_1901 = array_1899.value().start_object();
crate::json_ser::serialize_structure_crate_model_artifact_source_type(
&mut object_1901,
item_1900,
)?;
object_1901.finish();
}
}
array_1899.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_ml_channel(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoMlChannel,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1902) = &input.data_source {
#[allow(unused_mut)]
let mut object_1903 = object.key("DataSource").start_object();
crate::json_ser::serialize_structure_crate_model_auto_ml_data_source(
&mut object_1903,
var_1902,
)?;
object_1903.finish();
}
if let Some(var_1904) = &input.compression_type {
object.key("CompressionType").string(var_1904.as_str());
}
if let Some(var_1905) = &input.target_attribute_name {
object.key("TargetAttributeName").string(var_1905.as_str());
}
if let Some(var_1906) = &input.content_type {
object.key("ContentType").string(var_1906.as_str());
}
if let Some(var_1907) = &input.channel_type {
object.key("ChannelType").string(var_1907.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_ml_output_data_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoMlOutputDataConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1908) = &input.kms_key_id {
object.key("KmsKeyId").string(var_1908.as_str());
}
if let Some(var_1909) = &input.s3_output_path {
object.key("S3OutputPath").string(var_1909.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_ml_job_objective(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoMlJobObjective,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1910) = &input.metric_name {
object.key("MetricName").string(var_1910.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_ml_job_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoMlJobConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1911) = &input.completion_criteria {
#[allow(unused_mut)]
let mut object_1912 = object.key("CompletionCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_auto_ml_job_completion_criteria(
&mut object_1912,
var_1911,
)?;
object_1912.finish();
}
if let Some(var_1913) = &input.security_config {
#[allow(unused_mut)]
let mut object_1914 = object.key("SecurityConfig").start_object();
crate::json_ser::serialize_structure_crate_model_auto_ml_security_config(
&mut object_1914,
var_1913,
)?;
object_1914.finish();
}
if let Some(var_1915) = &input.data_split_config {
#[allow(unused_mut)]
let mut object_1916 = object.key("DataSplitConfig").start_object();
crate::json_ser::serialize_structure_crate_model_auto_ml_data_split_config(
&mut object_1916,
var_1915,
)?;
object_1916.finish();
}
if let Some(var_1917) = &input.candidate_generation_config {
#[allow(unused_mut)]
let mut object_1918 = object.key("CandidateGenerationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_auto_ml_candidate_generation_config(
&mut object_1918,
var_1917,
)?;
object_1918.finish();
}
if let Some(var_1919) = &input.mode {
object.key("Mode").string(var_1919.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_model_deploy_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelDeployConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.auto_generate_endpoint_name {
object
.key("AutoGenerateEndpointName")
.boolean(input.auto_generate_endpoint_name);
}
if let Some(var_1920) = &input.endpoint_name {
object.key("EndpointName").string(var_1920.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_git_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GitConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1921) = &input.repository_url {
object.key("RepositoryUrl").string(var_1921.as_str());
}
if let Some(var_1922) = &input.branch {
object.key("Branch").string(var_1922.as_str());
}
if let Some(var_1923) = &input.secret_arn {
object.key("SecretArn").string(var_1923.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_input_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InputConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1924) = &input.s3_uri {
object.key("S3Uri").string(var_1924.as_str());
}
if let Some(var_1925) = &input.data_input_config {
object.key("DataInputConfig").string(var_1925.as_str());
}
if let Some(var_1926) = &input.framework {
object.key("Framework").string(var_1926.as_str());
}
if let Some(var_1927) = &input.framework_version {
object.key("FrameworkVersion").string(var_1927.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_output_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OutputConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1928) = &input.s3_output_location {
object.key("S3OutputLocation").string(var_1928.as_str());
}
if let Some(var_1929) = &input.target_device {
object.key("TargetDevice").string(var_1929.as_str());
}
if let Some(var_1930) = &input.target_platform {
#[allow(unused_mut)]
let mut object_1931 = object.key("TargetPlatform").start_object();
crate::json_ser::serialize_structure_crate_model_target_platform(
&mut object_1931,
var_1930,
)?;
object_1931.finish();
}
if let Some(var_1932) = &input.compiler_options {
object.key("CompilerOptions").string(var_1932.as_str());
}
if let Some(var_1933) = &input.kms_key_id {
object.key("KmsKeyId").string(var_1933.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_neo_vpc_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NeoVpcConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1934) = &input.security_group_ids {
let mut array_1935 = object.key("SecurityGroupIds").start_array();
for item_1936 in var_1934 {
{
array_1935.value().string(item_1936.as_str());
}
}
array_1935.finish();
}
if let Some(var_1937) = &input.subnets {
let mut array_1938 = object.key("Subnets").start_array();
for item_1939 in var_1937 {
{
array_1938.value().string(item_1939.as_str());
}
}
array_1938.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_stopping_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StoppingCondition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.max_runtime_in_seconds != 0 {
object.key("MaxRuntimeInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_runtime_in_seconds).into()),
);
}
if let Some(var_1940) = &input.max_wait_time_in_seconds {
object.key("MaxWaitTimeInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1940).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_context_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContextSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1941) = &input.source_uri {
object.key("SourceUri").string(var_1941.as_str());
}
if let Some(var_1942) = &input.source_type {
object.key("SourceType").string(var_1942.as_str());
}
if let Some(var_1943) = &input.source_id {
object.key("SourceId").string(var_1943.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_quality_baseline_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataQualityBaselineConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1944) = &input.baselining_job_name {
object.key("BaseliningJobName").string(var_1944.as_str());
}
if let Some(var_1945) = &input.constraints_resource {
#[allow(unused_mut)]
let mut object_1946 = object.key("ConstraintsResource").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_constraints_resource(
&mut object_1946,
var_1945,
)?;
object_1946.finish();
}
if let Some(var_1947) = &input.statistics_resource {
#[allow(unused_mut)]
let mut object_1948 = object.key("StatisticsResource").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_statistics_resource(
&mut object_1948,
var_1947,
)?;
object_1948.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_data_quality_app_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataQualityAppSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1949) = &input.image_uri {
object.key("ImageUri").string(var_1949.as_str());
}
if let Some(var_1950) = &input.container_entrypoint {
let mut array_1951 = object.key("ContainerEntrypoint").start_array();
for item_1952 in var_1950 {
{
array_1951.value().string(item_1952.as_str());
}
}
array_1951.finish();
}
if let Some(var_1953) = &input.container_arguments {
let mut array_1954 = object.key("ContainerArguments").start_array();
for item_1955 in var_1953 {
{
array_1954.value().string(item_1955.as_str());
}
}
array_1954.finish();
}
if let Some(var_1956) = &input.record_preprocessor_source_uri {
object
.key("RecordPreprocessorSourceUri")
.string(var_1956.as_str());
}
if let Some(var_1957) = &input.post_analytics_processor_source_uri {
object
.key("PostAnalyticsProcessorSourceUri")
.string(var_1957.as_str());
}
if let Some(var_1958) = &input.environment {
#[allow(unused_mut)]
let mut object_1959 = object.key("Environment").start_object();
for (key_1960, value_1961) in var_1958 {
{
object_1959
.key(key_1960.as_str())
.string(value_1961.as_str());
}
}
object_1959.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_data_quality_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataQualityJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1962) = &input.endpoint_input {
#[allow(unused_mut)]
let mut object_1963 = object.key("EndpointInput").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_input(
&mut object_1963,
var_1962,
)?;
object_1963.finish();
}
if let Some(var_1964) = &input.batch_transform_input {
#[allow(unused_mut)]
let mut object_1965 = object.key("BatchTransformInput").start_object();
crate::json_ser::serialize_structure_crate_model_batch_transform_input(
&mut object_1965,
var_1964,
)?;
object_1965.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_output_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringOutputConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1966) = &input.monitoring_outputs {
let mut array_1967 = object.key("MonitoringOutputs").start_array();
for item_1968 in var_1966 {
{
#[allow(unused_mut)]
let mut object_1969 = array_1967.value().start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_output(
&mut object_1969,
item_1968,
)?;
object_1969.finish();
}
}
array_1967.finish();
}
if let Some(var_1970) = &input.kms_key_id {
object.key("KmsKeyId").string(var_1970.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_resources(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringResources,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1971) = &input.cluster_config {
#[allow(unused_mut)]
let mut object_1972 = object.key("ClusterConfig").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_cluster_config(
&mut object_1972,
var_1971,
)?;
object_1972.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_network_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringNetworkConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enable_inter_container_traffic_encryption {
object
.key("EnableInterContainerTrafficEncryption")
.boolean(input.enable_inter_container_traffic_encryption);
}
if input.enable_network_isolation {
object
.key("EnableNetworkIsolation")
.boolean(input.enable_network_isolation);
}
if let Some(var_1973) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_1974 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_1974, var_1973)?;
object_1974.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_stopping_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringStoppingCondition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("MaxRuntimeInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_runtime_in_seconds).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_edge_output_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EdgeOutputConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1975) = &input.s3_output_location {
object.key("S3OutputLocation").string(var_1975.as_str());
}
if let Some(var_1976) = &input.kms_key_id {
object.key("KmsKeyId").string(var_1976.as_str());
}
if let Some(var_1977) = &input.preset_deployment_type {
object.key("PresetDeploymentType").string(var_1977.as_str());
}
if let Some(var_1978) = &input.preset_deployment_config {
object
.key("PresetDeploymentConfig")
.string(var_1978.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_user_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UserSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1979) = &input.execution_role {
object.key("ExecutionRole").string(var_1979.as_str());
}
if let Some(var_1980) = &input.security_groups {
let mut array_1981 = object.key("SecurityGroups").start_array();
for item_1982 in var_1980 {
{
array_1981.value().string(item_1982.as_str());
}
}
array_1981.finish();
}
if let Some(var_1983) = &input.sharing_settings {
#[allow(unused_mut)]
let mut object_1984 = object.key("SharingSettings").start_object();
crate::json_ser::serialize_structure_crate_model_sharing_settings(
&mut object_1984,
var_1983,
)?;
object_1984.finish();
}
if let Some(var_1985) = &input.jupyter_server_app_settings {
#[allow(unused_mut)]
let mut object_1986 = object.key("JupyterServerAppSettings").start_object();
crate::json_ser::serialize_structure_crate_model_jupyter_server_app_settings(
&mut object_1986,
var_1985,
)?;
object_1986.finish();
}
if let Some(var_1987) = &input.kernel_gateway_app_settings {
#[allow(unused_mut)]
let mut object_1988 = object.key("KernelGatewayAppSettings").start_object();
crate::json_ser::serialize_structure_crate_model_kernel_gateway_app_settings(
&mut object_1988,
var_1987,
)?;
object_1988.finish();
}
if let Some(var_1989) = &input.tensor_board_app_settings {
#[allow(unused_mut)]
let mut object_1990 = object.key("TensorBoardAppSettings").start_object();
crate::json_ser::serialize_structure_crate_model_tensor_board_app_settings(
&mut object_1990,
var_1989,
)?;
object_1990.finish();
}
if let Some(var_1991) = &input.r_studio_server_pro_app_settings {
#[allow(unused_mut)]
let mut object_1992 = object.key("RStudioServerProAppSettings").start_object();
crate::json_ser::serialize_structure_crate_model_r_studio_server_pro_app_settings(
&mut object_1992,
var_1991,
)?;
object_1992.finish();
}
if let Some(var_1993) = &input.r_session_app_settings {
#[allow(unused_mut)]
let mut object_1994 = object.key("RSessionAppSettings").start_object();
crate::json_ser::serialize_structure_crate_model_r_session_app_settings(
&mut object_1994,
var_1993,
)?;
object_1994.finish();
}
if let Some(var_1995) = &input.canvas_app_settings {
#[allow(unused_mut)]
let mut object_1996 = object.key("CanvasAppSettings").start_object();
crate::json_ser::serialize_structure_crate_model_canvas_app_settings(
&mut object_1996,
var_1995,
)?;
object_1996.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_domain_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DomainSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1997) = &input.security_group_ids {
let mut array_1998 = object.key("SecurityGroupIds").start_array();
for item_1999 in var_1997 {
{
array_1998.value().string(item_1999.as_str());
}
}
array_1998.finish();
}
if let Some(var_2000) = &input.r_studio_server_pro_domain_settings {
#[allow(unused_mut)]
let mut object_2001 = object.key("RStudioServerProDomainSettings").start_object();
crate::json_ser::serialize_structure_crate_model_r_studio_server_pro_domain_settings(
&mut object_2001,
var_2000,
)?;
object_2001.finish();
}
if let Some(var_2002) = &input.execution_role_identity_config {
object
.key("ExecutionRoleIdentityConfig")
.string(var_2002.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_default_space_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DefaultSpaceSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2003) = &input.execution_role {
object.key("ExecutionRole").string(var_2003.as_str());
}
if let Some(var_2004) = &input.security_groups {
let mut array_2005 = object.key("SecurityGroups").start_array();
for item_2006 in var_2004 {
{
array_2005.value().string(item_2006.as_str());
}
}
array_2005.finish();
}
if let Some(var_2007) = &input.jupyter_server_app_settings {
#[allow(unused_mut)]
let mut object_2008 = object.key("JupyterServerAppSettings").start_object();
crate::json_ser::serialize_structure_crate_model_jupyter_server_app_settings(
&mut object_2008,
var_2007,
)?;
object_2008.finish();
}
if let Some(var_2009) = &input.kernel_gateway_app_settings {
#[allow(unused_mut)]
let mut object_2010 = object.key("KernelGatewayAppSettings").start_object();
crate::json_ser::serialize_structure_crate_model_kernel_gateway_app_settings(
&mut object_2010,
var_2009,
)?;
object_2010.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_edge_deployment_model_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EdgeDeploymentModelConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2011) = &input.model_handle {
object.key("ModelHandle").string(var_2011.as_str());
}
if let Some(var_2012) = &input.edge_packaging_job_name {
object.key("EdgePackagingJobName").string(var_2012.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_deployment_stage(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeploymentStage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2013) = &input.stage_name {
object.key("StageName").string(var_2013.as_str());
}
if let Some(var_2014) = &input.device_selection_config {
#[allow(unused_mut)]
let mut object_2015 = object.key("DeviceSelectionConfig").start_object();
crate::json_ser::serialize_structure_crate_model_device_selection_config(
&mut object_2015,
var_2014,
)?;
object_2015.finish();
}
if let Some(var_2016) = &input.deployment_config {
#[allow(unused_mut)]
let mut object_2017 = object.key("DeploymentConfig").start_object();
crate::json_ser::serialize_structure_crate_model_edge_deployment_config(
&mut object_2017,
var_2016,
)?;
object_2017.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_deployment_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeploymentConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2018) = &input.blue_green_update_policy {
#[allow(unused_mut)]
let mut object_2019 = object.key("BlueGreenUpdatePolicy").start_object();
crate::json_ser::serialize_structure_crate_model_blue_green_update_policy(
&mut object_2019,
var_2018,
)?;
object_2019.finish();
}
if let Some(var_2020) = &input.auto_rollback_configuration {
#[allow(unused_mut)]
let mut object_2021 = object.key("AutoRollbackConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_auto_rollback_config(
&mut object_2021,
var_2020,
)?;
object_2021.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_production_variant(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProductionVariant,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2022) = &input.variant_name {
object.key("VariantName").string(var_2022.as_str());
}
if let Some(var_2023) = &input.model_name {
object.key("ModelName").string(var_2023.as_str());
}
if let Some(var_2024) = &input.initial_instance_count {
object.key("InitialInstanceCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2024).into()),
);
}
if let Some(var_2025) = &input.instance_type {
object.key("InstanceType").string(var_2025.as_str());
}
if let Some(var_2026) = &input.initial_variant_weight {
object.key("InitialVariantWeight").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_2026).into()),
);
}
if let Some(var_2027) = &input.accelerator_type {
object.key("AcceleratorType").string(var_2027.as_str());
}
if let Some(var_2028) = &input.core_dump_config {
#[allow(unused_mut)]
let mut object_2029 = object.key("CoreDumpConfig").start_object();
crate::json_ser::serialize_structure_crate_model_production_variant_core_dump_config(
&mut object_2029,
var_2028,
)?;
object_2029.finish();
}
if let Some(var_2030) = &input.serverless_config {
#[allow(unused_mut)]
let mut object_2031 = object.key("ServerlessConfig").start_object();
crate::json_ser::serialize_structure_crate_model_production_variant_serverless_config(
&mut object_2031,
var_2030,
)?;
object_2031.finish();
}
if let Some(var_2032) = &input.volume_size_in_gb {
object.key("VolumeSizeInGB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2032).into()),
);
}
if let Some(var_2033) = &input.model_data_download_timeout_in_seconds {
object.key("ModelDataDownloadTimeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2033).into()),
);
}
if let Some(var_2034) = &input.container_startup_health_check_timeout_in_seconds {
object
.key("ContainerStartupHealthCheckTimeoutInSeconds")
.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2034).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_data_capture_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataCaptureConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enable_capture {
object.key("EnableCapture").boolean(input.enable_capture);
}
if let Some(var_2035) = &input.initial_sampling_percentage {
object.key("InitialSamplingPercentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2035).into()),
);
}
if let Some(var_2036) = &input.destination_s3_uri {
object.key("DestinationS3Uri").string(var_2036.as_str());
}
if let Some(var_2037) = &input.kms_key_id {
object.key("KmsKeyId").string(var_2037.as_str());
}
if let Some(var_2038) = &input.capture_options {
let mut array_2039 = object.key("CaptureOptions").start_array();
for item_2040 in var_2038 {
{
#[allow(unused_mut)]
let mut object_2041 = array_2039.value().start_object();
crate::json_ser::serialize_structure_crate_model_capture_option(
&mut object_2041,
item_2040,
)?;
object_2041.finish();
}
}
array_2039.finish();
}
if let Some(var_2042) = &input.capture_content_type_header {
#[allow(unused_mut)]
let mut object_2043 = object.key("CaptureContentTypeHeader").start_object();
crate::json_ser::serialize_structure_crate_model_capture_content_type_header(
&mut object_2043,
var_2042,
)?;
object_2043.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_async_inference_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AsyncInferenceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2044) = &input.client_config {
#[allow(unused_mut)]
let mut object_2045 = object.key("ClientConfig").start_object();
crate::json_ser::serialize_structure_crate_model_async_inference_client_config(
&mut object_2045,
var_2044,
)?;
object_2045.finish();
}
if let Some(var_2046) = &input.output_config {
#[allow(unused_mut)]
let mut object_2047 = object.key("OutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_async_inference_output_config(
&mut object_2047,
var_2046,
)?;
object_2047.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_explainer_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExplainerConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2048) = &input.clarify_explainer_config {
#[allow(unused_mut)]
let mut object_2049 = object.key("ClarifyExplainerConfig").start_object();
crate::json_ser::serialize_structure_crate_model_clarify_explainer_config(
&mut object_2049,
var_2048,
)?;
object_2049.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_feature_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FeatureDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2050) = &input.feature_name {
object.key("FeatureName").string(var_2050.as_str());
}
if let Some(var_2051) = &input.feature_type {
object.key("FeatureType").string(var_2051.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_online_store_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OnlineStoreConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2052) = &input.security_config {
#[allow(unused_mut)]
let mut object_2053 = object.key("SecurityConfig").start_object();
crate::json_ser::serialize_structure_crate_model_online_store_security_config(
&mut object_2053,
var_2052,
)?;
object_2053.finish();
}
if input.enable_online_store {
object
.key("EnableOnlineStore")
.boolean(input.enable_online_store);
}
Ok(())
}
pub fn serialize_structure_crate_model_offline_store_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OfflineStoreConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2054) = &input.s3_storage_config {
#[allow(unused_mut)]
let mut object_2055 = object.key("S3StorageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_s3_storage_config(
&mut object_2055,
var_2054,
)?;
object_2055.finish();
}
if input.disable_glue_table_creation {
object
.key("DisableGlueTableCreation")
.boolean(input.disable_glue_table_creation);
}
if let Some(var_2056) = &input.data_catalog_config {
#[allow(unused_mut)]
let mut object_2057 = object.key("DataCatalogConfig").start_object();
crate::json_ser::serialize_structure_crate_model_data_catalog_config(
&mut object_2057,
var_2056,
)?;
object_2057.finish();
}
if let Some(var_2058) = &input.table_format {
object.key("TableFormat").string(var_2058.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_human_loop_request_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HumanLoopRequestSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2059) = &input.aws_managed_human_loop_request_source {
object
.key("AwsManagedHumanLoopRequestSource")
.string(var_2059.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_human_loop_activation_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HumanLoopActivationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2060) = &input.human_loop_activation_conditions_config {
#[allow(unused_mut)]
let mut object_2061 = object
.key("HumanLoopActivationConditionsConfig")
.start_object();
crate::json_ser::serialize_structure_crate_model_human_loop_activation_conditions_config(
&mut object_2061,
var_2060,
)?;
object_2061.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_human_loop_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HumanLoopConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2062) = &input.workteam_arn {
object.key("WorkteamArn").string(var_2062.as_str());
}
if let Some(var_2063) = &input.human_task_ui_arn {
object.key("HumanTaskUiArn").string(var_2063.as_str());
}
if let Some(var_2064) = &input.task_title {
object.key("TaskTitle").string(var_2064.as_str());
}
if let Some(var_2065) = &input.task_description {
object.key("TaskDescription").string(var_2065.as_str());
}
if let Some(var_2066) = &input.task_count {
object.key("TaskCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2066).into()),
);
}
if let Some(var_2067) = &input.task_availability_lifetime_in_seconds {
object.key("TaskAvailabilityLifetimeInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2067).into()),
);
}
if let Some(var_2068) = &input.task_time_limit_in_seconds {
object.key("TaskTimeLimitInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2068).into()),
);
}
if let Some(var_2069) = &input.task_keywords {
let mut array_2070 = object.key("TaskKeywords").start_array();
for item_2071 in var_2069 {
{
array_2070.value().string(item_2071.as_str());
}
}
array_2070.finish();
}
if let Some(var_2072) = &input.public_workforce_task_price {
#[allow(unused_mut)]
let mut object_2073 = object.key("PublicWorkforceTaskPrice").start_object();
crate::json_ser::serialize_structure_crate_model_public_workforce_task_price(
&mut object_2073,
var_2072,
)?;
object_2073.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_flow_definition_output_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FlowDefinitionOutputConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2074) = &input.s3_output_path {
object.key("S3OutputPath").string(var_2074.as_str());
}
if let Some(var_2075) = &input.kms_key_id {
object.key("KmsKeyId").string(var_2075.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_hub_s3_storage_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HubS3StorageConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2076) = &input.s3_output_path {
object.key("S3OutputPath").string(var_2076.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ui_template(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UiTemplate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2077) = &input.content {
object.key("Content").string(var_2077.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_hyper_parameter_tuning_job_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HyperParameterTuningJobConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2078) = &input.strategy {
object.key("Strategy").string(var_2078.as_str());
}
if let Some(var_2079) = &input.strategy_config {
#[allow(unused_mut)]
let mut object_2080 = object.key("StrategyConfig").start_object();
crate::json_ser::serialize_structure_crate_model_hyper_parameter_tuning_job_strategy_config(&mut object_2080, var_2079)?;
object_2080.finish();
}
if let Some(var_2081) = &input.hyper_parameter_tuning_job_objective {
#[allow(unused_mut)]
let mut object_2082 = object
.key("HyperParameterTuningJobObjective")
.start_object();
crate::json_ser::serialize_structure_crate_model_hyper_parameter_tuning_job_objective(
&mut object_2082,
var_2081,
)?;
object_2082.finish();
}
if let Some(var_2083) = &input.resource_limits {
#[allow(unused_mut)]
let mut object_2084 = object.key("ResourceLimits").start_object();
crate::json_ser::serialize_structure_crate_model_resource_limits(
&mut object_2084,
var_2083,
)?;
object_2084.finish();
}
if let Some(var_2085) = &input.parameter_ranges {
#[allow(unused_mut)]
let mut object_2086 = object.key("ParameterRanges").start_object();
crate::json_ser::serialize_structure_crate_model_parameter_ranges(
&mut object_2086,
var_2085,
)?;
object_2086.finish();
}
if let Some(var_2087) = &input.training_job_early_stopping_type {
object
.key("TrainingJobEarlyStoppingType")
.string(var_2087.as_str());
}
if let Some(var_2088) = &input.tuning_job_completion_criteria {
#[allow(unused_mut)]
let mut object_2089 = object.key("TuningJobCompletionCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_tuning_job_completion_criteria(
&mut object_2089,
var_2088,
)?;
object_2089.finish();
}
if let Some(var_2090) = &input.random_seed {
object.key("RandomSeed").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2090).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_hyper_parameter_training_job_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HyperParameterTrainingJobDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2091) = &input.definition_name {
object.key("DefinitionName").string(var_2091.as_str());
}
if let Some(var_2092) = &input.tuning_objective {
#[allow(unused_mut)]
let mut object_2093 = object.key("TuningObjective").start_object();
crate::json_ser::serialize_structure_crate_model_hyper_parameter_tuning_job_objective(
&mut object_2093,
var_2092,
)?;
object_2093.finish();
}
if let Some(var_2094) = &input.hyper_parameter_ranges {
#[allow(unused_mut)]
let mut object_2095 = object.key("HyperParameterRanges").start_object();
crate::json_ser::serialize_structure_crate_model_parameter_ranges(
&mut object_2095,
var_2094,
)?;
object_2095.finish();
}
if let Some(var_2096) = &input.static_hyper_parameters {
#[allow(unused_mut)]
let mut object_2097 = object.key("StaticHyperParameters").start_object();
for (key_2098, value_2099) in var_2096 {
{
object_2097
.key(key_2098.as_str())
.string(value_2099.as_str());
}
}
object_2097.finish();
}
if let Some(var_2100) = &input.algorithm_specification {
#[allow(unused_mut)]
let mut object_2101 = object.key("AlgorithmSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_hyper_parameter_algorithm_specification(
&mut object_2101,
var_2100,
)?;
object_2101.finish();
}
if let Some(var_2102) = &input.role_arn {
object.key("RoleArn").string(var_2102.as_str());
}
if let Some(var_2103) = &input.input_data_config {
let mut array_2104 = object.key("InputDataConfig").start_array();
for item_2105 in var_2103 {
{
#[allow(unused_mut)]
let mut object_2106 = array_2104.value().start_object();
crate::json_ser::serialize_structure_crate_model_channel(
&mut object_2106,
item_2105,
)?;
object_2106.finish();
}
}
array_2104.finish();
}
if let Some(var_2107) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_2108 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_2108, var_2107)?;
object_2108.finish();
}
if let Some(var_2109) = &input.output_data_config {
#[allow(unused_mut)]
let mut object_2110 = object.key("OutputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_output_data_config(
&mut object_2110,
var_2109,
)?;
object_2110.finish();
}
if let Some(var_2111) = &input.resource_config {
#[allow(unused_mut)]
let mut object_2112 = object.key("ResourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_resource_config(
&mut object_2112,
var_2111,
)?;
object_2112.finish();
}
if let Some(var_2113) = &input.stopping_condition {
#[allow(unused_mut)]
let mut object_2114 = object.key("StoppingCondition").start_object();
crate::json_ser::serialize_structure_crate_model_stopping_condition(
&mut object_2114,
var_2113,
)?;
object_2114.finish();
}
if input.enable_network_isolation {
object
.key("EnableNetworkIsolation")
.boolean(input.enable_network_isolation);
}
if input.enable_inter_container_traffic_encryption {
object
.key("EnableInterContainerTrafficEncryption")
.boolean(input.enable_inter_container_traffic_encryption);
}
if input.enable_managed_spot_training {
object
.key("EnableManagedSpotTraining")
.boolean(input.enable_managed_spot_training);
}
if let Some(var_2115) = &input.checkpoint_config {
#[allow(unused_mut)]
let mut object_2116 = object.key("CheckpointConfig").start_object();
crate::json_ser::serialize_structure_crate_model_checkpoint_config(
&mut object_2116,
var_2115,
)?;
object_2116.finish();
}
if let Some(var_2117) = &input.retry_strategy {
#[allow(unused_mut)]
let mut object_2118 = object.key("RetryStrategy").start_object();
crate::json_ser::serialize_structure_crate_model_retry_strategy(
&mut object_2118,
var_2117,
)?;
object_2118.finish();
}
if let Some(var_2119) = &input.hyper_parameter_tuning_resource_config {
#[allow(unused_mut)]
let mut object_2120 = object
.key("HyperParameterTuningResourceConfig")
.start_object();
crate::json_ser::serialize_structure_crate_model_hyper_parameter_tuning_resource_config(
&mut object_2120,
var_2119,
)?;
object_2120.finish();
}
if let Some(var_2121) = &input.environment {
#[allow(unused_mut)]
let mut object_2122 = object.key("Environment").start_object();
for (key_2123, value_2124) in var_2121 {
{
object_2122
.key(key_2123.as_str())
.string(value_2124.as_str());
}
}
object_2122.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_hyper_parameter_tuning_job_warm_start_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HyperParameterTuningJobWarmStartConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2125) = &input.parent_hyper_parameter_tuning_jobs {
let mut array_2126 = object.key("ParentHyperParameterTuningJobs").start_array();
for item_2127 in var_2125 {
{
#[allow(unused_mut)]
let mut object_2128 = array_2126.value().start_object();
crate::json_ser::serialize_structure_crate_model_parent_hyper_parameter_tuning_job(
&mut object_2128,
item_2127,
)?;
object_2128.finish();
}
}
array_2126.finish();
}
if let Some(var_2129) = &input.warm_start_type {
object.key("WarmStartType").string(var_2129.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_inference_experiment_schedule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InferenceExperimentSchedule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2130) = &input.start_time {
object
.key("StartTime")
.date_time(var_2130, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_2131) = &input.end_time {
object
.key("EndTime")
.date_time(var_2131, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_model_variant_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelVariantConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2132) = &input.model_name {
object.key("ModelName").string(var_2132.as_str());
}
if let Some(var_2133) = &input.variant_name {
object.key("VariantName").string(var_2133.as_str());
}
if let Some(var_2134) = &input.infrastructure_config {
#[allow(unused_mut)]
let mut object_2135 = object.key("InfrastructureConfig").start_object();
crate::json_ser::serialize_structure_crate_model_model_infrastructure_config(
&mut object_2135,
var_2134,
)?;
object_2135.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_inference_experiment_data_storage_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InferenceExperimentDataStorageConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2136) = &input.destination {
object.key("Destination").string(var_2136.as_str());
}
if let Some(var_2137) = &input.kms_key {
object.key("KmsKey").string(var_2137.as_str());
}
if let Some(var_2138) = &input.content_type {
#[allow(unused_mut)]
let mut object_2139 = object.key("ContentType").start_object();
crate::json_ser::serialize_structure_crate_model_capture_content_type_header(
&mut object_2139,
var_2138,
)?;
object_2139.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_shadow_mode_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ShadowModeConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2140) = &input.source_model_variant_name {
object
.key("SourceModelVariantName")
.string(var_2140.as_str());
}
if let Some(var_2141) = &input.shadow_model_variants {
let mut array_2142 = object.key("ShadowModelVariants").start_array();
for item_2143 in var_2141 {
{
#[allow(unused_mut)]
let mut object_2144 = array_2142.value().start_object();
crate::json_ser::serialize_structure_crate_model_shadow_model_variant_config(
&mut object_2144,
item_2143,
)?;
object_2144.finish();
}
}
array_2142.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_recommendation_job_input_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RecommendationJobInputConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2145) = &input.model_package_version_arn {
object
.key("ModelPackageVersionArn")
.string(var_2145.as_str());
}
if let Some(var_2146) = &input.job_duration_in_seconds {
object.key("JobDurationInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2146).into()),
);
}
if let Some(var_2147) = &input.traffic_pattern {
#[allow(unused_mut)]
let mut object_2148 = object.key("TrafficPattern").start_object();
crate::json_ser::serialize_structure_crate_model_traffic_pattern(
&mut object_2148,
var_2147,
)?;
object_2148.finish();
}
if let Some(var_2149) = &input.resource_limit {
#[allow(unused_mut)]
let mut object_2150 = object.key("ResourceLimit").start_object();
crate::json_ser::serialize_structure_crate_model_recommendation_job_resource_limit(
&mut object_2150,
var_2149,
)?;
object_2150.finish();
}
if let Some(var_2151) = &input.endpoint_configurations {
let mut array_2152 = object.key("EndpointConfigurations").start_array();
for item_2153 in var_2151 {
{
#[allow(unused_mut)]
let mut object_2154 = array_2152.value().start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_input_configuration(
&mut object_2154,
item_2153,
)?;
object_2154.finish();
}
}
array_2152.finish();
}
if let Some(var_2155) = &input.volume_kms_key_id {
object.key("VolumeKmsKeyId").string(var_2155.as_str());
}
if let Some(var_2156) = &input.container_config {
#[allow(unused_mut)]
let mut object_2157 = object.key("ContainerConfig").start_object();
crate::json_ser::serialize_structure_crate_model_recommendation_job_container_config(
&mut object_2157,
var_2156,
)?;
object_2157.finish();
}
if let Some(var_2158) = &input.endpoints {
let mut array_2159 = object.key("Endpoints").start_array();
for item_2160 in var_2158 {
{
#[allow(unused_mut)]
let mut object_2161 = array_2159.value().start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_info(
&mut object_2161,
item_2160,
)?;
object_2161.finish();
}
}
array_2159.finish();
}
if let Some(var_2162) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_2163 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_recommendation_job_vpc_config(
&mut object_2163,
var_2162,
)?;
object_2163.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_recommendation_job_stopping_conditions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RecommendationJobStoppingConditions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.max_invocations != 0 {
object.key("MaxInvocations").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_invocations).into()),
);
}
if let Some(var_2164) = &input.model_latency_thresholds {
let mut array_2165 = object.key("ModelLatencyThresholds").start_array();
for item_2166 in var_2164 {
{
#[allow(unused_mut)]
let mut object_2167 = array_2165.value().start_object();
crate::json_ser::serialize_structure_crate_model_model_latency_threshold(
&mut object_2167,
item_2166,
)?;
object_2167.finish();
}
}
array_2165.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_recommendation_job_output_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RecommendationJobOutputConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2168) = &input.kms_key_id {
object.key("KmsKeyId").string(var_2168.as_str());
}
if let Some(var_2169) = &input.compiled_output_config {
#[allow(unused_mut)]
let mut object_2170 = object.key("CompiledOutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_recommendation_job_compiled_output_config(
&mut object_2170,
var_2169,
)?;
object_2170.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_labeling_job_input_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LabelingJobInputConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2171) = &input.data_source {
#[allow(unused_mut)]
let mut object_2172 = object.key("DataSource").start_object();
crate::json_ser::serialize_structure_crate_model_labeling_job_data_source(
&mut object_2172,
var_2171,
)?;
object_2172.finish();
}
if let Some(var_2173) = &input.data_attributes {
#[allow(unused_mut)]
let mut object_2174 = object.key("DataAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_labeling_job_data_attributes(
&mut object_2174,
var_2173,
)?;
object_2174.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_labeling_job_output_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LabelingJobOutputConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2175) = &input.s3_output_path {
object.key("S3OutputPath").string(var_2175.as_str());
}
if let Some(var_2176) = &input.kms_key_id {
object.key("KmsKeyId").string(var_2176.as_str());
}
if let Some(var_2177) = &input.sns_topic_arn {
object.key("SnsTopicArn").string(var_2177.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_labeling_job_stopping_conditions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LabelingJobStoppingConditions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2178) = &input.max_human_labeled_object_count {
object.key("MaxHumanLabeledObjectCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2178).into()),
);
}
if let Some(var_2179) = &input.max_percentage_of_input_dataset_labeled {
object.key("MaxPercentageOfInputDatasetLabeled").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2179).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_labeling_job_algorithms_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LabelingJobAlgorithmsConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2180) = &input.labeling_job_algorithm_specification_arn {
object
.key("LabelingJobAlgorithmSpecificationArn")
.string(var_2180.as_str());
}
if let Some(var_2181) = &input.initial_active_learning_model_arn {
object
.key("InitialActiveLearningModelArn")
.string(var_2181.as_str());
}
if let Some(var_2182) = &input.labeling_job_resource_config {
#[allow(unused_mut)]
let mut object_2183 = object.key("LabelingJobResourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_labeling_job_resource_config(
&mut object_2183,
var_2182,
)?;
object_2183.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_human_task_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HumanTaskConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2184) = &input.workteam_arn {
object.key("WorkteamArn").string(var_2184.as_str());
}
if let Some(var_2185) = &input.ui_config {
#[allow(unused_mut)]
let mut object_2186 = object.key("UiConfig").start_object();
crate::json_ser::serialize_structure_crate_model_ui_config(&mut object_2186, var_2185)?;
object_2186.finish();
}
if let Some(var_2187) = &input.pre_human_task_lambda_arn {
object
.key("PreHumanTaskLambdaArn")
.string(var_2187.as_str());
}
if let Some(var_2188) = &input.task_keywords {
let mut array_2189 = object.key("TaskKeywords").start_array();
for item_2190 in var_2188 {
{
array_2189.value().string(item_2190.as_str());
}
}
array_2189.finish();
}
if let Some(var_2191) = &input.task_title {
object.key("TaskTitle").string(var_2191.as_str());
}
if let Some(var_2192) = &input.task_description {
object.key("TaskDescription").string(var_2192.as_str());
}
if let Some(var_2193) = &input.number_of_human_workers_per_data_object {
object.key("NumberOfHumanWorkersPerDataObject").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2193).into()),
);
}
if let Some(var_2194) = &input.task_time_limit_in_seconds {
object.key("TaskTimeLimitInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2194).into()),
);
}
if let Some(var_2195) = &input.task_availability_lifetime_in_seconds {
object.key("TaskAvailabilityLifetimeInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2195).into()),
);
}
if let Some(var_2196) = &input.max_concurrent_task_count {
object.key("MaxConcurrentTaskCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2196).into()),
);
}
if let Some(var_2197) = &input.annotation_consolidation_config {
#[allow(unused_mut)]
let mut object_2198 = object.key("AnnotationConsolidationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_annotation_consolidation_config(
&mut object_2198,
var_2197,
)?;
object_2198.finish();
}
if let Some(var_2199) = &input.public_workforce_task_price {
#[allow(unused_mut)]
let mut object_2200 = object.key("PublicWorkforceTaskPrice").start_object();
crate::json_ser::serialize_structure_crate_model_public_workforce_task_price(
&mut object_2200,
var_2199,
)?;
object_2200.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_container_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContainerDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2201) = &input.container_hostname {
object.key("ContainerHostname").string(var_2201.as_str());
}
if let Some(var_2202) = &input.image {
object.key("Image").string(var_2202.as_str());
}
if let Some(var_2203) = &input.image_config {
#[allow(unused_mut)]
let mut object_2204 = object.key("ImageConfig").start_object();
crate::json_ser::serialize_structure_crate_model_image_config(&mut object_2204, var_2203)?;
object_2204.finish();
}
if let Some(var_2205) = &input.mode {
object.key("Mode").string(var_2205.as_str());
}
if let Some(var_2206) = &input.model_data_url {
object.key("ModelDataUrl").string(var_2206.as_str());
}
if let Some(var_2207) = &input.environment {
#[allow(unused_mut)]
let mut object_2208 = object.key("Environment").start_object();
for (key_2209, value_2210) in var_2207 {
{
object_2208
.key(key_2209.as_str())
.string(value_2210.as_str());
}
}
object_2208.finish();
}
if let Some(var_2211) = &input.model_package_name {
object.key("ModelPackageName").string(var_2211.as_str());
}
if let Some(var_2212) = &input.inference_specification_name {
object
.key("InferenceSpecificationName")
.string(var_2212.as_str());
}
if let Some(var_2213) = &input.multi_model_config {
#[allow(unused_mut)]
let mut object_2214 = object.key("MultiModelConfig").start_object();
crate::json_ser::serialize_structure_crate_model_multi_model_config(
&mut object_2214,
var_2213,
)?;
object_2214.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_inference_execution_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InferenceExecutionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2215) = &input.mode {
object.key("Mode").string(var_2215.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_2216) = &input.security_group_ids {
let mut array_2217 = object.key("SecurityGroupIds").start_array();
for item_2218 in var_2216 {
{
array_2217.value().string(item_2218.as_str());
}
}
array_2217.finish();
}
if let Some(var_2219) = &input.subnets {
let mut array_2220 = object.key("Subnets").start_array();
for item_2221 in var_2219 {
{
array_2220.value().string(item_2221.as_str());
}
}
array_2220.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_model_bias_baseline_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelBiasBaselineConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2222) = &input.baselining_job_name {
object.key("BaseliningJobName").string(var_2222.as_str());
}
if let Some(var_2223) = &input.constraints_resource {
#[allow(unused_mut)]
let mut object_2224 = object.key("ConstraintsResource").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_constraints_resource(
&mut object_2224,
var_2223,
)?;
object_2224.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_model_bias_app_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelBiasAppSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2225) = &input.image_uri {
object.key("ImageUri").string(var_2225.as_str());
}
if let Some(var_2226) = &input.config_uri {
object.key("ConfigUri").string(var_2226.as_str());
}
if let Some(var_2227) = &input.environment {
#[allow(unused_mut)]
let mut object_2228 = object.key("Environment").start_object();
for (key_2229, value_2230) in var_2227 {
{
object_2228
.key(key_2229.as_str())
.string(value_2230.as_str());
}
}
object_2228.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_model_bias_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelBiasJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2231) = &input.endpoint_input {
#[allow(unused_mut)]
let mut object_2232 = object.key("EndpointInput").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_input(
&mut object_2232,
var_2231,
)?;
object_2232.finish();
}
if let Some(var_2233) = &input.batch_transform_input {
#[allow(unused_mut)]
let mut object_2234 = object.key("BatchTransformInput").start_object();
crate::json_ser::serialize_structure_crate_model_batch_transform_input(
&mut object_2234,
var_2233,
)?;
object_2234.finish();
}
if let Some(var_2235) = &input.ground_truth_s3_input {
#[allow(unused_mut)]
let mut object_2236 = object.key("GroundTruthS3Input").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_ground_truth_s3_input(
&mut object_2236,
var_2235,
)?;
object_2236.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_model_card_security_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelCardSecurityConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2237) = &input.kms_key_id {
object.key("KmsKeyId").string(var_2237.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_model_card_export_output_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelCardExportOutputConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2238) = &input.s3_output_path {
object.key("S3OutputPath").string(var_2238.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_model_explainability_baseline_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelExplainabilityBaselineConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2239) = &input.baselining_job_name {
object.key("BaseliningJobName").string(var_2239.as_str());
}
if let Some(var_2240) = &input.constraints_resource {
#[allow(unused_mut)]
let mut object_2241 = object.key("ConstraintsResource").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_constraints_resource(
&mut object_2241,
var_2240,
)?;
object_2241.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_model_explainability_app_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelExplainabilityAppSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2242) = &input.image_uri {
object.key("ImageUri").string(var_2242.as_str());
}
if let Some(var_2243) = &input.config_uri {
object.key("ConfigUri").string(var_2243.as_str());
}
if let Some(var_2244) = &input.environment {
#[allow(unused_mut)]
let mut object_2245 = object.key("Environment").start_object();
for (key_2246, value_2247) in var_2244 {
{
object_2245
.key(key_2246.as_str())
.string(value_2247.as_str());
}
}
object_2245.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_model_explainability_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelExplainabilityJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2248) = &input.endpoint_input {
#[allow(unused_mut)]
let mut object_2249 = object.key("EndpointInput").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_input(
&mut object_2249,
var_2248,
)?;
object_2249.finish();
}
if let Some(var_2250) = &input.batch_transform_input {
#[allow(unused_mut)]
let mut object_2251 = object.key("BatchTransformInput").start_object();
crate::json_ser::serialize_structure_crate_model_batch_transform_input(
&mut object_2251,
var_2250,
)?;
object_2251.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_model_package_validation_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelPackageValidationSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2252) = &input.validation_role {
object.key("ValidationRole").string(var_2252.as_str());
}
if let Some(var_2253) = &input.validation_profiles {
let mut array_2254 = object.key("ValidationProfiles").start_array();
for item_2255 in var_2253 {
{
#[allow(unused_mut)]
let mut object_2256 = array_2254.value().start_object();
crate::json_ser::serialize_structure_crate_model_model_package_validation_profile(
&mut object_2256,
item_2255,
)?;
object_2256.finish();
}
}
array_2254.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_source_algorithm_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SourceAlgorithmSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2257) = &input.source_algorithms {
let mut array_2258 = object.key("SourceAlgorithms").start_array();
for item_2259 in var_2257 {
{
#[allow(unused_mut)]
let mut object_2260 = array_2258.value().start_object();
crate::json_ser::serialize_structure_crate_model_source_algorithm(
&mut object_2260,
item_2259,
)?;
object_2260.finish();
}
}
array_2258.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_model_metrics(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelMetrics,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2261) = &input.model_quality {
#[allow(unused_mut)]
let mut object_2262 = object.key("ModelQuality").start_object();
crate::json_ser::serialize_structure_crate_model_model_quality(&mut object_2262, var_2261)?;
object_2262.finish();
}
if let Some(var_2263) = &input.model_data_quality {
#[allow(unused_mut)]
let mut object_2264 = object.key("ModelDataQuality").start_object();
crate::json_ser::serialize_structure_crate_model_model_data_quality(
&mut object_2264,
var_2263,
)?;
object_2264.finish();
}
if let Some(var_2265) = &input.bias {
#[allow(unused_mut)]
let mut object_2266 = object.key("Bias").start_object();
crate::json_ser::serialize_structure_crate_model_bias(&mut object_2266, var_2265)?;
object_2266.finish();
}
if let Some(var_2267) = &input.explainability {
#[allow(unused_mut)]
let mut object_2268 = object.key("Explainability").start_object();
crate::json_ser::serialize_structure_crate_model_explainability(
&mut object_2268,
var_2267,
)?;
object_2268.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_drift_check_baselines(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DriftCheckBaselines,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2269) = &input.bias {
#[allow(unused_mut)]
let mut object_2270 = object.key("Bias").start_object();
crate::json_ser::serialize_structure_crate_model_drift_check_bias(
&mut object_2270,
var_2269,
)?;
object_2270.finish();
}
if let Some(var_2271) = &input.explainability {
#[allow(unused_mut)]
let mut object_2272 = object.key("Explainability").start_object();
crate::json_ser::serialize_structure_crate_model_drift_check_explainability(
&mut object_2272,
var_2271,
)?;
object_2272.finish();
}
if let Some(var_2273) = &input.model_quality {
#[allow(unused_mut)]
let mut object_2274 = object.key("ModelQuality").start_object();
crate::json_ser::serialize_structure_crate_model_drift_check_model_quality(
&mut object_2274,
var_2273,
)?;
object_2274.finish();
}
if let Some(var_2275) = &input.model_data_quality {
#[allow(unused_mut)]
let mut object_2276 = object.key("ModelDataQuality").start_object();
crate::json_ser::serialize_structure_crate_model_drift_check_model_data_quality(
&mut object_2276,
var_2275,
)?;
object_2276.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_additional_inference_specification_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AdditionalInferenceSpecificationDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2277) = &input.name {
object.key("Name").string(var_2277.as_str());
}
if let Some(var_2278) = &input.description {
object.key("Description").string(var_2278.as_str());
}
if let Some(var_2279) = &input.containers {
let mut array_2280 = object.key("Containers").start_array();
for item_2281 in var_2279 {
{
#[allow(unused_mut)]
let mut object_2282 = array_2280.value().start_object();
crate::json_ser::serialize_structure_crate_model_model_package_container_definition(&mut object_2282, item_2281)?;
object_2282.finish();
}
}
array_2280.finish();
}
if let Some(var_2283) = &input.supported_transform_instance_types {
let mut array_2284 = object.key("SupportedTransformInstanceTypes").start_array();
for item_2285 in var_2283 {
{
array_2284.value().string(item_2285.as_str());
}
}
array_2284.finish();
}
if let Some(var_2286) = &input.supported_realtime_inference_instance_types {
let mut array_2287 = object
.key("SupportedRealtimeInferenceInstanceTypes")
.start_array();
for item_2288 in var_2286 {
{
array_2287.value().string(item_2288.as_str());
}
}
array_2287.finish();
}
if let Some(var_2289) = &input.supported_content_types {
let mut array_2290 = object.key("SupportedContentTypes").start_array();
for item_2291 in var_2289 {
{
array_2290.value().string(item_2291.as_str());
}
}
array_2290.finish();
}
if let Some(var_2292) = &input.supported_response_mime_types {
let mut array_2293 = object.key("SupportedResponseMIMETypes").start_array();
for item_2294 in var_2292 {
{
array_2293.value().string(item_2294.as_str());
}
}
array_2293.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_model_quality_baseline_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelQualityBaselineConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2295) = &input.baselining_job_name {
object.key("BaseliningJobName").string(var_2295.as_str());
}
if let Some(var_2296) = &input.constraints_resource {
#[allow(unused_mut)]
let mut object_2297 = object.key("ConstraintsResource").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_constraints_resource(
&mut object_2297,
var_2296,
)?;
object_2297.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_model_quality_app_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelQualityAppSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2298) = &input.image_uri {
object.key("ImageUri").string(var_2298.as_str());
}
if let Some(var_2299) = &input.container_entrypoint {
let mut array_2300 = object.key("ContainerEntrypoint").start_array();
for item_2301 in var_2299 {
{
array_2300.value().string(item_2301.as_str());
}
}
array_2300.finish();
}
if let Some(var_2302) = &input.container_arguments {
let mut array_2303 = object.key("ContainerArguments").start_array();
for item_2304 in var_2302 {
{
array_2303.value().string(item_2304.as_str());
}
}
array_2303.finish();
}
if let Some(var_2305) = &input.record_preprocessor_source_uri {
object
.key("RecordPreprocessorSourceUri")
.string(var_2305.as_str());
}
if let Some(var_2306) = &input.post_analytics_processor_source_uri {
object
.key("PostAnalyticsProcessorSourceUri")
.string(var_2306.as_str());
}
if let Some(var_2307) = &input.problem_type {
object.key("ProblemType").string(var_2307.as_str());
}
if let Some(var_2308) = &input.environment {
#[allow(unused_mut)]
let mut object_2309 = object.key("Environment").start_object();
for (key_2310, value_2311) in var_2308 {
{
object_2309
.key(key_2310.as_str())
.string(value_2311.as_str());
}
}
object_2309.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_model_quality_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelQualityJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2312) = &input.endpoint_input {
#[allow(unused_mut)]
let mut object_2313 = object.key("EndpointInput").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_input(
&mut object_2313,
var_2312,
)?;
object_2313.finish();
}
if let Some(var_2314) = &input.batch_transform_input {
#[allow(unused_mut)]
let mut object_2315 = object.key("BatchTransformInput").start_object();
crate::json_ser::serialize_structure_crate_model_batch_transform_input(
&mut object_2315,
var_2314,
)?;
object_2315.finish();
}
if let Some(var_2316) = &input.ground_truth_s3_input {
#[allow(unused_mut)]
let mut object_2317 = object.key("GroundTruthS3Input").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_ground_truth_s3_input(
&mut object_2317,
var_2316,
)?;
object_2317.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_schedule_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringScheduleConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2318) = &input.schedule_config {
#[allow(unused_mut)]
let mut object_2319 = object.key("ScheduleConfig").start_object();
crate::json_ser::serialize_structure_crate_model_schedule_config(
&mut object_2319,
var_2318,
)?;
object_2319.finish();
}
if let Some(var_2320) = &input.monitoring_job_definition {
#[allow(unused_mut)]
let mut object_2321 = object.key("MonitoringJobDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_job_definition(
&mut object_2321,
var_2320,
)?;
object_2321.finish();
}
if let Some(var_2322) = &input.monitoring_job_definition_name {
object
.key("MonitoringJobDefinitionName")
.string(var_2322.as_str());
}
if let Some(var_2323) = &input.monitoring_type {
object.key("MonitoringType").string(var_2323.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_instance_metadata_service_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InstanceMetadataServiceConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2324) = &input.minimum_instance_metadata_service_version {
object
.key("MinimumInstanceMetadataServiceVersion")
.string(var_2324.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_notebook_instance_lifecycle_hook(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NotebookInstanceLifecycleHook,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2325) = &input.content {
object.key("Content").string(var_2325.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_pipeline_definition_s3_location(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipelineDefinitionS3Location,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2326) = &input.bucket {
object.key("Bucket").string(var_2326.as_str());
}
if let Some(var_2327) = &input.object_key {
object.key("ObjectKey").string(var_2327.as_str());
}
if let Some(var_2328) = &input.version_id {
object.key("VersionId").string(var_2328.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_parallelism_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParallelismConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("MaxParallelExecutionSteps").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_parallel_execution_steps).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_processing_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProcessingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2329) = &input.input_name {
object.key("InputName").string(var_2329.as_str());
}
if input.app_managed {
object.key("AppManaged").boolean(input.app_managed);
}
if let Some(var_2330) = &input.s3_input {
#[allow(unused_mut)]
let mut object_2331 = object.key("S3Input").start_object();
crate::json_ser::serialize_structure_crate_model_processing_s3_input(
&mut object_2331,
var_2330,
)?;
object_2331.finish();
}
if let Some(var_2332) = &input.dataset_definition {
#[allow(unused_mut)]
let mut object_2333 = object.key("DatasetDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_dataset_definition(
&mut object_2333,
var_2332,
)?;
object_2333.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_processing_output_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProcessingOutputConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2334) = &input.outputs {
let mut array_2335 = object.key("Outputs").start_array();
for item_2336 in var_2334 {
{
#[allow(unused_mut)]
let mut object_2337 = array_2335.value().start_object();
crate::json_ser::serialize_structure_crate_model_processing_output(
&mut object_2337,
item_2336,
)?;
object_2337.finish();
}
}
array_2335.finish();
}
if let Some(var_2338) = &input.kms_key_id {
object.key("KmsKeyId").string(var_2338.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_processing_resources(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProcessingResources,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2339) = &input.cluster_config {
#[allow(unused_mut)]
let mut object_2340 = object.key("ClusterConfig").start_object();
crate::json_ser::serialize_structure_crate_model_processing_cluster_config(
&mut object_2340,
var_2339,
)?;
object_2340.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_processing_stopping_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProcessingStoppingCondition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("MaxRuntimeInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_runtime_in_seconds).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_app_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AppSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2341) = &input.image_uri {
object.key("ImageUri").string(var_2341.as_str());
}
if let Some(var_2342) = &input.container_entrypoint {
let mut array_2343 = object.key("ContainerEntrypoint").start_array();
for item_2344 in var_2342 {
{
array_2343.value().string(item_2344.as_str());
}
}
array_2343.finish();
}
if let Some(var_2345) = &input.container_arguments {
let mut array_2346 = object.key("ContainerArguments").start_array();
for item_2347 in var_2345 {
{
array_2346.value().string(item_2347.as_str());
}
}
array_2346.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_network_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NetworkConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enable_inter_container_traffic_encryption {
object
.key("EnableInterContainerTrafficEncryption")
.boolean(input.enable_inter_container_traffic_encryption);
}
if input.enable_network_isolation {
object
.key("EnableNetworkIsolation")
.boolean(input.enable_network_isolation);
}
if let Some(var_2348) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_2349 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_2349, var_2348)?;
object_2349.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_experiment_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExperimentConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2350) = &input.experiment_name {
object.key("ExperimentName").string(var_2350.as_str());
}
if let Some(var_2351) = &input.trial_name {
object.key("TrialName").string(var_2351.as_str());
}
if let Some(var_2352) = &input.trial_component_display_name {
object
.key("TrialComponentDisplayName")
.string(var_2352.as_str());
}
if let Some(var_2353) = &input.run_name {
object.key("RunName").string(var_2353.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_service_catalog_provisioning_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServiceCatalogProvisioningDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2354) = &input.product_id {
object.key("ProductId").string(var_2354.as_str());
}
if let Some(var_2355) = &input.provisioning_artifact_id {
object
.key("ProvisioningArtifactId")
.string(var_2355.as_str());
}
if let Some(var_2356) = &input.path_id {
object.key("PathId").string(var_2356.as_str());
}
if let Some(var_2357) = &input.provisioning_parameters {
let mut array_2358 = object.key("ProvisioningParameters").start_array();
for item_2359 in var_2357 {
{
#[allow(unused_mut)]
let mut object_2360 = array_2358.value().start_object();
crate::json_ser::serialize_structure_crate_model_provisioning_parameter(
&mut object_2360,
item_2359,
)?;
object_2360.finish();
}
}
array_2358.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_space_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SpaceSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2361) = &input.jupyter_server_app_settings {
#[allow(unused_mut)]
let mut object_2362 = object.key("JupyterServerAppSettings").start_object();
crate::json_ser::serialize_structure_crate_model_jupyter_server_app_settings(
&mut object_2362,
var_2361,
)?;
object_2362.finish();
}
if let Some(var_2363) = &input.kernel_gateway_app_settings {
#[allow(unused_mut)]
let mut object_2364 = object.key("KernelGatewayAppSettings").start_object();
crate::json_ser::serialize_structure_crate_model_kernel_gateway_app_settings(
&mut object_2364,
var_2363,
)?;
object_2364.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_algorithm_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AlgorithmSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2365) = &input.training_image {
object.key("TrainingImage").string(var_2365.as_str());
}
if let Some(var_2366) = &input.algorithm_name {
object.key("AlgorithmName").string(var_2366.as_str());
}
if let Some(var_2367) = &input.training_input_mode {
object.key("TrainingInputMode").string(var_2367.as_str());
}
if let Some(var_2368) = &input.metric_definitions {
let mut array_2369 = object.key("MetricDefinitions").start_array();
for item_2370 in var_2368 {
{
#[allow(unused_mut)]
let mut object_2371 = array_2369.value().start_object();
crate::json_ser::serialize_structure_crate_model_metric_definition(
&mut object_2371,
item_2370,
)?;
object_2371.finish();
}
}
array_2369.finish();
}
if input.enable_sage_maker_metrics_time_series {
object
.key("EnableSageMakerMetricsTimeSeries")
.boolean(input.enable_sage_maker_metrics_time_series);
}
if let Some(var_2372) = &input.container_entrypoint {
let mut array_2373 = object.key("ContainerEntrypoint").start_array();
for item_2374 in var_2372 {
{
array_2373.value().string(item_2374.as_str());
}
}
array_2373.finish();
}
if let Some(var_2375) = &input.container_arguments {
let mut array_2376 = object.key("ContainerArguments").start_array();
for item_2377 in var_2375 {
{
array_2376.value().string(item_2377.as_str());
}
}
array_2376.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_channel(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Channel,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2378) = &input.channel_name {
object.key("ChannelName").string(var_2378.as_str());
}
if let Some(var_2379) = &input.data_source {
#[allow(unused_mut)]
let mut object_2380 = object.key("DataSource").start_object();
crate::json_ser::serialize_structure_crate_model_data_source(&mut object_2380, var_2379)?;
object_2380.finish();
}
if let Some(var_2381) = &input.content_type {
object.key("ContentType").string(var_2381.as_str());
}
if let Some(var_2382) = &input.compression_type {
object.key("CompressionType").string(var_2382.as_str());
}
if let Some(var_2383) = &input.record_wrapper_type {
object.key("RecordWrapperType").string(var_2383.as_str());
}
if let Some(var_2384) = &input.input_mode {
object.key("InputMode").string(var_2384.as_str());
}
if let Some(var_2385) = &input.shuffle_config {
#[allow(unused_mut)]
let mut object_2386 = object.key("ShuffleConfig").start_object();
crate::json_ser::serialize_structure_crate_model_shuffle_config(
&mut object_2386,
var_2385,
)?;
object_2386.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_output_data_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OutputDataConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2387) = &input.kms_key_id {
object.key("KmsKeyId").string(var_2387.as_str());
}
if let Some(var_2388) = &input.s3_output_path {
object.key("S3OutputPath").string(var_2388.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2389) = &input.instance_type {
object.key("InstanceType").string(var_2389.as_str());
}
if input.instance_count != 0 {
object.key("InstanceCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.instance_count).into()),
);
}
{
object.key("VolumeSizeInGB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.volume_size_in_gb).into()),
);
}
if let Some(var_2390) = &input.volume_kms_key_id {
object.key("VolumeKmsKeyId").string(var_2390.as_str());
}
if let Some(var_2391) = &input.instance_groups {
let mut array_2392 = object.key("InstanceGroups").start_array();
for item_2393 in var_2391 {
{
#[allow(unused_mut)]
let mut object_2394 = array_2392.value().start_object();
crate::json_ser::serialize_structure_crate_model_instance_group(
&mut object_2394,
item_2393,
)?;
object_2394.finish();
}
}
array_2392.finish();
}
if let Some(var_2395) = &input.keep_alive_period_in_seconds {
object.key("KeepAlivePeriodInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2395).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_checkpoint_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CheckpointConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2396) = &input.s3_uri {
object.key("S3Uri").string(var_2396.as_str());
}
if let Some(var_2397) = &input.local_path {
object.key("LocalPath").string(var_2397.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_debug_hook_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DebugHookConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2398) = &input.local_path {
object.key("LocalPath").string(var_2398.as_str());
}
if let Some(var_2399) = &input.s3_output_path {
object.key("S3OutputPath").string(var_2399.as_str());
}
if let Some(var_2400) = &input.hook_parameters {
#[allow(unused_mut)]
let mut object_2401 = object.key("HookParameters").start_object();
for (key_2402, value_2403) in var_2400 {
{
object_2401
.key(key_2402.as_str())
.string(value_2403.as_str());
}
}
object_2401.finish();
}
if let Some(var_2404) = &input.collection_configurations {
let mut array_2405 = object.key("CollectionConfigurations").start_array();
for item_2406 in var_2404 {
{
#[allow(unused_mut)]
let mut object_2407 = array_2405.value().start_object();
crate::json_ser::serialize_structure_crate_model_collection_configuration(
&mut object_2407,
item_2406,
)?;
object_2407.finish();
}
}
array_2405.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_debug_rule_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DebugRuleConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2408) = &input.rule_configuration_name {
object
.key("RuleConfigurationName")
.string(var_2408.as_str());
}
if let Some(var_2409) = &input.local_path {
object.key("LocalPath").string(var_2409.as_str());
}
if let Some(var_2410) = &input.s3_output_path {
object.key("S3OutputPath").string(var_2410.as_str());
}
if let Some(var_2411) = &input.rule_evaluator_image {
object.key("RuleEvaluatorImage").string(var_2411.as_str());
}
if let Some(var_2412) = &input.instance_type {
object.key("InstanceType").string(var_2412.as_str());
}
if input.volume_size_in_gb != 0 {
object.key("VolumeSizeInGB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.volume_size_in_gb).into()),
);
}
if let Some(var_2413) = &input.rule_parameters {
#[allow(unused_mut)]
let mut object_2414 = object.key("RuleParameters").start_object();
for (key_2415, value_2416) in var_2413 {
{
object_2414
.key(key_2415.as_str())
.string(value_2416.as_str());
}
}
object_2414.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tensor_board_output_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TensorBoardOutputConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2417) = &input.local_path {
object.key("LocalPath").string(var_2417.as_str());
}
if let Some(var_2418) = &input.s3_output_path {
object.key("S3OutputPath").string(var_2418.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_profiler_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProfilerConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2419) = &input.s3_output_path {
object.key("S3OutputPath").string(var_2419.as_str());
}
if let Some(var_2420) = &input.profiling_interval_in_milliseconds {
object.key("ProfilingIntervalInMilliseconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2420).into()),
);
}
if let Some(var_2421) = &input.profiling_parameters {
#[allow(unused_mut)]
let mut object_2422 = object.key("ProfilingParameters").start_object();
for (key_2423, value_2424) in var_2421 {
{
object_2422
.key(key_2423.as_str())
.string(value_2424.as_str());
}
}
object_2422.finish();
}
if input.disable_profiler {
object
.key("DisableProfiler")
.boolean(input.disable_profiler);
}
Ok(())
}
pub fn serialize_structure_crate_model_profiler_rule_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProfilerRuleConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2425) = &input.rule_configuration_name {
object
.key("RuleConfigurationName")
.string(var_2425.as_str());
}
if let Some(var_2426) = &input.local_path {
object.key("LocalPath").string(var_2426.as_str());
}
if let Some(var_2427) = &input.s3_output_path {
object.key("S3OutputPath").string(var_2427.as_str());
}
if let Some(var_2428) = &input.rule_evaluator_image {
object.key("RuleEvaluatorImage").string(var_2428.as_str());
}
if let Some(var_2429) = &input.instance_type {
object.key("InstanceType").string(var_2429.as_str());
}
if input.volume_size_in_gb != 0 {
object.key("VolumeSizeInGB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.volume_size_in_gb).into()),
);
}
if let Some(var_2430) = &input.rule_parameters {
#[allow(unused_mut)]
let mut object_2431 = object.key("RuleParameters").start_object();
for (key_2432, value_2433) in var_2430 {
{
object_2431
.key(key_2432.as_str())
.string(value_2433.as_str());
}
}
object_2431.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_retry_strategy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RetryStrategy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("MaximumRetryAttempts").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.maximum_retry_attempts).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_model_client_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelClientConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2434) = &input.invocations_timeout_in_seconds {
object.key("InvocationsTimeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2434).into()),
);
}
if let Some(var_2435) = &input.invocations_max_retries {
object.key("InvocationsMaxRetries").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2435).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_transform_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TransformInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2436) = &input.data_source {
#[allow(unused_mut)]
let mut object_2437 = object.key("DataSource").start_object();
crate::json_ser::serialize_structure_crate_model_transform_data_source(
&mut object_2437,
var_2436,
)?;
object_2437.finish();
}
if let Some(var_2438) = &input.content_type {
object.key("ContentType").string(var_2438.as_str());
}
if let Some(var_2439) = &input.compression_type {
object.key("CompressionType").string(var_2439.as_str());
}
if let Some(var_2440) = &input.split_type {
object.key("SplitType").string(var_2440.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_transform_output(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TransformOutput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2441) = &input.s3_output_path {
object.key("S3OutputPath").string(var_2441.as_str());
}
if let Some(var_2442) = &input.accept {
object.key("Accept").string(var_2442.as_str());
}
if let Some(var_2443) = &input.assemble_with {
object.key("AssembleWith").string(var_2443.as_str());
}
if let Some(var_2444) = &input.kms_key_id {
object.key("KmsKeyId").string(var_2444.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_batch_data_capture_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BatchDataCaptureConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2445) = &input.destination_s3_uri {
object.key("DestinationS3Uri").string(var_2445.as_str());
}
if let Some(var_2446) = &input.kms_key_id {
object.key("KmsKeyId").string(var_2446.as_str());
}
if input.generate_inference_id {
object
.key("GenerateInferenceId")
.boolean(input.generate_inference_id);
}
Ok(())
}
pub fn serialize_structure_crate_model_transform_resources(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TransformResources,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2447) = &input.instance_type {
object.key("InstanceType").string(var_2447.as_str());
}
if let Some(var_2448) = &input.instance_count {
object.key("InstanceCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2448).into()),
);
}
if let Some(var_2449) = &input.volume_kms_key_id {
object.key("VolumeKmsKeyId").string(var_2449.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_processing(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataProcessing,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2450) = &input.input_filter {
object.key("InputFilter").string(var_2450.as_str());
}
if let Some(var_2451) = &input.output_filter {
object.key("OutputFilter").string(var_2451.as_str());
}
if let Some(var_2452) = &input.join_source {
object.key("JoinSource").string(var_2452.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_trial_component_status(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TrialComponentStatus,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2453) = &input.primary_status {
object.key("PrimaryStatus").string(var_2453.as_str());
}
if let Some(var_2454) = &input.message {
object.key("Message").string(var_2454.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_trial_component_parameter_value(
object_714: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TrialComponentParameterValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::TrialComponentParameterValue::StringValue(inner) => {
object_714.key("StringValue").string(inner.as_str());
}
crate::model::TrialComponentParameterValue::NumberValue(inner) => {
object_714.key("NumberValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*inner).into()),
);
}
crate::model::TrialComponentParameterValue::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"TrialComponentParameterValue",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_trial_component_artifact(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TrialComponentArtifact,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2455) = &input.media_type {
object.key("MediaType").string(var_2455.as_str());
}
if let Some(var_2456) = &input.value {
object.key("Value").string(var_2456.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_cognito_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CognitoConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2457) = &input.user_pool {
object.key("UserPool").string(var_2457.as_str());
}
if let Some(var_2458) = &input.client_id {
object.key("ClientId").string(var_2458.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_oidc_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OidcConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2459) = &input.client_id {
object.key("ClientId").string(var_2459.as_str());
}
if let Some(var_2460) = &input.client_secret {
object.key("ClientSecret").string(var_2460.as_str());
}
if let Some(var_2461) = &input.issuer {
object.key("Issuer").string(var_2461.as_str());
}
if let Some(var_2462) = &input.authorization_endpoint {
object
.key("AuthorizationEndpoint")
.string(var_2462.as_str());
}
if let Some(var_2463) = &input.token_endpoint {
object.key("TokenEndpoint").string(var_2463.as_str());
}
if let Some(var_2464) = &input.user_info_endpoint {
object.key("UserInfoEndpoint").string(var_2464.as_str());
}
if let Some(var_2465) = &input.logout_endpoint {
object.key("LogoutEndpoint").string(var_2465.as_str());
}
if let Some(var_2466) = &input.jwks_uri {
object.key("JwksUri").string(var_2466.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_source_ip_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SourceIpConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2467) = &input.cidrs {
let mut array_2468 = object.key("Cidrs").start_array();
for item_2469 in var_2467 {
{
array_2468.value().string(item_2469.as_str());
}
}
array_2468.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_workforce_vpc_config_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WorkforceVpcConfigRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2470) = &input.vpc_id {
object.key("VpcId").string(var_2470.as_str());
}
if let Some(var_2471) = &input.security_group_ids {
let mut array_2472 = object.key("SecurityGroupIds").start_array();
for item_2473 in var_2471 {
{
array_2472.value().string(item_2473.as_str());
}
}
array_2472.finish();
}
if let Some(var_2474) = &input.subnets {
let mut array_2475 = object.key("Subnets").start_array();
for item_2476 in var_2474 {
{
array_2475.value().string(item_2476.as_str());
}
}
array_2475.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_member_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MemberDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2477) = &input.cognito_member_definition {
#[allow(unused_mut)]
let mut object_2478 = object.key("CognitoMemberDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_cognito_member_definition(
&mut object_2478,
var_2477,
)?;
object_2478.finish();
}
if let Some(var_2479) = &input.oidc_member_definition {
#[allow(unused_mut)]
let mut object_2480 = object.key("OidcMemberDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_oidc_member_definition(
&mut object_2480,
var_2479,
)?;
object_2480.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_notification_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NotificationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2481) = &input.notification_topic_arn {
object.key("NotificationTopicArn").string(var_2481.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_retention_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RetentionPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2482) = &input.home_efs_file_system {
object.key("HomeEfsFileSystem").string(var_2482.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_suggestion_query(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SuggestionQuery,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2483) = &input.property_name_query {
#[allow(unused_mut)]
let mut object_2484 = object.key("PropertyNameQuery").start_object();
crate::json_ser::serialize_structure_crate_model_property_name_query(
&mut object_2484,
var_2483,
)?;
object_2484.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_model_metadata_search_expression(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelMetadataSearchExpression,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2485) = &input.filters {
let mut array_2486 = object.key("Filters").start_array();
for item_2487 in var_2485 {
{
#[allow(unused_mut)]
let mut object_2488 = array_2486.value().start_object();
crate::json_ser::serialize_structure_crate_model_model_metadata_filter(
&mut object_2488,
item_2487,
)?;
object_2488.finish();
}
}
array_2486.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_query_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::QueryFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2489) = &input.types {
let mut array_2490 = object.key("Types").start_array();
for item_2491 in var_2489 {
{
array_2490.value().string(item_2491.as_str());
}
}
array_2490.finish();
}
if let Some(var_2492) = &input.lineage_types {
let mut array_2493 = object.key("LineageTypes").start_array();
for item_2494 in var_2492 {
{
array_2493.value().string(item_2494.as_str());
}
}
array_2493.finish();
}
if let Some(var_2495) = &input.created_before {
object
.key("CreatedBefore")
.date_time(var_2495, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_2496) = &input.created_after {
object
.key("CreatedAfter")
.date_time(var_2496, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_2497) = &input.modified_before {
object
.key("ModifiedBefore")
.date_time(var_2497, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_2498) = &input.modified_after {
object
.key("ModifiedAfter")
.date_time(var_2498, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_2499) = &input.properties {
#[allow(unused_mut)]
let mut object_2500 = object.key("Properties").start_object();
for (key_2501, value_2502) in var_2499 {
{
object_2500
.key(key_2501.as_str())
.string(value_2502.as_str());
}
}
object_2500.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_device(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Device,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2503) = &input.device_name {
object.key("DeviceName").string(var_2503.as_str());
}
if let Some(var_2504) = &input.description {
object.key("Description").string(var_2504.as_str());
}
if let Some(var_2505) = &input.iot_thing_name {
object.key("IotThingName").string(var_2505.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_renderable_task(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RenderableTask,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2506) = &input.input {
object.key("Input").string(var_2506.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_search_expression(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SearchExpression,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2507) = &input.filters {
let mut array_2508 = object.key("Filters").start_array();
for item_2509 in var_2507 {
{
#[allow(unused_mut)]
let mut object_2510 = array_2508.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(
&mut object_2510,
item_2509,
)?;
object_2510.finish();
}
}
array_2508.finish();
}
if let Some(var_2511) = &input.nested_filters {
let mut array_2512 = object.key("NestedFilters").start_array();
for item_2513 in var_2511 {
{
#[allow(unused_mut)]
let mut object_2514 = array_2512.value().start_object();
crate::json_ser::serialize_structure_crate_model_nested_filters(
&mut object_2514,
item_2513,
)?;
object_2514.finish();
}
}
array_2512.finish();
}
if let Some(var_2515) = &input.sub_expressions {
let mut array_2516 = object.key("SubExpressions").start_array();
for item_2517 in var_2515 {
{
#[allow(unused_mut)]
let mut object_2518 = array_2516.value().start_object();
crate::json_ser::serialize_structure_crate_model_search_expression(
&mut object_2518,
item_2517,
)?;
object_2518.finish();
}
}
array_2516.finish();
}
if let Some(var_2519) = &input.operator {
object.key("Operator").string(var_2519.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_output_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OutputParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2520) = &input.name {
object.key("Name").string(var_2520.as_str());
}
if let Some(var_2521) = &input.value {
object.key("Value").string(var_2521.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Parameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2522) = &input.name {
object.key("Name").string(var_2522.as_str());
}
if let Some(var_2523) = &input.value {
object.key("Value").string(var_2523.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_git_config_for_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GitConfigForUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2524) = &input.secret_arn {
object.key("SecretArn").string(var_2524.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_domain_settings_for_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DomainSettingsForUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2525) = &input.r_studio_server_pro_domain_settings_for_update {
#[allow(unused_mut)]
let mut object_2526 = object
.key("RStudioServerProDomainSettingsForUpdate")
.start_object();
crate::json_ser::serialize_structure_crate_model_r_studio_server_pro_domain_settings_for_update(&mut object_2526, var_2525)?;
object_2526.finish();
}
if let Some(var_2527) = &input.execution_role_identity_config {
object
.key("ExecutionRoleIdentityConfig")
.string(var_2527.as_str());
}
if let Some(var_2528) = &input.security_group_ids {
let mut array_2529 = object.key("SecurityGroupIds").start_array();
for item_2530 in var_2528 {
{
array_2529.value().string(item_2530.as_str());
}
}
array_2529.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_variant_property(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VariantProperty,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2531) = &input.variant_property_type {
object.key("VariantPropertyType").string(var_2531.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_desired_weight_and_capacity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DesiredWeightAndCapacity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2532) = &input.variant_name {
object.key("VariantName").string(var_2532.as_str());
}
if let Some(var_2533) = &input.desired_weight {
object.key("DesiredWeight").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_2533).into()),
);
}
if let Some(var_2534) = &input.desired_instance_count {
object.key("DesiredInstanceCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2534).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_feature_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FeatureParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2535) = &input.key {
object.key("Key").string(var_2535.as_str());
}
if let Some(var_2536) = &input.value {
object.key("Value").string(var_2536.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_service_catalog_provisioning_update_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServiceCatalogProvisioningUpdateDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2537) = &input.provisioning_artifact_id {
object
.key("ProvisioningArtifactId")
.string(var_2537.as_str());
}
if let Some(var_2538) = &input.provisioning_parameters {
let mut array_2539 = object.key("ProvisioningParameters").start_array();
for item_2540 in var_2538 {
{
#[allow(unused_mut)]
let mut object_2541 = array_2539.value().start_object();
crate::json_ser::serialize_structure_crate_model_provisioning_parameter(
&mut object_2541,
item_2540,
)?;
object_2541.finish();
}
}
array_2539.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_profiler_config_for_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProfilerConfigForUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2542) = &input.s3_output_path {
object.key("S3OutputPath").string(var_2542.as_str());
}
if let Some(var_2543) = &input.profiling_interval_in_milliseconds {
object.key("ProfilingIntervalInMilliseconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2543).into()),
);
}
if let Some(var_2544) = &input.profiling_parameters {
#[allow(unused_mut)]
let mut object_2545 = object.key("ProfilingParameters").start_object();
for (key_2546, value_2547) in var_2544 {
{
object_2545
.key(key_2546.as_str())
.string(value_2547.as_str());
}
}
object_2545.finish();
}
if input.disable_profiler {
object
.key("DisableProfiler")
.boolean(input.disable_profiler);
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_config_for_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceConfigForUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2548) = &input.keep_alive_period_in_seconds {
object.key("KeepAlivePeriodInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2548).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_hyper_parameter_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HyperParameterSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2549) = &input.name {
object.key("Name").string(var_2549.as_str());
}
if let Some(var_2550) = &input.description {
object.key("Description").string(var_2550.as_str());
}
if let Some(var_2551) = &input.r#type {
object.key("Type").string(var_2551.as_str());
}
if let Some(var_2552) = &input.range {
#[allow(unused_mut)]
let mut object_2553 = object.key("Range").start_object();
crate::json_ser::serialize_structure_crate_model_parameter_range(
&mut object_2553,
var_2552,
)?;
object_2553.finish();
}
if input.is_tunable {
object.key("IsTunable").boolean(input.is_tunable);
}
if input.is_required {
object.key("IsRequired").boolean(input.is_required);
}
if let Some(var_2554) = &input.default_value {
object.key("DefaultValue").string(var_2554.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_metric_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MetricDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2555) = &input.name {
object.key("Name").string(var_2555.as_str());
}
if let Some(var_2556) = &input.regex {
object.key("Regex").string(var_2556.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_channel_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ChannelSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2557) = &input.name {
object.key("Name").string(var_2557.as_str());
}
if let Some(var_2558) = &input.description {
object.key("Description").string(var_2558.as_str());
}
if input.is_required {
object.key("IsRequired").boolean(input.is_required);
}
if let Some(var_2559) = &input.supported_content_types {
let mut array_2560 = object.key("SupportedContentTypes").start_array();
for item_2561 in var_2559 {
{
array_2560.value().string(item_2561.as_str());
}
}
array_2560.finish();
}
if let Some(var_2562) = &input.supported_compression_types {
let mut array_2563 = object.key("SupportedCompressionTypes").start_array();
for item_2564 in var_2562 {
{
array_2563.value().string(item_2564.as_str());
}
}
array_2563.finish();
}
if let Some(var_2565) = &input.supported_input_modes {
let mut array_2566 = object.key("SupportedInputModes").start_array();
for item_2567 in var_2565 {
{
array_2566.value().string(item_2567.as_str());
}
}
array_2566.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_hyper_parameter_tuning_job_objective(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HyperParameterTuningJobObjective,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2568) = &input.r#type {
object.key("Type").string(var_2568.as_str());
}
if let Some(var_2569) = &input.metric_name {
object.key("MetricName").string(var_2569.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_model_package_container_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelPackageContainerDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2570) = &input.container_hostname {
object.key("ContainerHostname").string(var_2570.as_str());
}
if let Some(var_2571) = &input.image {
object.key("Image").string(var_2571.as_str());
}
if let Some(var_2572) = &input.image_digest {
object.key("ImageDigest").string(var_2572.as_str());
}
if let Some(var_2573) = &input.model_data_url {
object.key("ModelDataUrl").string(var_2573.as_str());
}
if let Some(var_2574) = &input.product_id {
object.key("ProductId").string(var_2574.as_str());
}
if let Some(var_2575) = &input.environment {
#[allow(unused_mut)]
let mut object_2576 = object.key("Environment").start_object();
for (key_2577, value_2578) in var_2575 {
{
object_2576
.key(key_2577.as_str())
.string(value_2578.as_str());
}
}
object_2576.finish();
}
if let Some(var_2579) = &input.model_input {
#[allow(unused_mut)]
let mut object_2580 = object.key("ModelInput").start_object();
crate::json_ser::serialize_structure_crate_model_model_input(&mut object_2580, var_2579)?;
object_2580.finish();
}
if let Some(var_2581) = &input.framework {
object.key("Framework").string(var_2581.as_str());
}
if let Some(var_2582) = &input.framework_version {
object.key("FrameworkVersion").string(var_2582.as_str());
}
if let Some(var_2583) = &input.nearest_model_name {
object.key("NearestModelName").string(var_2583.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_algorithm_validation_profile(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AlgorithmValidationProfile,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2584) = &input.profile_name {
object.key("ProfileName").string(var_2584.as_str());
}
if let Some(var_2585) = &input.training_job_definition {
#[allow(unused_mut)]
let mut object_2586 = object.key("TrainingJobDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_training_job_definition(
&mut object_2586,
var_2585,
)?;
object_2586.finish();
}
if let Some(var_2587) = &input.transform_job_definition {
#[allow(unused_mut)]
let mut object_2588 = object.key("TransformJobDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_transform_job_definition(
&mut object_2588,
var_2587,
)?;
object_2588.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_kernel_spec(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KernelSpec,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2589) = &input.name {
object.key("Name").string(var_2589.as_str());
}
if let Some(var_2590) = &input.display_name {
object.key("DisplayName").string(var_2590.as_str());
}
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_2591) = &input.mount_path {
object.key("MountPath").string(var_2591.as_str());
}
if let Some(var_2592) = &input.default_uid {
object.key("DefaultUid").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2592).into()),
);
}
if let Some(var_2593) = &input.default_gid {
object.key("DefaultGid").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2593).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_artifact_source_type(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ArtifactSourceType,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2594) = &input.source_id_type {
object.key("SourceIdType").string(var_2594.as_str());
}
if let Some(var_2595) = &input.value {
object.key("Value").string(var_2595.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_ml_data_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoMlDataSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2596) = &input.s3_data_source {
#[allow(unused_mut)]
let mut object_2597 = object.key("S3DataSource").start_object();
crate::json_ser::serialize_structure_crate_model_auto_mls3_data_source(
&mut object_2597,
var_2596,
)?;
object_2597.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_ml_job_completion_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoMlJobCompletionCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2598) = &input.max_candidates {
object.key("MaxCandidates").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2598).into()),
);
}
if let Some(var_2599) = &input.max_runtime_per_training_job_in_seconds {
object.key("MaxRuntimePerTrainingJobInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2599).into()),
);
}
if let Some(var_2600) = &input.max_auto_ml_job_runtime_in_seconds {
object.key("MaxAutoMLJobRuntimeInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2600).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_ml_security_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoMlSecurityConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2601) = &input.volume_kms_key_id {
object.key("VolumeKmsKeyId").string(var_2601.as_str());
}
if input.enable_inter_container_traffic_encryption {
object
.key("EnableInterContainerTrafficEncryption")
.boolean(input.enable_inter_container_traffic_encryption);
}
if let Some(var_2602) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_2603 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_2603, var_2602)?;
object_2603.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_ml_data_split_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoMlDataSplitConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2604) = &input.validation_fraction {
object.key("ValidationFraction").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_2604).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_ml_candidate_generation_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoMlCandidateGenerationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2605) = &input.feature_specification_s3_uri {
object
.key("FeatureSpecificationS3Uri")
.string(var_2605.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_target_platform(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TargetPlatform,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2606) = &input.os {
object.key("Os").string(var_2606.as_str());
}
if let Some(var_2607) = &input.arch {
object.key("Arch").string(var_2607.as_str());
}
if let Some(var_2608) = &input.accelerator {
object.key("Accelerator").string(var_2608.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_constraints_resource(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringConstraintsResource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2609) = &input.s3_uri {
object.key("S3Uri").string(var_2609.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_statistics_resource(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringStatisticsResource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2610) = &input.s3_uri {
object.key("S3Uri").string(var_2610.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2611) = &input.endpoint_name {
object.key("EndpointName").string(var_2611.as_str());
}
if let Some(var_2612) = &input.local_path {
object.key("LocalPath").string(var_2612.as_str());
}
if let Some(var_2613) = &input.s3_input_mode {
object.key("S3InputMode").string(var_2613.as_str());
}
if let Some(var_2614) = &input.s3_data_distribution_type {
object
.key("S3DataDistributionType")
.string(var_2614.as_str());
}
if let Some(var_2615) = &input.features_attribute {
object.key("FeaturesAttribute").string(var_2615.as_str());
}
if let Some(var_2616) = &input.inference_attribute {
object.key("InferenceAttribute").string(var_2616.as_str());
}
if let Some(var_2617) = &input.probability_attribute {
object.key("ProbabilityAttribute").string(var_2617.as_str());
}
if let Some(var_2618) = &input.probability_threshold_attribute {
object.key("ProbabilityThresholdAttribute").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_2618).into()),
);
}
if let Some(var_2619) = &input.start_time_offset {
object.key("StartTimeOffset").string(var_2619.as_str());
}
if let Some(var_2620) = &input.end_time_offset {
object.key("EndTimeOffset").string(var_2620.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_batch_transform_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BatchTransformInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2621) = &input.data_captured_destination_s3_uri {
object
.key("DataCapturedDestinationS3Uri")
.string(var_2621.as_str());
}
if let Some(var_2622) = &input.dataset_format {
#[allow(unused_mut)]
let mut object_2623 = object.key("DatasetFormat").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_dataset_format(
&mut object_2623,
var_2622,
)?;
object_2623.finish();
}
if let Some(var_2624) = &input.local_path {
object.key("LocalPath").string(var_2624.as_str());
}
if let Some(var_2625) = &input.s3_input_mode {
object.key("S3InputMode").string(var_2625.as_str());
}
if let Some(var_2626) = &input.s3_data_distribution_type {
object
.key("S3DataDistributionType")
.string(var_2626.as_str());
}
if let Some(var_2627) = &input.features_attribute {
object.key("FeaturesAttribute").string(var_2627.as_str());
}
if let Some(var_2628) = &input.inference_attribute {
object.key("InferenceAttribute").string(var_2628.as_str());
}
if let Some(var_2629) = &input.probability_attribute {
object.key("ProbabilityAttribute").string(var_2629.as_str());
}
if let Some(var_2630) = &input.probability_threshold_attribute {
object.key("ProbabilityThresholdAttribute").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_2630).into()),
);
}
if let Some(var_2631) = &input.start_time_offset {
object.key("StartTimeOffset").string(var_2631.as_str());
}
if let Some(var_2632) = &input.end_time_offset {
object.key("EndTimeOffset").string(var_2632.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_output(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringOutput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2633) = &input.s3_output {
#[allow(unused_mut)]
let mut object_2634 = object.key("S3Output").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_s3_output(
&mut object_2634,
var_2633,
)?;
object_2634.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_cluster_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringClusterConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2635) = &input.instance_count {
object.key("InstanceCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2635).into()),
);
}
if let Some(var_2636) = &input.instance_type {
object.key("InstanceType").string(var_2636.as_str());
}
if let Some(var_2637) = &input.volume_size_in_gb {
object.key("VolumeSizeInGB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2637).into()),
);
}
if let Some(var_2638) = &input.volume_kms_key_id {
object.key("VolumeKmsKeyId").string(var_2638.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sharing_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SharingSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2639) = &input.notebook_output_option {
object.key("NotebookOutputOption").string(var_2639.as_str());
}
if let Some(var_2640) = &input.s3_output_path {
object.key("S3OutputPath").string(var_2640.as_str());
}
if let Some(var_2641) = &input.s3_kms_key_id {
object.key("S3KmsKeyId").string(var_2641.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_jupyter_server_app_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JupyterServerAppSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2642) = &input.default_resource_spec {
#[allow(unused_mut)]
let mut object_2643 = object.key("DefaultResourceSpec").start_object();
crate::json_ser::serialize_structure_crate_model_resource_spec(&mut object_2643, var_2642)?;
object_2643.finish();
}
if let Some(var_2644) = &input.lifecycle_config_arns {
let mut array_2645 = object.key("LifecycleConfigArns").start_array();
for item_2646 in var_2644 {
{
array_2645.value().string(item_2646.as_str());
}
}
array_2645.finish();
}
if let Some(var_2647) = &input.code_repositories {
let mut array_2648 = object.key("CodeRepositories").start_array();
for item_2649 in var_2647 {
{
#[allow(unused_mut)]
let mut object_2650 = array_2648.value().start_object();
crate::json_ser::serialize_structure_crate_model_code_repository(
&mut object_2650,
item_2649,
)?;
object_2650.finish();
}
}
array_2648.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_kernel_gateway_app_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KernelGatewayAppSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2651) = &input.default_resource_spec {
#[allow(unused_mut)]
let mut object_2652 = object.key("DefaultResourceSpec").start_object();
crate::json_ser::serialize_structure_crate_model_resource_spec(&mut object_2652, var_2651)?;
object_2652.finish();
}
if let Some(var_2653) = &input.custom_images {
let mut array_2654 = object.key("CustomImages").start_array();
for item_2655 in var_2653 {
{
#[allow(unused_mut)]
let mut object_2656 = array_2654.value().start_object();
crate::json_ser::serialize_structure_crate_model_custom_image(
&mut object_2656,
item_2655,
)?;
object_2656.finish();
}
}
array_2654.finish();
}
if let Some(var_2657) = &input.lifecycle_config_arns {
let mut array_2658 = object.key("LifecycleConfigArns").start_array();
for item_2659 in var_2657 {
{
array_2658.value().string(item_2659.as_str());
}
}
array_2658.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tensor_board_app_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TensorBoardAppSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2660) = &input.default_resource_spec {
#[allow(unused_mut)]
let mut object_2661 = object.key("DefaultResourceSpec").start_object();
crate::json_ser::serialize_structure_crate_model_resource_spec(&mut object_2661, var_2660)?;
object_2661.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_r_studio_server_pro_app_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RStudioServerProAppSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2662) = &input.access_status {
object.key("AccessStatus").string(var_2662.as_str());
}
if let Some(var_2663) = &input.user_group {
object.key("UserGroup").string(var_2663.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_r_session_app_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RSessionAppSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2664) = &input.default_resource_spec {
#[allow(unused_mut)]
let mut object_2665 = object.key("DefaultResourceSpec").start_object();
crate::json_ser::serialize_structure_crate_model_resource_spec(&mut object_2665, var_2664)?;
object_2665.finish();
}
if let Some(var_2666) = &input.custom_images {
let mut array_2667 = object.key("CustomImages").start_array();
for item_2668 in var_2666 {
{
#[allow(unused_mut)]
let mut object_2669 = array_2667.value().start_object();
crate::json_ser::serialize_structure_crate_model_custom_image(
&mut object_2669,
item_2668,
)?;
object_2669.finish();
}
}
array_2667.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_canvas_app_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CanvasAppSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2670) = &input.time_series_forecasting_settings {
#[allow(unused_mut)]
let mut object_2671 = object.key("TimeSeriesForecastingSettings").start_object();
crate::json_ser::serialize_structure_crate_model_time_series_forecasting_settings(
&mut object_2671,
var_2670,
)?;
object_2671.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_r_studio_server_pro_domain_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RStudioServerProDomainSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2672) = &input.domain_execution_role_arn {
object
.key("DomainExecutionRoleArn")
.string(var_2672.as_str());
}
if let Some(var_2673) = &input.r_studio_connect_url {
object.key("RStudioConnectUrl").string(var_2673.as_str());
}
if let Some(var_2674) = &input.r_studio_package_manager_url {
object
.key("RStudioPackageManagerUrl")
.string(var_2674.as_str());
}
if let Some(var_2675) = &input.default_resource_spec {
#[allow(unused_mut)]
let mut object_2676 = object.key("DefaultResourceSpec").start_object();
crate::json_ser::serialize_structure_crate_model_resource_spec(&mut object_2676, var_2675)?;
object_2676.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_device_selection_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeviceSelectionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2677) = &input.device_subset_type {
object.key("DeviceSubsetType").string(var_2677.as_str());
}
if input.percentage != 0 {
object.key("Percentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.percentage).into()),
);
}
if let Some(var_2678) = &input.device_names {
let mut array_2679 = object.key("DeviceNames").start_array();
for item_2680 in var_2678 {
{
array_2679.value().string(item_2680.as_str());
}
}
array_2679.finish();
}
if let Some(var_2681) = &input.device_name_contains {
object.key("DeviceNameContains").string(var_2681.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_edge_deployment_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EdgeDeploymentConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2682) = &input.failure_handling_policy {
object
.key("FailureHandlingPolicy")
.string(var_2682.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_blue_green_update_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BlueGreenUpdatePolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2683) = &input.traffic_routing_configuration {
#[allow(unused_mut)]
let mut object_2684 = object.key("TrafficRoutingConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_traffic_routing_config(
&mut object_2684,
var_2683,
)?;
object_2684.finish();
}
if let Some(var_2685) = &input.termination_wait_in_seconds {
object.key("TerminationWaitInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2685).into()),
);
}
if let Some(var_2686) = &input.maximum_execution_timeout_in_seconds {
object.key("MaximumExecutionTimeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2686).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_rollback_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoRollbackConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2687) = &input.alarms {
let mut array_2688 = object.key("Alarms").start_array();
for item_2689 in var_2687 {
{
#[allow(unused_mut)]
let mut object_2690 = array_2688.value().start_object();
crate::json_ser::serialize_structure_crate_model_alarm(
&mut object_2690,
item_2689,
)?;
object_2690.finish();
}
}
array_2688.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_production_variant_core_dump_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProductionVariantCoreDumpConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2691) = &input.destination_s3_uri {
object.key("DestinationS3Uri").string(var_2691.as_str());
}
if let Some(var_2692) = &input.kms_key_id {
object.key("KmsKeyId").string(var_2692.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_production_variant_serverless_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProductionVariantServerlessConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2693) = &input.memory_size_in_mb {
object.key("MemorySizeInMB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2693).into()),
);
}
if let Some(var_2694) = &input.max_concurrency {
object.key("MaxConcurrency").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2694).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_capture_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CaptureOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2695) = &input.capture_mode {
object.key("CaptureMode").string(var_2695.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_capture_content_type_header(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CaptureContentTypeHeader,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2696) = &input.csv_content_types {
let mut array_2697 = object.key("CsvContentTypes").start_array();
for item_2698 in var_2696 {
{
array_2697.value().string(item_2698.as_str());
}
}
array_2697.finish();
}
if let Some(var_2699) = &input.json_content_types {
let mut array_2700 = object.key("JsonContentTypes").start_array();
for item_2701 in var_2699 {
{
array_2700.value().string(item_2701.as_str());
}
}
array_2700.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_async_inference_client_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AsyncInferenceClientConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2702) = &input.max_concurrent_invocations_per_instance {
object.key("MaxConcurrentInvocationsPerInstance").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2702).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_async_inference_output_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AsyncInferenceOutputConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2703) = &input.kms_key_id {
object.key("KmsKeyId").string(var_2703.as_str());
}
if let Some(var_2704) = &input.s3_output_path {
object.key("S3OutputPath").string(var_2704.as_str());
}
if let Some(var_2705) = &input.notification_config {
#[allow(unused_mut)]
let mut object_2706 = object.key("NotificationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_async_inference_notification_config(
&mut object_2706,
var_2705,
)?;
object_2706.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_clarify_explainer_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ClarifyExplainerConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2707) = &input.enable_explanations {
object.key("EnableExplanations").string(var_2707.as_str());
}
if let Some(var_2708) = &input.inference_config {
#[allow(unused_mut)]
let mut object_2709 = object.key("InferenceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_clarify_inference_config(
&mut object_2709,
var_2708,
)?;
object_2709.finish();
}
if let Some(var_2710) = &input.shap_config {
#[allow(unused_mut)]
let mut object_2711 = object.key("ShapConfig").start_object();
crate::json_ser::serialize_structure_crate_model_clarify_shap_config(
&mut object_2711,
var_2710,
)?;
object_2711.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_online_store_security_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OnlineStoreSecurityConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2712) = &input.kms_key_id {
object.key("KmsKeyId").string(var_2712.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_storage_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3StorageConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2713) = &input.s3_uri {
object.key("S3Uri").string(var_2713.as_str());
}
if let Some(var_2714) = &input.kms_key_id {
object.key("KmsKeyId").string(var_2714.as_str());
}
if let Some(var_2715) = &input.resolved_output_s3_uri {
object.key("ResolvedOutputS3Uri").string(var_2715.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_catalog_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataCatalogConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2716) = &input.table_name {
object.key("TableName").string(var_2716.as_str());
}
if let Some(var_2717) = &input.catalog {
object.key("Catalog").string(var_2717.as_str());
}
if let Some(var_2718) = &input.database {
object.key("Database").string(var_2718.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_human_loop_activation_conditions_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HumanLoopActivationConditionsConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2719) = &input.human_loop_activation_conditions {
object
.key("HumanLoopActivationConditions")
.string(var_2719.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_public_workforce_task_price(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PublicWorkforceTaskPrice,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2720) = &input.amount_in_usd {
#[allow(unused_mut)]
let mut object_2721 = object.key("AmountInUsd").start_object();
crate::json_ser::serialize_structure_crate_model_usd(&mut object_2721, var_2720)?;
object_2721.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_hyper_parameter_tuning_job_strategy_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HyperParameterTuningJobStrategyConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2722) = &input.hyperband_strategy_config {
#[allow(unused_mut)]
let mut object_2723 = object.key("HyperbandStrategyConfig").start_object();
crate::json_ser::serialize_structure_crate_model_hyperband_strategy_config(
&mut object_2723,
var_2722,
)?;
object_2723.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_limits(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceLimits,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2724) = &input.max_number_of_training_jobs {
object.key("MaxNumberOfTrainingJobs").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2724).into()),
);
}
{
object.key("MaxParallelTrainingJobs").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_parallel_training_jobs).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_parameter_ranges(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParameterRanges,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2725) = &input.integer_parameter_ranges {
let mut array_2726 = object.key("IntegerParameterRanges").start_array();
for item_2727 in var_2725 {
{
#[allow(unused_mut)]
let mut object_2728 = array_2726.value().start_object();
crate::json_ser::serialize_structure_crate_model_integer_parameter_range(
&mut object_2728,
item_2727,
)?;
object_2728.finish();
}
}
array_2726.finish();
}
if let Some(var_2729) = &input.continuous_parameter_ranges {
let mut array_2730 = object.key("ContinuousParameterRanges").start_array();
for item_2731 in var_2729 {
{
#[allow(unused_mut)]
let mut object_2732 = array_2730.value().start_object();
crate::json_ser::serialize_structure_crate_model_continuous_parameter_range(
&mut object_2732,
item_2731,
)?;
object_2732.finish();
}
}
array_2730.finish();
}
if let Some(var_2733) = &input.categorical_parameter_ranges {
let mut array_2734 = object.key("CategoricalParameterRanges").start_array();
for item_2735 in var_2733 {
{
#[allow(unused_mut)]
let mut object_2736 = array_2734.value().start_object();
crate::json_ser::serialize_structure_crate_model_categorical_parameter_range(
&mut object_2736,
item_2735,
)?;
object_2736.finish();
}
}
array_2734.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tuning_job_completion_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TuningJobCompletionCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2737) = &input.target_objective_metric_value {
object.key("TargetObjectiveMetricValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_2737).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_hyper_parameter_algorithm_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HyperParameterAlgorithmSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2738) = &input.training_image {
object.key("TrainingImage").string(var_2738.as_str());
}
if let Some(var_2739) = &input.training_input_mode {
object.key("TrainingInputMode").string(var_2739.as_str());
}
if let Some(var_2740) = &input.algorithm_name {
object.key("AlgorithmName").string(var_2740.as_str());
}
if let Some(var_2741) = &input.metric_definitions {
let mut array_2742 = object.key("MetricDefinitions").start_array();
for item_2743 in var_2741 {
{
#[allow(unused_mut)]
let mut object_2744 = array_2742.value().start_object();
crate::json_ser::serialize_structure_crate_model_metric_definition(
&mut object_2744,
item_2743,
)?;
object_2744.finish();
}
}
array_2742.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_hyper_parameter_tuning_resource_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HyperParameterTuningResourceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2745) = &input.instance_type {
object.key("InstanceType").string(var_2745.as_str());
}
if input.instance_count != 0 {
object.key("InstanceCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.instance_count).into()),
);
}
if input.volume_size_in_gb != 0 {
object.key("VolumeSizeInGB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.volume_size_in_gb).into()),
);
}
if let Some(var_2746) = &input.volume_kms_key_id {
object.key("VolumeKmsKeyId").string(var_2746.as_str());
}
if let Some(var_2747) = &input.allocation_strategy {
object.key("AllocationStrategy").string(var_2747.as_str());
}
if let Some(var_2748) = &input.instance_configs {
let mut array_2749 = object.key("InstanceConfigs").start_array();
for item_2750 in var_2748 {
{
#[allow(unused_mut)]
let mut object_2751 = array_2749.value().start_object();
crate::json_ser::serialize_structure_crate_model_hyper_parameter_tuning_instance_config(&mut object_2751, item_2750)?;
object_2751.finish();
}
}
array_2749.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_parent_hyper_parameter_tuning_job(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParentHyperParameterTuningJob,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2752) = &input.hyper_parameter_tuning_job_name {
object
.key("HyperParameterTuningJobName")
.string(var_2752.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_model_infrastructure_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelInfrastructureConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2753) = &input.infrastructure_type {
object.key("InfrastructureType").string(var_2753.as_str());
}
if let Some(var_2754) = &input.real_time_inference_config {
#[allow(unused_mut)]
let mut object_2755 = object.key("RealTimeInferenceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_real_time_inference_config(
&mut object_2755,
var_2754,
)?;
object_2755.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_shadow_model_variant_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ShadowModelVariantConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2756) = &input.shadow_model_variant_name {
object
.key("ShadowModelVariantName")
.string(var_2756.as_str());
}
{
object.key("SamplingPercentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.sampling_percentage).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_traffic_pattern(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TrafficPattern,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2757) = &input.traffic_type {
object.key("TrafficType").string(var_2757.as_str());
}
if let Some(var_2758) = &input.phases {
let mut array_2759 = object.key("Phases").start_array();
for item_2760 in var_2758 {
{
#[allow(unused_mut)]
let mut object_2761 = array_2759.value().start_object();
crate::json_ser::serialize_structure_crate_model_phase(
&mut object_2761,
item_2760,
)?;
object_2761.finish();
}
}
array_2759.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_recommendation_job_resource_limit(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RecommendationJobResourceLimit,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2762) = &input.max_number_of_tests {
object.key("MaxNumberOfTests").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2762).into()),
);
}
if let Some(var_2763) = &input.max_parallel_of_tests {
object.key("MaxParallelOfTests").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2763).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_endpoint_input_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EndpointInputConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2764) = &input.instance_type {
object.key("InstanceType").string(var_2764.as_str());
}
if let Some(var_2765) = &input.inference_specification_name {
object
.key("InferenceSpecificationName")
.string(var_2765.as_str());
}
if let Some(var_2766) = &input.environment_parameter_ranges {
#[allow(unused_mut)]
let mut object_2767 = object.key("EnvironmentParameterRanges").start_object();
crate::json_ser::serialize_structure_crate_model_environment_parameter_ranges(
&mut object_2767,
var_2766,
)?;
object_2767.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_recommendation_job_container_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RecommendationJobContainerConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2768) = &input.domain {
object.key("Domain").string(var_2768.as_str());
}
if let Some(var_2769) = &input.task {
object.key("Task").string(var_2769.as_str());
}
if let Some(var_2770) = &input.framework {
object.key("Framework").string(var_2770.as_str());
}
if let Some(var_2771) = &input.framework_version {
object.key("FrameworkVersion").string(var_2771.as_str());
}
if let Some(var_2772) = &input.payload_config {
#[allow(unused_mut)]
let mut object_2773 = object.key("PayloadConfig").start_object();
crate::json_ser::serialize_structure_crate_model_recommendation_job_payload_config(
&mut object_2773,
var_2772,
)?;
object_2773.finish();
}
if let Some(var_2774) = &input.nearest_model_name {
object.key("NearestModelName").string(var_2774.as_str());
}
if let Some(var_2775) = &input.supported_instance_types {
let mut array_2776 = object.key("SupportedInstanceTypes").start_array();
for item_2777 in var_2775 {
{
array_2776.value().string(item_2777.as_str());
}
}
array_2776.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_endpoint_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EndpointInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2778) = &input.endpoint_name {
object.key("EndpointName").string(var_2778.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_recommendation_job_vpc_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RecommendationJobVpcConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2779) = &input.security_group_ids {
let mut array_2780 = object.key("SecurityGroupIds").start_array();
for item_2781 in var_2779 {
{
array_2780.value().string(item_2781.as_str());
}
}
array_2780.finish();
}
if let Some(var_2782) = &input.subnets {
let mut array_2783 = object.key("Subnets").start_array();
for item_2784 in var_2782 {
{
array_2783.value().string(item_2784.as_str());
}
}
array_2783.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_model_latency_threshold(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelLatencyThreshold,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2785) = &input.percentile {
object.key("Percentile").string(var_2785.as_str());
}
if input.value_in_milliseconds != 0 {
object.key("ValueInMilliseconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.value_in_milliseconds).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_recommendation_job_compiled_output_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RecommendationJobCompiledOutputConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2786) = &input.s3_output_uri {
object.key("S3OutputUri").string(var_2786.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_labeling_job_data_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LabelingJobDataSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2787) = &input.s3_data_source {
#[allow(unused_mut)]
let mut object_2788 = object.key("S3DataSource").start_object();
crate::json_ser::serialize_structure_crate_model_labeling_job_s3_data_source(
&mut object_2788,
var_2787,
)?;
object_2788.finish();
}
if let Some(var_2789) = &input.sns_data_source {
#[allow(unused_mut)]
let mut object_2790 = object.key("SnsDataSource").start_object();
crate::json_ser::serialize_structure_crate_model_labeling_job_sns_data_source(
&mut object_2790,
var_2789,
)?;
object_2790.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_labeling_job_data_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LabelingJobDataAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2791) = &input.content_classifiers {
let mut array_2792 = object.key("ContentClassifiers").start_array();
for item_2793 in var_2791 {
{
array_2792.value().string(item_2793.as_str());
}
}
array_2792.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_labeling_job_resource_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LabelingJobResourceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2794) = &input.volume_kms_key_id {
object.key("VolumeKmsKeyId").string(var_2794.as_str());
}
if let Some(var_2795) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_2796 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_2796, var_2795)?;
object_2796.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_ui_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UiConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2797) = &input.ui_template_s3_uri {
object.key("UiTemplateS3Uri").string(var_2797.as_str());
}
if let Some(var_2798) = &input.human_task_ui_arn {
object.key("HumanTaskUiArn").string(var_2798.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_annotation_consolidation_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnnotationConsolidationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2799) = &input.annotation_consolidation_lambda_arn {
object
.key("AnnotationConsolidationLambdaArn")
.string(var_2799.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_2800) = &input.repository_access_mode {
object.key("RepositoryAccessMode").string(var_2800.as_str());
}
if let Some(var_2801) = &input.repository_auth_config {
#[allow(unused_mut)]
let mut object_2802 = object.key("RepositoryAuthConfig").start_object();
crate::json_ser::serialize_structure_crate_model_repository_auth_config(
&mut object_2802,
var_2801,
)?;
object_2802.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_multi_model_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MultiModelConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2803) = &input.model_cache_setting {
object.key("ModelCacheSetting").string(var_2803.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_ground_truth_s3_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringGroundTruthS3Input,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2804) = &input.s3_uri {
object.key("S3Uri").string(var_2804.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_model_package_validation_profile(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelPackageValidationProfile,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2805) = &input.profile_name {
object.key("ProfileName").string(var_2805.as_str());
}
if let Some(var_2806) = &input.transform_job_definition {
#[allow(unused_mut)]
let mut object_2807 = object.key("TransformJobDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_transform_job_definition(
&mut object_2807,
var_2806,
)?;
object_2807.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_source_algorithm(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SourceAlgorithm,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2808) = &input.model_data_url {
object.key("ModelDataUrl").string(var_2808.as_str());
}
if let Some(var_2809) = &input.algorithm_name {
object.key("AlgorithmName").string(var_2809.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_model_quality(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelQuality,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2810) = &input.statistics {
#[allow(unused_mut)]
let mut object_2811 = object.key("Statistics").start_object();
crate::json_ser::serialize_structure_crate_model_metrics_source(
&mut object_2811,
var_2810,
)?;
object_2811.finish();
}
if let Some(var_2812) = &input.constraints {
#[allow(unused_mut)]
let mut object_2813 = object.key("Constraints").start_object();
crate::json_ser::serialize_structure_crate_model_metrics_source(
&mut object_2813,
var_2812,
)?;
object_2813.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_model_data_quality(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelDataQuality,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2814) = &input.statistics {
#[allow(unused_mut)]
let mut object_2815 = object.key("Statistics").start_object();
crate::json_ser::serialize_structure_crate_model_metrics_source(
&mut object_2815,
var_2814,
)?;
object_2815.finish();
}
if let Some(var_2816) = &input.constraints {
#[allow(unused_mut)]
let mut object_2817 = object.key("Constraints").start_object();
crate::json_ser::serialize_structure_crate_model_metrics_source(
&mut object_2817,
var_2816,
)?;
object_2817.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_bias(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Bias,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2818) = &input.report {
#[allow(unused_mut)]
let mut object_2819 = object.key("Report").start_object();
crate::json_ser::serialize_structure_crate_model_metrics_source(
&mut object_2819,
var_2818,
)?;
object_2819.finish();
}
if let Some(var_2820) = &input.pre_training_report {
#[allow(unused_mut)]
let mut object_2821 = object.key("PreTrainingReport").start_object();
crate::json_ser::serialize_structure_crate_model_metrics_source(
&mut object_2821,
var_2820,
)?;
object_2821.finish();
}
if let Some(var_2822) = &input.post_training_report {
#[allow(unused_mut)]
let mut object_2823 = object.key("PostTrainingReport").start_object();
crate::json_ser::serialize_structure_crate_model_metrics_source(
&mut object_2823,
var_2822,
)?;
object_2823.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_explainability(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Explainability,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2824) = &input.report {
#[allow(unused_mut)]
let mut object_2825 = object.key("Report").start_object();
crate::json_ser::serialize_structure_crate_model_metrics_source(
&mut object_2825,
var_2824,
)?;
object_2825.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_drift_check_bias(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DriftCheckBias,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2826) = &input.config_file {
#[allow(unused_mut)]
let mut object_2827 = object.key("ConfigFile").start_object();
crate::json_ser::serialize_structure_crate_model_file_source(&mut object_2827, var_2826)?;
object_2827.finish();
}
if let Some(var_2828) = &input.pre_training_constraints {
#[allow(unused_mut)]
let mut object_2829 = object.key("PreTrainingConstraints").start_object();
crate::json_ser::serialize_structure_crate_model_metrics_source(
&mut object_2829,
var_2828,
)?;
object_2829.finish();
}
if let Some(var_2830) = &input.post_training_constraints {
#[allow(unused_mut)]
let mut object_2831 = object.key("PostTrainingConstraints").start_object();
crate::json_ser::serialize_structure_crate_model_metrics_source(
&mut object_2831,
var_2830,
)?;
object_2831.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_drift_check_explainability(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DriftCheckExplainability,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2832) = &input.constraints {
#[allow(unused_mut)]
let mut object_2833 = object.key("Constraints").start_object();
crate::json_ser::serialize_structure_crate_model_metrics_source(
&mut object_2833,
var_2832,
)?;
object_2833.finish();
}
if let Some(var_2834) = &input.config_file {
#[allow(unused_mut)]
let mut object_2835 = object.key("ConfigFile").start_object();
crate::json_ser::serialize_structure_crate_model_file_source(&mut object_2835, var_2834)?;
object_2835.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_drift_check_model_quality(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DriftCheckModelQuality,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2836) = &input.statistics {
#[allow(unused_mut)]
let mut object_2837 = object.key("Statistics").start_object();
crate::json_ser::serialize_structure_crate_model_metrics_source(
&mut object_2837,
var_2836,
)?;
object_2837.finish();
}
if let Some(var_2838) = &input.constraints {
#[allow(unused_mut)]
let mut object_2839 = object.key("Constraints").start_object();
crate::json_ser::serialize_structure_crate_model_metrics_source(
&mut object_2839,
var_2838,
)?;
object_2839.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_drift_check_model_data_quality(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DriftCheckModelDataQuality,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2840) = &input.statistics {
#[allow(unused_mut)]
let mut object_2841 = object.key("Statistics").start_object();
crate::json_ser::serialize_structure_crate_model_metrics_source(
&mut object_2841,
var_2840,
)?;
object_2841.finish();
}
if let Some(var_2842) = &input.constraints {
#[allow(unused_mut)]
let mut object_2843 = object.key("Constraints").start_object();
crate::json_ser::serialize_structure_crate_model_metrics_source(
&mut object_2843,
var_2842,
)?;
object_2843.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_schedule_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScheduleConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2844) = &input.schedule_expression {
object.key("ScheduleExpression").string(var_2844.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_job_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringJobDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2845) = &input.baseline_config {
#[allow(unused_mut)]
let mut object_2846 = object.key("BaselineConfig").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_baseline_config(
&mut object_2846,
var_2845,
)?;
object_2846.finish();
}
if let Some(var_2847) = &input.monitoring_inputs {
let mut array_2848 = object.key("MonitoringInputs").start_array();
for item_2849 in var_2847 {
{
#[allow(unused_mut)]
let mut object_2850 = array_2848.value().start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_input(
&mut object_2850,
item_2849,
)?;
object_2850.finish();
}
}
array_2848.finish();
}
if let Some(var_2851) = &input.monitoring_output_config {
#[allow(unused_mut)]
let mut object_2852 = object.key("MonitoringOutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_output_config(
&mut object_2852,
var_2851,
)?;
object_2852.finish();
}
if let Some(var_2853) = &input.monitoring_resources {
#[allow(unused_mut)]
let mut object_2854 = object.key("MonitoringResources").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_resources(
&mut object_2854,
var_2853,
)?;
object_2854.finish();
}
if let Some(var_2855) = &input.monitoring_app_specification {
#[allow(unused_mut)]
let mut object_2856 = object.key("MonitoringAppSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_app_specification(
&mut object_2856,
var_2855,
)?;
object_2856.finish();
}
if let Some(var_2857) = &input.stopping_condition {
#[allow(unused_mut)]
let mut object_2858 = object.key("StoppingCondition").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_stopping_condition(
&mut object_2858,
var_2857,
)?;
object_2858.finish();
}
if let Some(var_2859) = &input.environment {
#[allow(unused_mut)]
let mut object_2860 = object.key("Environment").start_object();
for (key_2861, value_2862) in var_2859 {
{
object_2860
.key(key_2861.as_str())
.string(value_2862.as_str());
}
}
object_2860.finish();
}
if let Some(var_2863) = &input.network_config {
#[allow(unused_mut)]
let mut object_2864 = object.key("NetworkConfig").start_object();
crate::json_ser::serialize_structure_crate_model_network_config(
&mut object_2864,
var_2863,
)?;
object_2864.finish();
}
if let Some(var_2865) = &input.role_arn {
object.key("RoleArn").string(var_2865.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_processing_s3_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProcessingS3Input,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2866) = &input.s3_uri {
object.key("S3Uri").string(var_2866.as_str());
}
if let Some(var_2867) = &input.local_path {
object.key("LocalPath").string(var_2867.as_str());
}
if let Some(var_2868) = &input.s3_data_type {
object.key("S3DataType").string(var_2868.as_str());
}
if let Some(var_2869) = &input.s3_input_mode {
object.key("S3InputMode").string(var_2869.as_str());
}
if let Some(var_2870) = &input.s3_data_distribution_type {
object
.key("S3DataDistributionType")
.string(var_2870.as_str());
}
if let Some(var_2871) = &input.s3_compression_type {
object.key("S3CompressionType").string(var_2871.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_dataset_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatasetDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2872) = &input.athena_dataset_definition {
#[allow(unused_mut)]
let mut object_2873 = object.key("AthenaDatasetDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_athena_dataset_definition(
&mut object_2873,
var_2872,
)?;
object_2873.finish();
}
if let Some(var_2874) = &input.redshift_dataset_definition {
#[allow(unused_mut)]
let mut object_2875 = object.key("RedshiftDatasetDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_redshift_dataset_definition(
&mut object_2875,
var_2874,
)?;
object_2875.finish();
}
if let Some(var_2876) = &input.local_path {
object.key("LocalPath").string(var_2876.as_str());
}
if let Some(var_2877) = &input.data_distribution_type {
object.key("DataDistributionType").string(var_2877.as_str());
}
if let Some(var_2878) = &input.input_mode {
object.key("InputMode").string(var_2878.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_processing_output(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProcessingOutput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2879) = &input.output_name {
object.key("OutputName").string(var_2879.as_str());
}
if let Some(var_2880) = &input.s3_output {
#[allow(unused_mut)]
let mut object_2881 = object.key("S3Output").start_object();
crate::json_ser::serialize_structure_crate_model_processing_s3_output(
&mut object_2881,
var_2880,
)?;
object_2881.finish();
}
if let Some(var_2882) = &input.feature_store_output {
#[allow(unused_mut)]
let mut object_2883 = object.key("FeatureStoreOutput").start_object();
crate::json_ser::serialize_structure_crate_model_processing_feature_store_output(
&mut object_2883,
var_2882,
)?;
object_2883.finish();
}
if input.app_managed {
object.key("AppManaged").boolean(input.app_managed);
}
Ok(())
}
pub fn serialize_structure_crate_model_processing_cluster_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProcessingClusterConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2884) = &input.instance_count {
object.key("InstanceCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2884).into()),
);
}
if let Some(var_2885) = &input.instance_type {
object.key("InstanceType").string(var_2885.as_str());
}
if let Some(var_2886) = &input.volume_size_in_gb {
object.key("VolumeSizeInGB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2886).into()),
);
}
if let Some(var_2887) = &input.volume_kms_key_id {
object.key("VolumeKmsKeyId").string(var_2887.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_provisioning_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProvisioningParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2888) = &input.key {
object.key("Key").string(var_2888.as_str());
}
if let Some(var_2889) = &input.value {
object.key("Value").string(var_2889.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2890) = &input.s3_data_source {
#[allow(unused_mut)]
let mut object_2891 = object.key("S3DataSource").start_object();
crate::json_ser::serialize_structure_crate_model_s3_data_source(
&mut object_2891,
var_2890,
)?;
object_2891.finish();
}
if let Some(var_2892) = &input.file_system_data_source {
#[allow(unused_mut)]
let mut object_2893 = object.key("FileSystemDataSource").start_object();
crate::json_ser::serialize_structure_crate_model_file_system_data_source(
&mut object_2893,
var_2892,
)?;
object_2893.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_shuffle_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ShuffleConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("Seed").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.seed).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_instance_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InstanceGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2894) = &input.instance_type {
object.key("InstanceType").string(var_2894.as_str());
}
{
object.key("InstanceCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.instance_count).into()),
);
}
if let Some(var_2895) = &input.instance_group_name {
object.key("InstanceGroupName").string(var_2895.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_collection_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CollectionConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2896) = &input.collection_name {
object.key("CollectionName").string(var_2896.as_str());
}
if let Some(var_2897) = &input.collection_parameters {
#[allow(unused_mut)]
let mut object_2898 = object.key("CollectionParameters").start_object();
for (key_2899, value_2900) in var_2897 {
{
object_2898
.key(key_2899.as_str())
.string(value_2900.as_str());
}
}
object_2898.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_transform_data_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TransformDataSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2901) = &input.s3_data_source {
#[allow(unused_mut)]
let mut object_2902 = object.key("S3DataSource").start_object();
crate::json_ser::serialize_structure_crate_model_transform_s3_data_source(
&mut object_2902,
var_2901,
)?;
object_2902.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_cognito_member_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CognitoMemberDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2903) = &input.user_pool {
object.key("UserPool").string(var_2903.as_str());
}
if let Some(var_2904) = &input.user_group {
object.key("UserGroup").string(var_2904.as_str());
}
if let Some(var_2905) = &input.client_id {
object.key("ClientId").string(var_2905.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_oidc_member_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OidcMemberDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2906) = &input.groups {
let mut array_2907 = object.key("Groups").start_array();
for item_2908 in var_2906 {
{
array_2907.value().string(item_2908.as_str());
}
}
array_2907.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_property_name_query(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PropertyNameQuery,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2909) = &input.property_name_hint {
object.key("PropertyNameHint").string(var_2909.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_model_metadata_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelMetadataFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2910) = &input.name {
object.key("Name").string(var_2910.as_str());
}
if let Some(var_2911) = &input.value {
object.key("Value").string(var_2911.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_2912) = &input.name {
object.key("Name").string(var_2912.as_str());
}
if let Some(var_2913) = &input.operator {
object.key("Operator").string(var_2913.as_str());
}
if let Some(var_2914) = &input.value {
object.key("Value").string(var_2914.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_nested_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NestedFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2915) = &input.nested_property_name {
object.key("NestedPropertyName").string(var_2915.as_str());
}
if let Some(var_2916) = &input.filters {
let mut array_2917 = object.key("Filters").start_array();
for item_2918 in var_2916 {
{
#[allow(unused_mut)]
let mut object_2919 = array_2917.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(
&mut object_2919,
item_2918,
)?;
object_2919.finish();
}
}
array_2917.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_r_studio_server_pro_domain_settings_for_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RStudioServerProDomainSettingsForUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2920) = &input.domain_execution_role_arn {
object
.key("DomainExecutionRoleArn")
.string(var_2920.as_str());
}
if let Some(var_2921) = &input.default_resource_spec {
#[allow(unused_mut)]
let mut object_2922 = object.key("DefaultResourceSpec").start_object();
crate::json_ser::serialize_structure_crate_model_resource_spec(&mut object_2922, var_2921)?;
object_2922.finish();
}
if let Some(var_2923) = &input.r_studio_connect_url {
object.key("RStudioConnectUrl").string(var_2923.as_str());
}
if let Some(var_2924) = &input.r_studio_package_manager_url {
object
.key("RStudioPackageManagerUrl")
.string(var_2924.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_parameter_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParameterRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2925) = &input.integer_parameter_range_specification {
#[allow(unused_mut)]
let mut object_2926 = object
.key("IntegerParameterRangeSpecification")
.start_object();
crate::json_ser::serialize_structure_crate_model_integer_parameter_range_specification(
&mut object_2926,
var_2925,
)?;
object_2926.finish();
}
if let Some(var_2927) = &input.continuous_parameter_range_specification {
#[allow(unused_mut)]
let mut object_2928 = object
.key("ContinuousParameterRangeSpecification")
.start_object();
crate::json_ser::serialize_structure_crate_model_continuous_parameter_range_specification(
&mut object_2928,
var_2927,
)?;
object_2928.finish();
}
if let Some(var_2929) = &input.categorical_parameter_range_specification {
#[allow(unused_mut)]
let mut object_2930 = object
.key("CategoricalParameterRangeSpecification")
.start_object();
crate::json_ser::serialize_structure_crate_model_categorical_parameter_range_specification(
&mut object_2930,
var_2929,
)?;
object_2930.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2931) = &input.data_input_config {
object.key("DataInputConfig").string(var_2931.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_training_job_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TrainingJobDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2932) = &input.training_input_mode {
object.key("TrainingInputMode").string(var_2932.as_str());
}
if let Some(var_2933) = &input.hyper_parameters {
#[allow(unused_mut)]
let mut object_2934 = object.key("HyperParameters").start_object();
for (key_2935, value_2936) in var_2933 {
{
object_2934
.key(key_2935.as_str())
.string(value_2936.as_str());
}
}
object_2934.finish();
}
if let Some(var_2937) = &input.input_data_config {
let mut array_2938 = object.key("InputDataConfig").start_array();
for item_2939 in var_2937 {
{
#[allow(unused_mut)]
let mut object_2940 = array_2938.value().start_object();
crate::json_ser::serialize_structure_crate_model_channel(
&mut object_2940,
item_2939,
)?;
object_2940.finish();
}
}
array_2938.finish();
}
if let Some(var_2941) = &input.output_data_config {
#[allow(unused_mut)]
let mut object_2942 = object.key("OutputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_output_data_config(
&mut object_2942,
var_2941,
)?;
object_2942.finish();
}
if let Some(var_2943) = &input.resource_config {
#[allow(unused_mut)]
let mut object_2944 = object.key("ResourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_resource_config(
&mut object_2944,
var_2943,
)?;
object_2944.finish();
}
if let Some(var_2945) = &input.stopping_condition {
#[allow(unused_mut)]
let mut object_2946 = object.key("StoppingCondition").start_object();
crate::json_ser::serialize_structure_crate_model_stopping_condition(
&mut object_2946,
var_2945,
)?;
object_2946.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_transform_job_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TransformJobDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2947) = &input.max_concurrent_transforms {
object.key("MaxConcurrentTransforms").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2947).into()),
);
}
if let Some(var_2948) = &input.max_payload_in_mb {
object.key("MaxPayloadInMB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2948).into()),
);
}
if let Some(var_2949) = &input.batch_strategy {
object.key("BatchStrategy").string(var_2949.as_str());
}
if let Some(var_2950) = &input.environment {
#[allow(unused_mut)]
let mut object_2951 = object.key("Environment").start_object();
for (key_2952, value_2953) in var_2950 {
{
object_2951
.key(key_2952.as_str())
.string(value_2953.as_str());
}
}
object_2951.finish();
}
if let Some(var_2954) = &input.transform_input {
#[allow(unused_mut)]
let mut object_2955 = object.key("TransformInput").start_object();
crate::json_ser::serialize_structure_crate_model_transform_input(
&mut object_2955,
var_2954,
)?;
object_2955.finish();
}
if let Some(var_2956) = &input.transform_output {
#[allow(unused_mut)]
let mut object_2957 = object.key("TransformOutput").start_object();
crate::json_ser::serialize_structure_crate_model_transform_output(
&mut object_2957,
var_2956,
)?;
object_2957.finish();
}
if let Some(var_2958) = &input.transform_resources {
#[allow(unused_mut)]
let mut object_2959 = object.key("TransformResources").start_object();
crate::json_ser::serialize_structure_crate_model_transform_resources(
&mut object_2959,
var_2958,
)?;
object_2959.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_mls3_data_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoMls3DataSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2960) = &input.s3_data_type {
object.key("S3DataType").string(var_2960.as_str());
}
if let Some(var_2961) = &input.s3_uri {
object.key("S3Uri").string(var_2961.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_dataset_format(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringDatasetFormat,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2962) = &input.csv {
#[allow(unused_mut)]
let mut object_2963 = object.key("Csv").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_csv_dataset_format(
&mut object_2963,
var_2962,
)?;
object_2963.finish();
}
if let Some(var_2964) = &input.json {
#[allow(unused_mut)]
let mut object_2965 = object.key("Json").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_json_dataset_format(
&mut object_2965,
var_2964,
)?;
object_2965.finish();
}
if let Some(var_2966) = &input.parquet {
#[allow(unused_mut)]
let mut object_2967 = object.key("Parquet").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_parquet_dataset_format(
&mut object_2967,
var_2966,
)?;
object_2967.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_s3_output(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringS3Output,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2968) = &input.s3_uri {
object.key("S3Uri").string(var_2968.as_str());
}
if let Some(var_2969) = &input.local_path {
object.key("LocalPath").string(var_2969.as_str());
}
if let Some(var_2970) = &input.s3_upload_mode {
object.key("S3UploadMode").string(var_2970.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_code_repository(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CodeRepository,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2971) = &input.repository_url {
object.key("RepositoryUrl").string(var_2971.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_image(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomImage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2972) = &input.image_name {
object.key("ImageName").string(var_2972.as_str());
}
if let Some(var_2973) = &input.image_version_number {
object.key("ImageVersionNumber").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2973).into()),
);
}
if let Some(var_2974) = &input.app_image_config_name {
object.key("AppImageConfigName").string(var_2974.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_time_series_forecasting_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeSeriesForecastingSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2975) = &input.status {
object.key("Status").string(var_2975.as_str());
}
if let Some(var_2976) = &input.amazon_forecast_role_arn {
object
.key("AmazonForecastRoleArn")
.string(var_2976.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_traffic_routing_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TrafficRoutingConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2977) = &input.r#type {
object.key("Type").string(var_2977.as_str());
}
if let Some(var_2978) = &input.wait_interval_in_seconds {
object.key("WaitIntervalInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2978).into()),
);
}
if let Some(var_2979) = &input.canary_size {
#[allow(unused_mut)]
let mut object_2980 = object.key("CanarySize").start_object();
crate::json_ser::serialize_structure_crate_model_capacity_size(&mut object_2980, var_2979)?;
object_2980.finish();
}
if let Some(var_2981) = &input.linear_step_size {
#[allow(unused_mut)]
let mut object_2982 = object.key("LinearStepSize").start_object();
crate::json_ser::serialize_structure_crate_model_capacity_size(&mut object_2982, var_2981)?;
object_2982.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_alarm(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Alarm,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2983) = &input.alarm_name {
object.key("AlarmName").string(var_2983.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_async_inference_notification_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AsyncInferenceNotificationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2984) = &input.success_topic {
object.key("SuccessTopic").string(var_2984.as_str());
}
if let Some(var_2985) = &input.error_topic {
object.key("ErrorTopic").string(var_2985.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_clarify_inference_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ClarifyInferenceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2986) = &input.features_attribute {
object.key("FeaturesAttribute").string(var_2986.as_str());
}
if let Some(var_2987) = &input.content_template {
object.key("ContentTemplate").string(var_2987.as_str());
}
if let Some(var_2988) = &input.max_record_count {
object.key("MaxRecordCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2988).into()),
);
}
if let Some(var_2989) = &input.max_payload_in_mb {
object.key("MaxPayloadInMB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2989).into()),
);
}
if let Some(var_2990) = &input.probability_index {
object.key("ProbabilityIndex").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2990).into()),
);
}
if let Some(var_2991) = &input.label_index {
object.key("LabelIndex").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2991).into()),
);
}
if let Some(var_2992) = &input.probability_attribute {
object.key("ProbabilityAttribute").string(var_2992.as_str());
}
if let Some(var_2993) = &input.label_attribute {
object.key("LabelAttribute").string(var_2993.as_str());
}
if let Some(var_2994) = &input.label_headers {
let mut array_2995 = object.key("LabelHeaders").start_array();
for item_2996 in var_2994 {
{
array_2995.value().string(item_2996.as_str());
}
}
array_2995.finish();
}
if let Some(var_2997) = &input.feature_headers {
let mut array_2998 = object.key("FeatureHeaders").start_array();
for item_2999 in var_2997 {
{
array_2998.value().string(item_2999.as_str());
}
}
array_2998.finish();
}
if let Some(var_3000) = &input.feature_types {
let mut array_3001 = object.key("FeatureTypes").start_array();
for item_3002 in var_3000 {
{
array_3001.value().string(item_3002.as_str());
}
}
array_3001.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_clarify_shap_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ClarifyShapConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3003) = &input.shap_baseline_config {
#[allow(unused_mut)]
let mut object_3004 = object.key("ShapBaselineConfig").start_object();
crate::json_ser::serialize_structure_crate_model_clarify_shap_baseline_config(
&mut object_3004,
var_3003,
)?;
object_3004.finish();
}
if let Some(var_3005) = &input.number_of_samples {
object.key("NumberOfSamples").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3005).into()),
);
}
if let Some(var_3006) = &input.use_logit {
object.key("UseLogit").boolean(*var_3006);
}
if let Some(var_3007) = &input.seed {
object.key("Seed").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3007).into()),
);
}
if let Some(var_3008) = &input.text_config {
#[allow(unused_mut)]
let mut object_3009 = object.key("TextConfig").start_object();
crate::json_ser::serialize_structure_crate_model_clarify_text_config(
&mut object_3009,
var_3008,
)?;
object_3009.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_usd(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Usd,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.dollars != 0 {
object.key("Dollars").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.dollars).into()),
);
}
if input.cents != 0 {
object.key("Cents").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.cents).into()),
);
}
if input.tenth_fractions_of_a_cent != 0 {
object.key("TenthFractionsOfACent").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.tenth_fractions_of_a_cent).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_hyperband_strategy_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HyperbandStrategyConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3010) = &input.min_resource {
object.key("MinResource").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3010).into()),
);
}
if let Some(var_3011) = &input.max_resource {
object.key("MaxResource").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3011).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_integer_parameter_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IntegerParameterRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3012) = &input.name {
object.key("Name").string(var_3012.as_str());
}
if let Some(var_3013) = &input.min_value {
object.key("MinValue").string(var_3013.as_str());
}
if let Some(var_3014) = &input.max_value {
object.key("MaxValue").string(var_3014.as_str());
}
if let Some(var_3015) = &input.scaling_type {
object.key("ScalingType").string(var_3015.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_continuous_parameter_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContinuousParameterRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3016) = &input.name {
object.key("Name").string(var_3016.as_str());
}
if let Some(var_3017) = &input.min_value {
object.key("MinValue").string(var_3017.as_str());
}
if let Some(var_3018) = &input.max_value {
object.key("MaxValue").string(var_3018.as_str());
}
if let Some(var_3019) = &input.scaling_type {
object.key("ScalingType").string(var_3019.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_categorical_parameter_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CategoricalParameterRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3020) = &input.name {
object.key("Name").string(var_3020.as_str());
}
if let Some(var_3021) = &input.values {
let mut array_3022 = object.key("Values").start_array();
for item_3023 in var_3021 {
{
array_3022.value().string(item_3023.as_str());
}
}
array_3022.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_hyper_parameter_tuning_instance_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HyperParameterTuningInstanceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3024) = &input.instance_type {
object.key("InstanceType").string(var_3024.as_str());
}
{
object.key("InstanceCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.instance_count).into()),
);
}
{
object.key("VolumeSizeInGB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.volume_size_in_gb).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_real_time_inference_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RealTimeInferenceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3025) = &input.instance_type {
object.key("InstanceType").string(var_3025.as_str());
}
if let Some(var_3026) = &input.instance_count {
object.key("InstanceCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3026).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_phase(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Phase,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3027) = &input.initial_number_of_users {
object.key("InitialNumberOfUsers").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3027).into()),
);
}
if let Some(var_3028) = &input.spawn_rate {
object.key("SpawnRate").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3028).into()),
);
}
if let Some(var_3029) = &input.duration_in_seconds {
object.key("DurationInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3029).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_environment_parameter_ranges(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EnvironmentParameterRanges,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3030) = &input.categorical_parameter_ranges {
let mut array_3031 = object.key("CategoricalParameterRanges").start_array();
for item_3032 in var_3030 {
{
#[allow(unused_mut)]
let mut object_3033 = array_3031.value().start_object();
crate::json_ser::serialize_structure_crate_model_categorical_parameter(
&mut object_3033,
item_3032,
)?;
object_3033.finish();
}
}
array_3031.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_recommendation_job_payload_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RecommendationJobPayloadConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3034) = &input.sample_payload_url {
object.key("SamplePayloadUrl").string(var_3034.as_str());
}
if let Some(var_3035) = &input.supported_content_types {
let mut array_3036 = object.key("SupportedContentTypes").start_array();
for item_3037 in var_3035 {
{
array_3036.value().string(item_3037.as_str());
}
}
array_3036.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_labeling_job_s3_data_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LabelingJobS3DataSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3038) = &input.manifest_s3_uri {
object.key("ManifestS3Uri").string(var_3038.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_labeling_job_sns_data_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LabelingJobSnsDataSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3039) = &input.sns_topic_arn {
object.key("SnsTopicArn").string(var_3039.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_repository_auth_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RepositoryAuthConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3040) = &input.repository_credentials_provider_arn {
object
.key("RepositoryCredentialsProviderArn")
.string(var_3040.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_metrics_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MetricsSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3041) = &input.content_type {
object.key("ContentType").string(var_3041.as_str());
}
if let Some(var_3042) = &input.content_digest {
object.key("ContentDigest").string(var_3042.as_str());
}
if let Some(var_3043) = &input.s3_uri {
object.key("S3Uri").string(var_3043.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_file_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FileSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3044) = &input.content_type {
object.key("ContentType").string(var_3044.as_str());
}
if let Some(var_3045) = &input.content_digest {
object.key("ContentDigest").string(var_3045.as_str());
}
if let Some(var_3046) = &input.s3_uri {
object.key("S3Uri").string(var_3046.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_baseline_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringBaselineConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3047) = &input.baselining_job_name {
object.key("BaseliningJobName").string(var_3047.as_str());
}
if let Some(var_3048) = &input.constraints_resource {
#[allow(unused_mut)]
let mut object_3049 = object.key("ConstraintsResource").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_constraints_resource(
&mut object_3049,
var_3048,
)?;
object_3049.finish();
}
if let Some(var_3050) = &input.statistics_resource {
#[allow(unused_mut)]
let mut object_3051 = object.key("StatisticsResource").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_statistics_resource(
&mut object_3051,
var_3050,
)?;
object_3051.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3052) = &input.endpoint_input {
#[allow(unused_mut)]
let mut object_3053 = object.key("EndpointInput").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_input(
&mut object_3053,
var_3052,
)?;
object_3053.finish();
}
if let Some(var_3054) = &input.batch_transform_input {
#[allow(unused_mut)]
let mut object_3055 = object.key("BatchTransformInput").start_object();
crate::json_ser::serialize_structure_crate_model_batch_transform_input(
&mut object_3055,
var_3054,
)?;
object_3055.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_app_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringAppSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3056) = &input.image_uri {
object.key("ImageUri").string(var_3056.as_str());
}
if let Some(var_3057) = &input.container_entrypoint {
let mut array_3058 = object.key("ContainerEntrypoint").start_array();
for item_3059 in var_3057 {
{
array_3058.value().string(item_3059.as_str());
}
}
array_3058.finish();
}
if let Some(var_3060) = &input.container_arguments {
let mut array_3061 = object.key("ContainerArguments").start_array();
for item_3062 in var_3060 {
{
array_3061.value().string(item_3062.as_str());
}
}
array_3061.finish();
}
if let Some(var_3063) = &input.record_preprocessor_source_uri {
object
.key("RecordPreprocessorSourceUri")
.string(var_3063.as_str());
}
if let Some(var_3064) = &input.post_analytics_processor_source_uri {
object
.key("PostAnalyticsProcessorSourceUri")
.string(var_3064.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_athena_dataset_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AthenaDatasetDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3065) = &input.catalog {
object.key("Catalog").string(var_3065.as_str());
}
if let Some(var_3066) = &input.database {
object.key("Database").string(var_3066.as_str());
}
if let Some(var_3067) = &input.query_string {
object.key("QueryString").string(var_3067.as_str());
}
if let Some(var_3068) = &input.work_group {
object.key("WorkGroup").string(var_3068.as_str());
}
if let Some(var_3069) = &input.output_s3_uri {
object.key("OutputS3Uri").string(var_3069.as_str());
}
if let Some(var_3070) = &input.kms_key_id {
object.key("KmsKeyId").string(var_3070.as_str());
}
if let Some(var_3071) = &input.output_format {
object.key("OutputFormat").string(var_3071.as_str());
}
if let Some(var_3072) = &input.output_compression {
object.key("OutputCompression").string(var_3072.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_redshift_dataset_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RedshiftDatasetDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3073) = &input.cluster_id {
object.key("ClusterId").string(var_3073.as_str());
}
if let Some(var_3074) = &input.database {
object.key("Database").string(var_3074.as_str());
}
if let Some(var_3075) = &input.db_user {
object.key("DbUser").string(var_3075.as_str());
}
if let Some(var_3076) = &input.query_string {
object.key("QueryString").string(var_3076.as_str());
}
if let Some(var_3077) = &input.cluster_role_arn {
object.key("ClusterRoleArn").string(var_3077.as_str());
}
if let Some(var_3078) = &input.output_s3_uri {
object.key("OutputS3Uri").string(var_3078.as_str());
}
if let Some(var_3079) = &input.kms_key_id {
object.key("KmsKeyId").string(var_3079.as_str());
}
if let Some(var_3080) = &input.output_format {
object.key("OutputFormat").string(var_3080.as_str());
}
if let Some(var_3081) = &input.output_compression {
object.key("OutputCompression").string(var_3081.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_processing_s3_output(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProcessingS3Output,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3082) = &input.s3_uri {
object.key("S3Uri").string(var_3082.as_str());
}
if let Some(var_3083) = &input.local_path {
object.key("LocalPath").string(var_3083.as_str());
}
if let Some(var_3084) = &input.s3_upload_mode {
object.key("S3UploadMode").string(var_3084.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_processing_feature_store_output(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProcessingFeatureStoreOutput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3085) = &input.feature_group_name {
object.key("FeatureGroupName").string(var_3085.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_data_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3DataSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3086) = &input.s3_data_type {
object.key("S3DataType").string(var_3086.as_str());
}
if let Some(var_3087) = &input.s3_uri {
object.key("S3Uri").string(var_3087.as_str());
}
if let Some(var_3088) = &input.s3_data_distribution_type {
object
.key("S3DataDistributionType")
.string(var_3088.as_str());
}
if let Some(var_3089) = &input.attribute_names {
let mut array_3090 = object.key("AttributeNames").start_array();
for item_3091 in var_3089 {
{
array_3090.value().string(item_3091.as_str());
}
}
array_3090.finish();
}
if let Some(var_3092) = &input.instance_group_names {
let mut array_3093 = object.key("InstanceGroupNames").start_array();
for item_3094 in var_3092 {
{
array_3093.value().string(item_3094.as_str());
}
}
array_3093.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_file_system_data_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FileSystemDataSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3095) = &input.file_system_id {
object.key("FileSystemId").string(var_3095.as_str());
}
if let Some(var_3096) = &input.file_system_access_mode {
object.key("FileSystemAccessMode").string(var_3096.as_str());
}
if let Some(var_3097) = &input.file_system_type {
object.key("FileSystemType").string(var_3097.as_str());
}
if let Some(var_3098) = &input.directory_path {
object.key("DirectoryPath").string(var_3098.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_transform_s3_data_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TransformS3DataSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3099) = &input.s3_data_type {
object.key("S3DataType").string(var_3099.as_str());
}
if let Some(var_3100) = &input.s3_uri {
object.key("S3Uri").string(var_3100.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_integer_parameter_range_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IntegerParameterRangeSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3101) = &input.min_value {
object.key("MinValue").string(var_3101.as_str());
}
if let Some(var_3102) = &input.max_value {
object.key("MaxValue").string(var_3102.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_continuous_parameter_range_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContinuousParameterRangeSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3103) = &input.min_value {
object.key("MinValue").string(var_3103.as_str());
}
if let Some(var_3104) = &input.max_value {
object.key("MaxValue").string(var_3104.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_categorical_parameter_range_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CategoricalParameterRangeSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3105) = &input.values {
let mut array_3106 = object.key("Values").start_array();
for item_3107 in var_3105 {
{
array_3106.value().string(item_3107.as_str());
}
}
array_3106.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_csv_dataset_format(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringCsvDatasetFormat,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.header {
object.key("Header").boolean(input.header);
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_json_dataset_format(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringJsonDatasetFormat,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.line {
object.key("Line").boolean(input.line);
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_parquet_dataset_format(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringParquetDatasetFormat,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}
pub fn serialize_structure_crate_model_capacity_size(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CapacitySize,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3108) = &input.r#type {
object.key("Type").string(var_3108.as_str());
}
if let Some(var_3109) = &input.value {
object.key("Value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3109).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_clarify_shap_baseline_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ClarifyShapBaselineConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3110) = &input.mime_type {
object.key("MimeType").string(var_3110.as_str());
}
if let Some(var_3111) = &input.shap_baseline {
object.key("ShapBaseline").string(var_3111.as_str());
}
if let Some(var_3112) = &input.shap_baseline_uri {
object.key("ShapBaselineUri").string(var_3112.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_clarify_text_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ClarifyTextConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3113) = &input.language {
object.key("Language").string(var_3113.as_str());
}
if let Some(var_3114) = &input.granularity {
object.key("Granularity").string(var_3114.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_categorical_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CategoricalParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3115) = &input.name {
object.key("Name").string(var_3115.as_str());
}
if let Some(var_3116) = &input.value {
let mut array_3117 = object.key("Value").start_array();
for item_3118 in var_3116 {
{
array_3117.value().string(item_3118.as_str());
}
}
array_3117.finish();
}
Ok(())
}