pub fn serialize_structure_crate_input_copy_package_versions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CopyPackageVersionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_1) = &input.allow_overwrite {
object.key("allowOverwrite").boolean(*var_1);
}
if let Some(var_2) = &input.include_from_upstream {
object.key("includeFromUpstream").boolean(*var_2);
}
if let Some(var_3) = &input.version_revisions {
let mut object_4 = object.key("versionRevisions").start_object();
for (key_5, value_6) in var_3 {
{
object_4.key(key_5).string(value_6);
}
}
object_4.finish();
}
if let Some(var_7) = &input.versions {
let mut array_8 = object.key("versions").start_array();
for item_9 in var_7 {
{
array_8.value().string(item_9);
}
}
array_8.finish();
}
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::SerializationError> {
if let Some(var_10) = &input.encryption_key {
object.key("encryptionKey").string(var_10);
}
if let Some(var_11) = &input.tags {
let mut array_12 = object.key("tags").start_array();
for item_13 in var_11 {
{
let mut object_14 = array_12.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_14, item_13)?;
object_14.finish();
}
}
array_12.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_repository_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateRepositoryInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_15) = &input.description {
object.key("description").string(var_15);
}
if let Some(var_16) = &input.tags {
let mut array_17 = object.key("tags").start_array();
for item_18 in var_16 {
{
let mut object_19 = array_17.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_19, item_18)?;
object_19.finish();
}
}
array_17.finish();
}
if let Some(var_20) = &input.upstreams {
let mut array_21 = object.key("upstreams").start_array();
for item_22 in var_20 {
{
let mut object_23 = array_21.value().start_object();
crate::json_ser::serialize_structure_crate_model_upstream_repository(
&mut object_23,
item_22,
)?;
object_23.finish();
}
}
array_21.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_package_versions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeletePackageVersionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_24) = &input.expected_status {
object.key("expectedStatus").string(var_24.as_str());
}
if let Some(var_25) = &input.versions {
let mut array_26 = object.key("versions").start_array();
for item_27 in var_25 {
{
array_26.value().string(item_27);
}
}
array_26.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_dispose_package_versions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisposePackageVersionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_28) = &input.expected_status {
object.key("expectedStatus").string(var_28.as_str());
}
if let Some(var_29) = &input.version_revisions {
let mut object_30 = object.key("versionRevisions").start_object();
for (key_31, value_32) in var_29 {
{
object_30.key(key_31).string(value_32);
}
}
object_30.finish();
}
if let Some(var_33) = &input.versions {
let mut array_34 = object.key("versions").start_array();
for item_35 in var_33 {
{
array_34.value().string(item_35);
}
}
array_34.finish();
}
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::SerializationError> {
if let Some(var_36) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_36).into()),
);
}
if let Some(var_37) = &input.next_token {
object.key("nextToken").string(var_37);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_domain_permissions_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutDomainPermissionsPolicyInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_38) = &input.domain {
object.key("domain").string(var_38);
}
if let Some(var_39) = &input.domain_owner {
object.key("domainOwner").string(var_39);
}
if let Some(var_40) = &input.policy_document {
object.key("policyDocument").string(var_40);
}
if let Some(var_41) = &input.policy_revision {
object.key("policyRevision").string(var_41);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_repository_permissions_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutRepositoryPermissionsPolicyInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_42) = &input.policy_document {
object.key("policyDocument").string(var_42);
}
if let Some(var_43) = &input.policy_revision {
object.key("policyRevision").string(var_43);
}
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::SerializationError> {
if let Some(var_44) = &input.tags {
let mut array_45 = object.key("tags").start_array();
for item_46 in var_44 {
{
let mut object_47 = array_45.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_47, item_46)?;
object_47.finish();
}
}
array_45.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_untag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UntagResourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_48) = &input.tag_keys {
let mut array_49 = object.key("tagKeys").start_array();
for item_50 in var_48 {
{
array_49.value().string(item_50);
}
}
array_49.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_package_versions_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePackageVersionsStatusInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_51) = &input.expected_status {
object.key("expectedStatus").string(var_51.as_str());
}
if let Some(var_52) = &input.target_status {
object.key("targetStatus").string(var_52.as_str());
}
if let Some(var_53) = &input.version_revisions {
let mut object_54 = object.key("versionRevisions").start_object();
for (key_55, value_56) in var_53 {
{
object_54.key(key_55).string(value_56);
}
}
object_54.finish();
}
if let Some(var_57) = &input.versions {
let mut array_58 = object.key("versions").start_array();
for item_59 in var_57 {
{
array_58.value().string(item_59);
}
}
array_58.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_repository_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRepositoryInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_60) = &input.description {
object.key("description").string(var_60);
}
if let Some(var_61) = &input.upstreams {
let mut array_62 = object.key("upstreams").start_array();
for item_63 in var_61 {
{
let mut object_64 = array_62.value().start_object();
crate::json_ser::serialize_structure_crate_model_upstream_repository(
&mut object_64,
item_63,
)?;
object_64.finish();
}
}
array_62.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::SerializationError> {
if let Some(var_65) = &input.key {
object.key("key").string(var_65);
}
if let Some(var_66) = &input.value {
object.key("value").string(var_66);
}
Ok(())
}
pub fn serialize_structure_crate_model_upstream_repository(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpstreamRepository,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_67) = &input.repository_name {
object.key("repositoryName").string(var_67);
}
Ok(())
}