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_1) = &input.access_token {
object.key("accessToken").string(var_1.as_str());
}
if let Some(var_2) = &input.auto_branch_creation_config {
#[allow(unused_mut)]
let mut object_3 = object.key("autoBranchCreationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_auto_branch_creation_config(
&mut object_3,
var_2,
)?;
object_3.finish();
}
if let Some(var_4) = &input.auto_branch_creation_patterns {
let mut array_5 = object.key("autoBranchCreationPatterns").start_array();
for item_6 in var_4 {
{
array_5.value().string(item_6.as_str());
}
}
array_5.finish();
}
if let Some(var_7) = &input.basic_auth_credentials {
object.key("basicAuthCredentials").string(var_7.as_str());
}
if let Some(var_8) = &input.build_spec {
object.key("buildSpec").string(var_8.as_str());
}
if let Some(var_9) = &input.custom_headers {
object.key("customHeaders").string(var_9.as_str());
}
if let Some(var_10) = &input.custom_rules {
let mut array_11 = object.key("customRules").start_array();
for item_12 in var_10 {
{
#[allow(unused_mut)]
let mut object_13 = array_11.value().start_object();
crate::json_ser::serialize_structure_crate_model_custom_rule(
&mut object_13,
item_12,
)?;
object_13.finish();
}
}
array_11.finish();
}
if let Some(var_14) = &input.description {
object.key("description").string(var_14.as_str());
}
if let Some(var_15) = &input.enable_auto_branch_creation {
object.key("enableAutoBranchCreation").boolean(*var_15);
}
if let Some(var_16) = &input.enable_basic_auth {
object.key("enableBasicAuth").boolean(*var_16);
}
if let Some(var_17) = &input.enable_branch_auto_build {
object.key("enableBranchAutoBuild").boolean(*var_17);
}
if let Some(var_18) = &input.enable_branch_auto_deletion {
object.key("enableBranchAutoDeletion").boolean(*var_18);
}
if let Some(var_19) = &input.environment_variables {
#[allow(unused_mut)]
let mut object_20 = object.key("environmentVariables").start_object();
for (key_21, value_22) in var_19 {
{
object_20.key(key_21.as_str()).string(value_22.as_str());
}
}
object_20.finish();
}
if let Some(var_23) = &input.iam_service_role_arn {
object.key("iamServiceRoleArn").string(var_23.as_str());
}
if let Some(var_24) = &input.name {
object.key("name").string(var_24.as_str());
}
if let Some(var_25) = &input.oauth_token {
object.key("oauthToken").string(var_25.as_str());
}
if let Some(var_26) = &input.platform {
object.key("platform").string(var_26.as_str());
}
if let Some(var_27) = &input.repository {
object.key("repository").string(var_27.as_str());
}
if let Some(var_28) = &input.tags {
#[allow(unused_mut)]
let mut object_29 = object.key("tags").start_object();
for (key_30, value_31) in var_28 {
{
object_29.key(key_30.as_str()).string(value_31.as_str());
}
}
object_29.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_backend_environment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBackendEnvironmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_32) = &input.deployment_artifacts {
object.key("deploymentArtifacts").string(var_32.as_str());
}
if let Some(var_33) = &input.environment_name {
object.key("environmentName").string(var_33.as_str());
}
if let Some(var_34) = &input.stack_name {
object.key("stackName").string(var_34.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_branch_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBranchInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.backend_environment_arn {
object.key("backendEnvironmentArn").string(var_35.as_str());
}
if let Some(var_36) = &input.basic_auth_credentials {
object.key("basicAuthCredentials").string(var_36.as_str());
}
if let Some(var_37) = &input.branch_name {
object.key("branchName").string(var_37.as_str());
}
if let Some(var_38) = &input.build_spec {
object.key("buildSpec").string(var_38.as_str());
}
if let Some(var_39) = &input.description {
object.key("description").string(var_39.as_str());
}
if let Some(var_40) = &input.display_name {
object.key("displayName").string(var_40.as_str());
}
if let Some(var_41) = &input.enable_auto_build {
object.key("enableAutoBuild").boolean(*var_41);
}
if let Some(var_42) = &input.enable_basic_auth {
object.key("enableBasicAuth").boolean(*var_42);
}
if let Some(var_43) = &input.enable_notification {
object.key("enableNotification").boolean(*var_43);
}
if let Some(var_44) = &input.enable_performance_mode {
object.key("enablePerformanceMode").boolean(*var_44);
}
if let Some(var_45) = &input.enable_pull_request_preview {
object.key("enablePullRequestPreview").boolean(*var_45);
}
if let Some(var_46) = &input.environment_variables {
#[allow(unused_mut)]
let mut object_47 = object.key("environmentVariables").start_object();
for (key_48, value_49) in var_46 {
{
object_47.key(key_48.as_str()).string(value_49.as_str());
}
}
object_47.finish();
}
if let Some(var_50) = &input.framework {
object.key("framework").string(var_50.as_str());
}
if let Some(var_51) = &input.pull_request_environment_name {
object
.key("pullRequestEnvironmentName")
.string(var_51.as_str());
}
if let Some(var_52) = &input.stage {
object.key("stage").string(var_52.as_str());
}
if let Some(var_53) = &input.tags {
#[allow(unused_mut)]
let mut object_54 = object.key("tags").start_object();
for (key_55, value_56) in var_53 {
{
object_54.key(key_55.as_str()).string(value_56.as_str());
}
}
object_54.finish();
}
if let Some(var_57) = &input.ttl {
object.key("ttl").string(var_57.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_deployment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDeploymentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_58) = &input.file_map {
#[allow(unused_mut)]
let mut object_59 = object.key("fileMap").start_object();
for (key_60, value_61) in var_58 {
{
object_59.key(key_60.as_str()).string(value_61.as_str());
}
}
object_59.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_domain_association_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDomainAssociationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_62) = &input.auto_sub_domain_creation_patterns {
let mut array_63 = object.key("autoSubDomainCreationPatterns").start_array();
for item_64 in var_62 {
{
array_63.value().string(item_64.as_str());
}
}
array_63.finish();
}
if let Some(var_65) = &input.auto_sub_domain_iam_role {
object.key("autoSubDomainIAMRole").string(var_65.as_str());
}
if let Some(var_66) = &input.domain_name {
object.key("domainName").string(var_66.as_str());
}
if let Some(var_67) = &input.enable_auto_sub_domain {
object.key("enableAutoSubDomain").boolean(*var_67);
}
if let Some(var_68) = &input.sub_domain_settings {
let mut array_69 = object.key("subDomainSettings").start_array();
for item_70 in var_68 {
{
#[allow(unused_mut)]
let mut object_71 = array_69.value().start_object();
crate::json_ser::serialize_structure_crate_model_sub_domain_setting(
&mut object_71,
item_70,
)?;
object_71.finish();
}
}
array_69.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_webhook_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateWebhookInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_72) = &input.branch_name {
object.key("branchName").string(var_72.as_str());
}
if let Some(var_73) = &input.description {
object.key("description").string(var_73.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_generate_access_logs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GenerateAccessLogsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_74) = &input.domain_name {
object.key("domainName").string(var_74.as_str());
}
if let Some(var_75) = &input.end_time {
object
.key("endTime")
.date_time(var_75, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_76) = &input.start_time {
object
.key("startTime")
.date_time(var_76, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_input_start_deployment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartDeploymentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_77) = &input.job_id {
object.key("jobId").string(var_77.as_str());
}
if let Some(var_78) = &input.source_url {
object.key("sourceUrl").string(var_78.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_79) = &input.commit_id {
object.key("commitId").string(var_79.as_str());
}
if let Some(var_80) = &input.commit_message {
object.key("commitMessage").string(var_80.as_str());
}
if let Some(var_81) = &input.commit_time {
object
.key("commitTime")
.date_time(var_81, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_82) = &input.job_id {
object.key("jobId").string(var_82.as_str());
}
if let Some(var_83) = &input.job_reason {
object.key("jobReason").string(var_83.as_str());
}
if let Some(var_84) = &input.job_type {
object.key("jobType").string(var_84.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.tags {
#[allow(unused_mut)]
let mut object_86 = object.key("tags").start_object();
for (key_87, value_88) in var_85 {
{
object_86.key(key_87.as_str()).string(value_88.as_str());
}
}
object_86.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_app_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAppInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.access_token {
object.key("accessToken").string(var_89.as_str());
}
if let Some(var_90) = &input.auto_branch_creation_config {
#[allow(unused_mut)]
let mut object_91 = object.key("autoBranchCreationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_auto_branch_creation_config(
&mut object_91,
var_90,
)?;
object_91.finish();
}
if let Some(var_92) = &input.auto_branch_creation_patterns {
let mut array_93 = object.key("autoBranchCreationPatterns").start_array();
for item_94 in var_92 {
{
array_93.value().string(item_94.as_str());
}
}
array_93.finish();
}
if let Some(var_95) = &input.basic_auth_credentials {
object.key("basicAuthCredentials").string(var_95.as_str());
}
if let Some(var_96) = &input.build_spec {
object.key("buildSpec").string(var_96.as_str());
}
if let Some(var_97) = &input.custom_headers {
object.key("customHeaders").string(var_97.as_str());
}
if let Some(var_98) = &input.custom_rules {
let mut array_99 = object.key("customRules").start_array();
for item_100 in var_98 {
{
#[allow(unused_mut)]
let mut object_101 = array_99.value().start_object();
crate::json_ser::serialize_structure_crate_model_custom_rule(
&mut object_101,
item_100,
)?;
object_101.finish();
}
}
array_99.finish();
}
if let Some(var_102) = &input.description {
object.key("description").string(var_102.as_str());
}
if let Some(var_103) = &input.enable_auto_branch_creation {
object.key("enableAutoBranchCreation").boolean(*var_103);
}
if let Some(var_104) = &input.enable_basic_auth {
object.key("enableBasicAuth").boolean(*var_104);
}
if let Some(var_105) = &input.enable_branch_auto_build {
object.key("enableBranchAutoBuild").boolean(*var_105);
}
if let Some(var_106) = &input.enable_branch_auto_deletion {
object.key("enableBranchAutoDeletion").boolean(*var_106);
}
if let Some(var_107) = &input.environment_variables {
#[allow(unused_mut)]
let mut object_108 = object.key("environmentVariables").start_object();
for (key_109, value_110) in var_107 {
{
object_108.key(key_109.as_str()).string(value_110.as_str());
}
}
object_108.finish();
}
if let Some(var_111) = &input.iam_service_role_arn {
object.key("iamServiceRoleArn").string(var_111.as_str());
}
if let Some(var_112) = &input.name {
object.key("name").string(var_112.as_str());
}
if let Some(var_113) = &input.oauth_token {
object.key("oauthToken").string(var_113.as_str());
}
if let Some(var_114) = &input.platform {
object.key("platform").string(var_114.as_str());
}
if let Some(var_115) = &input.repository {
object.key("repository").string(var_115.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_branch_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBranchInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_116) = &input.backend_environment_arn {
object.key("backendEnvironmentArn").string(var_116.as_str());
}
if let Some(var_117) = &input.basic_auth_credentials {
object.key("basicAuthCredentials").string(var_117.as_str());
}
if let Some(var_118) = &input.build_spec {
object.key("buildSpec").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.display_name {
object.key("displayName").string(var_120.as_str());
}
if let Some(var_121) = &input.enable_auto_build {
object.key("enableAutoBuild").boolean(*var_121);
}
if let Some(var_122) = &input.enable_basic_auth {
object.key("enableBasicAuth").boolean(*var_122);
}
if let Some(var_123) = &input.enable_notification {
object.key("enableNotification").boolean(*var_123);
}
if let Some(var_124) = &input.enable_performance_mode {
object.key("enablePerformanceMode").boolean(*var_124);
}
if let Some(var_125) = &input.enable_pull_request_preview {
object.key("enablePullRequestPreview").boolean(*var_125);
}
if let Some(var_126) = &input.environment_variables {
#[allow(unused_mut)]
let mut object_127 = object.key("environmentVariables").start_object();
for (key_128, value_129) in var_126 {
{
object_127.key(key_128.as_str()).string(value_129.as_str());
}
}
object_127.finish();
}
if let Some(var_130) = &input.framework {
object.key("framework").string(var_130.as_str());
}
if let Some(var_131) = &input.pull_request_environment_name {
object
.key("pullRequestEnvironmentName")
.string(var_131.as_str());
}
if let Some(var_132) = &input.stage {
object.key("stage").string(var_132.as_str());
}
if let Some(var_133) = &input.ttl {
object.key("ttl").string(var_133.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_domain_association_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDomainAssociationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_134) = &input.auto_sub_domain_creation_patterns {
let mut array_135 = object.key("autoSubDomainCreationPatterns").start_array();
for item_136 in var_134 {
{
array_135.value().string(item_136.as_str());
}
}
array_135.finish();
}
if let Some(var_137) = &input.auto_sub_domain_iam_role {
object.key("autoSubDomainIAMRole").string(var_137.as_str());
}
if let Some(var_138) = &input.enable_auto_sub_domain {
object.key("enableAutoSubDomain").boolean(*var_138);
}
if let Some(var_139) = &input.sub_domain_settings {
let mut array_140 = object.key("subDomainSettings").start_array();
for item_141 in var_139 {
{
#[allow(unused_mut)]
let mut object_142 = array_140.value().start_object();
crate::json_ser::serialize_structure_crate_model_sub_domain_setting(
&mut object_142,
item_141,
)?;
object_142.finish();
}
}
array_140.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_webhook_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateWebhookInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_143) = &input.branch_name {
object.key("branchName").string(var_143.as_str());
}
if let Some(var_144) = &input.description {
object.key("description").string(var_144.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_branch_creation_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoBranchCreationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_145) = &input.stage {
object.key("stage").string(var_145.as_str());
}
if let Some(var_146) = &input.framework {
object.key("framework").string(var_146.as_str());
}
if let Some(var_147) = &input.enable_auto_build {
object.key("enableAutoBuild").boolean(*var_147);
}
if let Some(var_148) = &input.environment_variables {
#[allow(unused_mut)]
let mut object_149 = object.key("environmentVariables").start_object();
for (key_150, value_151) in var_148 {
{
object_149.key(key_150.as_str()).string(value_151.as_str());
}
}
object_149.finish();
}
if let Some(var_152) = &input.basic_auth_credentials {
object.key("basicAuthCredentials").string(var_152.as_str());
}
if let Some(var_153) = &input.enable_basic_auth {
object.key("enableBasicAuth").boolean(*var_153);
}
if let Some(var_154) = &input.enable_performance_mode {
object.key("enablePerformanceMode").boolean(*var_154);
}
if let Some(var_155) = &input.build_spec {
object.key("buildSpec").string(var_155.as_str());
}
if let Some(var_156) = &input.enable_pull_request_preview {
object.key("enablePullRequestPreview").boolean(*var_156);
}
if let Some(var_157) = &input.pull_request_environment_name {
object
.key("pullRequestEnvironmentName")
.string(var_157.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_158) = &input.source {
object.key("source").string(var_158.as_str());
}
if let Some(var_159) = &input.target {
object.key("target").string(var_159.as_str());
}
if let Some(var_160) = &input.status {
object.key("status").string(var_160.as_str());
}
if let Some(var_161) = &input.condition {
object.key("condition").string(var_161.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sub_domain_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SubDomainSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_162) = &input.prefix {
object.key("prefix").string(var_162.as_str());
}
if let Some(var_163) = &input.branch_name {
object.key("branchName").string(var_163.as_str());
}
Ok(())
}