aws-sdk-appmesh 1.101.0

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub(crate) fn create_gateway_route_output_output_correct_errors(
    mut builder: crate::operation::create_gateway_route::builders::CreateGatewayRouteOutputBuilder,
) -> crate::operation::create_gateway_route::builders::CreateGatewayRouteOutputBuilder {
    if builder.gateway_route.is_none() {
        builder.gateway_route = {
            let builder = crate::types::builders::GatewayRouteDataBuilder::default();
            crate::serde_util::gateway_route_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn create_mesh_output_output_correct_errors(
    mut builder: crate::operation::create_mesh::builders::CreateMeshOutputBuilder,
) -> crate::operation::create_mesh::builders::CreateMeshOutputBuilder {
    if builder.mesh.is_none() {
        builder.mesh = {
            let builder = crate::types::builders::MeshDataBuilder::default();
            crate::serde_util::mesh_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn create_route_output_output_correct_errors(
    mut builder: crate::operation::create_route::builders::CreateRouteOutputBuilder,
) -> crate::operation::create_route::builders::CreateRouteOutputBuilder {
    if builder.route.is_none() {
        builder.route = {
            let builder = crate::types::builders::RouteDataBuilder::default();
            crate::serde_util::route_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn create_virtual_gateway_output_output_correct_errors(
    mut builder: crate::operation::create_virtual_gateway::builders::CreateVirtualGatewayOutputBuilder,
) -> crate::operation::create_virtual_gateway::builders::CreateVirtualGatewayOutputBuilder {
    if builder.virtual_gateway.is_none() {
        builder.virtual_gateway = {
            let builder = crate::types::builders::VirtualGatewayDataBuilder::default();
            crate::serde_util::virtual_gateway_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn create_virtual_node_output_output_correct_errors(
    mut builder: crate::operation::create_virtual_node::builders::CreateVirtualNodeOutputBuilder,
) -> crate::operation::create_virtual_node::builders::CreateVirtualNodeOutputBuilder {
    if builder.virtual_node.is_none() {
        builder.virtual_node = {
            let builder = crate::types::builders::VirtualNodeDataBuilder::default();
            crate::serde_util::virtual_node_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn create_virtual_router_output_output_correct_errors(
    mut builder: crate::operation::create_virtual_router::builders::CreateVirtualRouterOutputBuilder,
) -> crate::operation::create_virtual_router::builders::CreateVirtualRouterOutputBuilder {
    if builder.virtual_router.is_none() {
        builder.virtual_router = {
            let builder = crate::types::builders::VirtualRouterDataBuilder::default();
            crate::serde_util::virtual_router_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn create_virtual_service_output_output_correct_errors(
    mut builder: crate::operation::create_virtual_service::builders::CreateVirtualServiceOutputBuilder,
) -> crate::operation::create_virtual_service::builders::CreateVirtualServiceOutputBuilder {
    if builder.virtual_service.is_none() {
        builder.virtual_service = {
            let builder = crate::types::builders::VirtualServiceDataBuilder::default();
            crate::serde_util::virtual_service_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn delete_gateway_route_output_output_correct_errors(
    mut builder: crate::operation::delete_gateway_route::builders::DeleteGatewayRouteOutputBuilder,
) -> crate::operation::delete_gateway_route::builders::DeleteGatewayRouteOutputBuilder {
    if builder.gateway_route.is_none() {
        builder.gateway_route = {
            let builder = crate::types::builders::GatewayRouteDataBuilder::default();
            crate::serde_util::gateway_route_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn delete_mesh_output_output_correct_errors(
    mut builder: crate::operation::delete_mesh::builders::DeleteMeshOutputBuilder,
) -> crate::operation::delete_mesh::builders::DeleteMeshOutputBuilder {
    if builder.mesh.is_none() {
        builder.mesh = {
            let builder = crate::types::builders::MeshDataBuilder::default();
            crate::serde_util::mesh_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn delete_route_output_output_correct_errors(
    mut builder: crate::operation::delete_route::builders::DeleteRouteOutputBuilder,
) -> crate::operation::delete_route::builders::DeleteRouteOutputBuilder {
    if builder.route.is_none() {
        builder.route = {
            let builder = crate::types::builders::RouteDataBuilder::default();
            crate::serde_util::route_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn delete_virtual_gateway_output_output_correct_errors(
    mut builder: crate::operation::delete_virtual_gateway::builders::DeleteVirtualGatewayOutputBuilder,
) -> crate::operation::delete_virtual_gateway::builders::DeleteVirtualGatewayOutputBuilder {
    if builder.virtual_gateway.is_none() {
        builder.virtual_gateway = {
            let builder = crate::types::builders::VirtualGatewayDataBuilder::default();
            crate::serde_util::virtual_gateway_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn delete_virtual_node_output_output_correct_errors(
    mut builder: crate::operation::delete_virtual_node::builders::DeleteVirtualNodeOutputBuilder,
) -> crate::operation::delete_virtual_node::builders::DeleteVirtualNodeOutputBuilder {
    if builder.virtual_node.is_none() {
        builder.virtual_node = {
            let builder = crate::types::builders::VirtualNodeDataBuilder::default();
            crate::serde_util::virtual_node_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn delete_virtual_router_output_output_correct_errors(
    mut builder: crate::operation::delete_virtual_router::builders::DeleteVirtualRouterOutputBuilder,
) -> crate::operation::delete_virtual_router::builders::DeleteVirtualRouterOutputBuilder {
    if builder.virtual_router.is_none() {
        builder.virtual_router = {
            let builder = crate::types::builders::VirtualRouterDataBuilder::default();
            crate::serde_util::virtual_router_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn delete_virtual_service_output_output_correct_errors(
    mut builder: crate::operation::delete_virtual_service::builders::DeleteVirtualServiceOutputBuilder,
) -> crate::operation::delete_virtual_service::builders::DeleteVirtualServiceOutputBuilder {
    if builder.virtual_service.is_none() {
        builder.virtual_service = {
            let builder = crate::types::builders::VirtualServiceDataBuilder::default();
            crate::serde_util::virtual_service_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn describe_gateway_route_output_output_correct_errors(
    mut builder: crate::operation::describe_gateway_route::builders::DescribeGatewayRouteOutputBuilder,
) -> crate::operation::describe_gateway_route::builders::DescribeGatewayRouteOutputBuilder {
    if builder.gateway_route.is_none() {
        builder.gateway_route = {
            let builder = crate::types::builders::GatewayRouteDataBuilder::default();
            crate::serde_util::gateway_route_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn describe_mesh_output_output_correct_errors(
    mut builder: crate::operation::describe_mesh::builders::DescribeMeshOutputBuilder,
) -> crate::operation::describe_mesh::builders::DescribeMeshOutputBuilder {
    if builder.mesh.is_none() {
        builder.mesh = {
            let builder = crate::types::builders::MeshDataBuilder::default();
            crate::serde_util::mesh_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn describe_route_output_output_correct_errors(
    mut builder: crate::operation::describe_route::builders::DescribeRouteOutputBuilder,
) -> crate::operation::describe_route::builders::DescribeRouteOutputBuilder {
    if builder.route.is_none() {
        builder.route = {
            let builder = crate::types::builders::RouteDataBuilder::default();
            crate::serde_util::route_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn describe_virtual_gateway_output_output_correct_errors(
    mut builder: crate::operation::describe_virtual_gateway::builders::DescribeVirtualGatewayOutputBuilder,
) -> crate::operation::describe_virtual_gateway::builders::DescribeVirtualGatewayOutputBuilder {
    if builder.virtual_gateway.is_none() {
        builder.virtual_gateway = {
            let builder = crate::types::builders::VirtualGatewayDataBuilder::default();
            crate::serde_util::virtual_gateway_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn describe_virtual_node_output_output_correct_errors(
    mut builder: crate::operation::describe_virtual_node::builders::DescribeVirtualNodeOutputBuilder,
) -> crate::operation::describe_virtual_node::builders::DescribeVirtualNodeOutputBuilder {
    if builder.virtual_node.is_none() {
        builder.virtual_node = {
            let builder = crate::types::builders::VirtualNodeDataBuilder::default();
            crate::serde_util::virtual_node_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn describe_virtual_router_output_output_correct_errors(
    mut builder: crate::operation::describe_virtual_router::builders::DescribeVirtualRouterOutputBuilder,
) -> crate::operation::describe_virtual_router::builders::DescribeVirtualRouterOutputBuilder {
    if builder.virtual_router.is_none() {
        builder.virtual_router = {
            let builder = crate::types::builders::VirtualRouterDataBuilder::default();
            crate::serde_util::virtual_router_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn describe_virtual_service_output_output_correct_errors(
    mut builder: crate::operation::describe_virtual_service::builders::DescribeVirtualServiceOutputBuilder,
) -> crate::operation::describe_virtual_service::builders::DescribeVirtualServiceOutputBuilder {
    if builder.virtual_service.is_none() {
        builder.virtual_service = {
            let builder = crate::types::builders::VirtualServiceDataBuilder::default();
            crate::serde_util::virtual_service_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn list_gateway_routes_output_output_correct_errors(
    mut builder: crate::operation::list_gateway_routes::builders::ListGatewayRoutesOutputBuilder,
) -> crate::operation::list_gateway_routes::builders::ListGatewayRoutesOutputBuilder {
    if builder.gateway_routes.is_none() {
        builder.gateway_routes = Some(Default::default())
    }
    builder
}

pub(crate) fn list_meshes_output_output_correct_errors(
    mut builder: crate::operation::list_meshes::builders::ListMeshesOutputBuilder,
) -> crate::operation::list_meshes::builders::ListMeshesOutputBuilder {
    if builder.meshes.is_none() {
        builder.meshes = Some(Default::default())
    }
    builder
}

pub(crate) fn list_routes_output_output_correct_errors(
    mut builder: crate::operation::list_routes::builders::ListRoutesOutputBuilder,
) -> crate::operation::list_routes::builders::ListRoutesOutputBuilder {
    if builder.routes.is_none() {
        builder.routes = Some(Default::default())
    }
    builder
}

pub(crate) fn list_tags_for_resource_output_output_correct_errors(
    mut builder: crate::operation::list_tags_for_resource::builders::ListTagsForResourceOutputBuilder,
) -> crate::operation::list_tags_for_resource::builders::ListTagsForResourceOutputBuilder {
    if builder.tags.is_none() {
        builder.tags = Some(Default::default())
    }
    builder
}

pub(crate) fn list_virtual_gateways_output_output_correct_errors(
    mut builder: crate::operation::list_virtual_gateways::builders::ListVirtualGatewaysOutputBuilder,
) -> crate::operation::list_virtual_gateways::builders::ListVirtualGatewaysOutputBuilder {
    if builder.virtual_gateways.is_none() {
        builder.virtual_gateways = Some(Default::default())
    }
    builder
}

pub(crate) fn list_virtual_nodes_output_output_correct_errors(
    mut builder: crate::operation::list_virtual_nodes::builders::ListVirtualNodesOutputBuilder,
) -> crate::operation::list_virtual_nodes::builders::ListVirtualNodesOutputBuilder {
    if builder.virtual_nodes.is_none() {
        builder.virtual_nodes = Some(Default::default())
    }
    builder
}

pub(crate) fn list_virtual_routers_output_output_correct_errors(
    mut builder: crate::operation::list_virtual_routers::builders::ListVirtualRoutersOutputBuilder,
) -> crate::operation::list_virtual_routers::builders::ListVirtualRoutersOutputBuilder {
    if builder.virtual_routers.is_none() {
        builder.virtual_routers = Some(Default::default())
    }
    builder
}

pub(crate) fn list_virtual_services_output_output_correct_errors(
    mut builder: crate::operation::list_virtual_services::builders::ListVirtualServicesOutputBuilder,
) -> crate::operation::list_virtual_services::builders::ListVirtualServicesOutputBuilder {
    if builder.virtual_services.is_none() {
        builder.virtual_services = Some(Default::default())
    }
    builder
}

pub(crate) fn update_gateway_route_output_output_correct_errors(
    mut builder: crate::operation::update_gateway_route::builders::UpdateGatewayRouteOutputBuilder,
) -> crate::operation::update_gateway_route::builders::UpdateGatewayRouteOutputBuilder {
    if builder.gateway_route.is_none() {
        builder.gateway_route = {
            let builder = crate::types::builders::GatewayRouteDataBuilder::default();
            crate::serde_util::gateway_route_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn update_mesh_output_output_correct_errors(
    mut builder: crate::operation::update_mesh::builders::UpdateMeshOutputBuilder,
) -> crate::operation::update_mesh::builders::UpdateMeshOutputBuilder {
    if builder.mesh.is_none() {
        builder.mesh = {
            let builder = crate::types::builders::MeshDataBuilder::default();
            crate::serde_util::mesh_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn update_route_output_output_correct_errors(
    mut builder: crate::operation::update_route::builders::UpdateRouteOutputBuilder,
) -> crate::operation::update_route::builders::UpdateRouteOutputBuilder {
    if builder.route.is_none() {
        builder.route = {
            let builder = crate::types::builders::RouteDataBuilder::default();
            crate::serde_util::route_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn update_virtual_gateway_output_output_correct_errors(
    mut builder: crate::operation::update_virtual_gateway::builders::UpdateVirtualGatewayOutputBuilder,
) -> crate::operation::update_virtual_gateway::builders::UpdateVirtualGatewayOutputBuilder {
    if builder.virtual_gateway.is_none() {
        builder.virtual_gateway = {
            let builder = crate::types::builders::VirtualGatewayDataBuilder::default();
            crate::serde_util::virtual_gateway_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn update_virtual_node_output_output_correct_errors(
    mut builder: crate::operation::update_virtual_node::builders::UpdateVirtualNodeOutputBuilder,
) -> crate::operation::update_virtual_node::builders::UpdateVirtualNodeOutputBuilder {
    if builder.virtual_node.is_none() {
        builder.virtual_node = {
            let builder = crate::types::builders::VirtualNodeDataBuilder::default();
            crate::serde_util::virtual_node_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn update_virtual_router_output_output_correct_errors(
    mut builder: crate::operation::update_virtual_router::builders::UpdateVirtualRouterOutputBuilder,
) -> crate::operation::update_virtual_router::builders::UpdateVirtualRouterOutputBuilder {
    if builder.virtual_router.is_none() {
        builder.virtual_router = {
            let builder = crate::types::builders::VirtualRouterDataBuilder::default();
            crate::serde_util::virtual_router_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn update_virtual_service_output_output_correct_errors(
    mut builder: crate::operation::update_virtual_service::builders::UpdateVirtualServiceOutputBuilder,
) -> crate::operation::update_virtual_service::builders::UpdateVirtualServiceOutputBuilder {
    if builder.virtual_service.is_none() {
        builder.virtual_service = {
            let builder = crate::types::builders::VirtualServiceDataBuilder::default();
            crate::serde_util::virtual_service_data_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn gateway_route_data_correct_errors(
    mut builder: crate::types::builders::GatewayRouteDataBuilder,
) -> crate::types::builders::GatewayRouteDataBuilder {
    if builder.mesh_name.is_none() {
        builder.mesh_name = Some(Default::default())
    }
    if builder.gateway_route_name.is_none() {
        builder.gateway_route_name = Some(Default::default())
    }
    if builder.virtual_gateway_name.is_none() {
        builder.virtual_gateway_name = Some(Default::default())
    }
    if builder.spec.is_none() {
        builder.spec = {
            let builder = crate::types::builders::GatewayRouteSpecBuilder::default();
            Some(builder.build())
        }
    }
    if builder.metadata.is_none() {
        builder.metadata = {
            let builder = crate::types::builders::ResourceMetadataBuilder::default();
            crate::serde_util::resource_metadata_correct_errors(builder).build().ok()
        }
    }
    if builder.status.is_none() {
        builder.status = {
            let builder = crate::types::builders::GatewayRouteStatusBuilder::default();
            crate::serde_util::gateway_route_status_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn mesh_data_correct_errors(mut builder: crate::types::builders::MeshDataBuilder) -> crate::types::builders::MeshDataBuilder {
    if builder.mesh_name.is_none() {
        builder.mesh_name = Some(Default::default())
    }
    if builder.spec.is_none() {
        builder.spec = {
            let builder = crate::types::builders::MeshSpecBuilder::default();
            Some(builder.build())
        }
    }
    if builder.metadata.is_none() {
        builder.metadata = {
            let builder = crate::types::builders::ResourceMetadataBuilder::default();
            crate::serde_util::resource_metadata_correct_errors(builder).build().ok()
        }
    }
    if builder.status.is_none() {
        builder.status = {
            let builder = crate::types::builders::MeshStatusBuilder::default();
            Some(builder.build())
        }
    }
    builder
}

pub(crate) fn route_data_correct_errors(mut builder: crate::types::builders::RouteDataBuilder) -> crate::types::builders::RouteDataBuilder {
    if builder.mesh_name.is_none() {
        builder.mesh_name = Some(Default::default())
    }
    if builder.virtual_router_name.is_none() {
        builder.virtual_router_name = Some(Default::default())
    }
    if builder.route_name.is_none() {
        builder.route_name = Some(Default::default())
    }
    if builder.spec.is_none() {
        builder.spec = {
            let builder = crate::types::builders::RouteSpecBuilder::default();
            Some(builder.build())
        }
    }
    if builder.metadata.is_none() {
        builder.metadata = {
            let builder = crate::types::builders::ResourceMetadataBuilder::default();
            crate::serde_util::resource_metadata_correct_errors(builder).build().ok()
        }
    }
    if builder.status.is_none() {
        builder.status = {
            let builder = crate::types::builders::RouteStatusBuilder::default();
            crate::serde_util::route_status_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn virtual_gateway_data_correct_errors(
    mut builder: crate::types::builders::VirtualGatewayDataBuilder,
) -> crate::types::builders::VirtualGatewayDataBuilder {
    if builder.mesh_name.is_none() {
        builder.mesh_name = Some(Default::default())
    }
    if builder.virtual_gateway_name.is_none() {
        builder.virtual_gateway_name = Some(Default::default())
    }
    if builder.spec.is_none() {
        builder.spec = {
            let builder = crate::types::builders::VirtualGatewaySpecBuilder::default();
            crate::serde_util::virtual_gateway_spec_correct_errors(builder).build().ok()
        }
    }
    if builder.metadata.is_none() {
        builder.metadata = {
            let builder = crate::types::builders::ResourceMetadataBuilder::default();
            crate::serde_util::resource_metadata_correct_errors(builder).build().ok()
        }
    }
    if builder.status.is_none() {
        builder.status = {
            let builder = crate::types::builders::VirtualGatewayStatusBuilder::default();
            crate::serde_util::virtual_gateway_status_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn virtual_node_data_correct_errors(
    mut builder: crate::types::builders::VirtualNodeDataBuilder,
) -> crate::types::builders::VirtualNodeDataBuilder {
    if builder.mesh_name.is_none() {
        builder.mesh_name = Some(Default::default())
    }
    if builder.virtual_node_name.is_none() {
        builder.virtual_node_name = Some(Default::default())
    }
    if builder.spec.is_none() {
        builder.spec = {
            let builder = crate::types::builders::VirtualNodeSpecBuilder::default();
            Some(builder.build())
        }
    }
    if builder.metadata.is_none() {
        builder.metadata = {
            let builder = crate::types::builders::ResourceMetadataBuilder::default();
            crate::serde_util::resource_metadata_correct_errors(builder).build().ok()
        }
    }
    if builder.status.is_none() {
        builder.status = {
            let builder = crate::types::builders::VirtualNodeStatusBuilder::default();
            crate::serde_util::virtual_node_status_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn virtual_router_data_correct_errors(
    mut builder: crate::types::builders::VirtualRouterDataBuilder,
) -> crate::types::builders::VirtualRouterDataBuilder {
    if builder.mesh_name.is_none() {
        builder.mesh_name = Some(Default::default())
    }
    if builder.virtual_router_name.is_none() {
        builder.virtual_router_name = Some(Default::default())
    }
    if builder.spec.is_none() {
        builder.spec = {
            let builder = crate::types::builders::VirtualRouterSpecBuilder::default();
            Some(builder.build())
        }
    }
    if builder.metadata.is_none() {
        builder.metadata = {
            let builder = crate::types::builders::ResourceMetadataBuilder::default();
            crate::serde_util::resource_metadata_correct_errors(builder).build().ok()
        }
    }
    if builder.status.is_none() {
        builder.status = {
            let builder = crate::types::builders::VirtualRouterStatusBuilder::default();
            crate::serde_util::virtual_router_status_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn virtual_service_data_correct_errors(
    mut builder: crate::types::builders::VirtualServiceDataBuilder,
) -> crate::types::builders::VirtualServiceDataBuilder {
    if builder.mesh_name.is_none() {
        builder.mesh_name = Some(Default::default())
    }
    if builder.virtual_service_name.is_none() {
        builder.virtual_service_name = Some(Default::default())
    }
    if builder.spec.is_none() {
        builder.spec = {
            let builder = crate::types::builders::VirtualServiceSpecBuilder::default();
            Some(builder.build())
        }
    }
    if builder.metadata.is_none() {
        builder.metadata = {
            let builder = crate::types::builders::ResourceMetadataBuilder::default();
            crate::serde_util::resource_metadata_correct_errors(builder).build().ok()
        }
    }
    if builder.status.is_none() {
        builder.status = {
            let builder = crate::types::builders::VirtualServiceStatusBuilder::default();
            crate::serde_util::virtual_service_status_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn resource_metadata_correct_errors(
    mut builder: crate::types::builders::ResourceMetadataBuilder,
) -> crate::types::builders::ResourceMetadataBuilder {
    if builder.arn.is_none() {
        builder.arn = Some(Default::default())
    }
    if builder.version.is_none() {
        builder.version = Some(Default::default())
    }
    if builder.uid.is_none() {
        builder.uid = Some(Default::default())
    }
    if builder.created_at.is_none() {
        builder.created_at = Some(::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64))
    }
    if builder.last_updated_at.is_none() {
        builder.last_updated_at = Some(::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64))
    }
    if builder.mesh_owner.is_none() {
        builder.mesh_owner = Some(Default::default())
    }
    if builder.resource_owner.is_none() {
        builder.resource_owner = Some(Default::default())
    }
    builder
}

pub(crate) fn gateway_route_status_correct_errors(
    mut builder: crate::types::builders::GatewayRouteStatusBuilder,
) -> crate::types::builders::GatewayRouteStatusBuilder {
    if builder.status.is_none() {
        builder.status = "no value was set".parse::<crate::types::GatewayRouteStatusCode>().ok()
    }
    builder
}

pub(crate) fn route_status_correct_errors(mut builder: crate::types::builders::RouteStatusBuilder) -> crate::types::builders::RouteStatusBuilder {
    if builder.status.is_none() {
        builder.status = "no value was set".parse::<crate::types::RouteStatusCode>().ok()
    }
    builder
}

pub(crate) fn virtual_gateway_spec_correct_errors(
    mut builder: crate::types::builders::VirtualGatewaySpecBuilder,
) -> crate::types::builders::VirtualGatewaySpecBuilder {
    if builder.listeners.is_none() {
        builder.listeners = Some(Default::default())
    }
    builder
}

pub(crate) fn virtual_gateway_status_correct_errors(
    mut builder: crate::types::builders::VirtualGatewayStatusBuilder,
) -> crate::types::builders::VirtualGatewayStatusBuilder {
    if builder.status.is_none() {
        builder.status = "no value was set".parse::<crate::types::VirtualGatewayStatusCode>().ok()
    }
    builder
}

pub(crate) fn virtual_node_status_correct_errors(
    mut builder: crate::types::builders::VirtualNodeStatusBuilder,
) -> crate::types::builders::VirtualNodeStatusBuilder {
    if builder.status.is_none() {
        builder.status = "no value was set".parse::<crate::types::VirtualNodeStatusCode>().ok()
    }
    builder
}

pub(crate) fn virtual_router_status_correct_errors(
    mut builder: crate::types::builders::VirtualRouterStatusBuilder,
) -> crate::types::builders::VirtualRouterStatusBuilder {
    if builder.status.is_none() {
        builder.status = "no value was set".parse::<crate::types::VirtualRouterStatusCode>().ok()
    }
    builder
}

pub(crate) fn virtual_service_status_correct_errors(
    mut builder: crate::types::builders::VirtualServiceStatusBuilder,
) -> crate::types::builders::VirtualServiceStatusBuilder {
    if builder.status.is_none() {
        builder.status = "no value was set".parse::<crate::types::VirtualServiceStatusCode>().ok()
    }
    builder
}

pub(crate) fn gateway_route_ref_correct_errors(
    mut builder: crate::types::builders::GatewayRouteRefBuilder,
) -> crate::types::builders::GatewayRouteRefBuilder {
    if builder.mesh_name.is_none() {
        builder.mesh_name = Some(Default::default())
    }
    if builder.gateway_route_name.is_none() {
        builder.gateway_route_name = Some(Default::default())
    }
    if builder.virtual_gateway_name.is_none() {
        builder.virtual_gateway_name = Some(Default::default())
    }
    if builder.mesh_owner.is_none() {
        builder.mesh_owner = Some(Default::default())
    }
    if builder.resource_owner.is_none() {
        builder.resource_owner = Some(Default::default())
    }
    if builder.arn.is_none() {
        builder.arn = Some(Default::default())
    }
    if builder.version.is_none() {
        builder.version = Some(Default::default())
    }
    if builder.created_at.is_none() {
        builder.created_at = Some(::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64))
    }
    if builder.last_updated_at.is_none() {
        builder.last_updated_at = Some(::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64))
    }
    builder
}

pub(crate) fn mesh_ref_correct_errors(mut builder: crate::types::builders::MeshRefBuilder) -> crate::types::builders::MeshRefBuilder {
    if builder.mesh_name.is_none() {
        builder.mesh_name = Some(Default::default())
    }
    if builder.mesh_owner.is_none() {
        builder.mesh_owner = Some(Default::default())
    }
    if builder.resource_owner.is_none() {
        builder.resource_owner = Some(Default::default())
    }
    if builder.arn.is_none() {
        builder.arn = Some(Default::default())
    }
    if builder.version.is_none() {
        builder.version = Some(Default::default())
    }
    if builder.created_at.is_none() {
        builder.created_at = Some(::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64))
    }
    if builder.last_updated_at.is_none() {
        builder.last_updated_at = Some(::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64))
    }
    builder
}

pub(crate) fn route_ref_correct_errors(mut builder: crate::types::builders::RouteRefBuilder) -> crate::types::builders::RouteRefBuilder {
    if builder.mesh_name.is_none() {
        builder.mesh_name = Some(Default::default())
    }
    if builder.virtual_router_name.is_none() {
        builder.virtual_router_name = Some(Default::default())
    }
    if builder.route_name.is_none() {
        builder.route_name = Some(Default::default())
    }
    if builder.mesh_owner.is_none() {
        builder.mesh_owner = Some(Default::default())
    }
    if builder.resource_owner.is_none() {
        builder.resource_owner = Some(Default::default())
    }
    if builder.arn.is_none() {
        builder.arn = Some(Default::default())
    }
    if builder.version.is_none() {
        builder.version = Some(Default::default())
    }
    if builder.created_at.is_none() {
        builder.created_at = Some(::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64))
    }
    if builder.last_updated_at.is_none() {
        builder.last_updated_at = Some(::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64))
    }
    builder
}

pub(crate) fn tag_ref_correct_errors(mut builder: crate::types::builders::TagRefBuilder) -> crate::types::builders::TagRefBuilder {
    if builder.key.is_none() {
        builder.key = Some(Default::default())
    }
    if builder.value.is_none() {
        builder.value = Some(Default::default())
    }
    builder
}

pub(crate) fn virtual_gateway_ref_correct_errors(
    mut builder: crate::types::builders::VirtualGatewayRefBuilder,
) -> crate::types::builders::VirtualGatewayRefBuilder {
    if builder.mesh_name.is_none() {
        builder.mesh_name = Some(Default::default())
    }
    if builder.virtual_gateway_name.is_none() {
        builder.virtual_gateway_name = Some(Default::default())
    }
    if builder.mesh_owner.is_none() {
        builder.mesh_owner = Some(Default::default())
    }
    if builder.resource_owner.is_none() {
        builder.resource_owner = Some(Default::default())
    }
    if builder.arn.is_none() {
        builder.arn = Some(Default::default())
    }
    if builder.version.is_none() {
        builder.version = Some(Default::default())
    }
    if builder.created_at.is_none() {
        builder.created_at = Some(::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64))
    }
    if builder.last_updated_at.is_none() {
        builder.last_updated_at = Some(::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64))
    }
    builder
}

pub(crate) fn virtual_node_ref_correct_errors(
    mut builder: crate::types::builders::VirtualNodeRefBuilder,
) -> crate::types::builders::VirtualNodeRefBuilder {
    if builder.mesh_name.is_none() {
        builder.mesh_name = Some(Default::default())
    }
    if builder.virtual_node_name.is_none() {
        builder.virtual_node_name = Some(Default::default())
    }
    if builder.mesh_owner.is_none() {
        builder.mesh_owner = Some(Default::default())
    }
    if builder.resource_owner.is_none() {
        builder.resource_owner = Some(Default::default())
    }
    if builder.arn.is_none() {
        builder.arn = Some(Default::default())
    }
    if builder.version.is_none() {
        builder.version = Some(Default::default())
    }
    if builder.created_at.is_none() {
        builder.created_at = Some(::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64))
    }
    if builder.last_updated_at.is_none() {
        builder.last_updated_at = Some(::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64))
    }
    builder
}

pub(crate) fn virtual_router_ref_correct_errors(
    mut builder: crate::types::builders::VirtualRouterRefBuilder,
) -> crate::types::builders::VirtualRouterRefBuilder {
    if builder.mesh_name.is_none() {
        builder.mesh_name = Some(Default::default())
    }
    if builder.virtual_router_name.is_none() {
        builder.virtual_router_name = Some(Default::default())
    }
    if builder.mesh_owner.is_none() {
        builder.mesh_owner = Some(Default::default())
    }
    if builder.resource_owner.is_none() {
        builder.resource_owner = Some(Default::default())
    }
    if builder.arn.is_none() {
        builder.arn = Some(Default::default())
    }
    if builder.version.is_none() {
        builder.version = Some(Default::default())
    }
    if builder.created_at.is_none() {
        builder.created_at = Some(::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64))
    }
    if builder.last_updated_at.is_none() {
        builder.last_updated_at = Some(::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64))
    }
    builder
}

pub(crate) fn virtual_service_ref_correct_errors(
    mut builder: crate::types::builders::VirtualServiceRefBuilder,
) -> crate::types::builders::VirtualServiceRefBuilder {
    if builder.mesh_name.is_none() {
        builder.mesh_name = Some(Default::default())
    }
    if builder.virtual_service_name.is_none() {
        builder.virtual_service_name = Some(Default::default())
    }
    if builder.mesh_owner.is_none() {
        builder.mesh_owner = Some(Default::default())
    }
    if builder.resource_owner.is_none() {
        builder.resource_owner = Some(Default::default())
    }
    if builder.arn.is_none() {
        builder.arn = Some(Default::default())
    }
    if builder.version.is_none() {
        builder.version = Some(Default::default())
    }
    if builder.created_at.is_none() {
        builder.created_at = Some(::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64))
    }
    if builder.last_updated_at.is_none() {
        builder.last_updated_at = Some(::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64))
    }
    builder
}

pub(crate) fn egress_filter_correct_errors(mut builder: crate::types::builders::EgressFilterBuilder) -> crate::types::builders::EgressFilterBuilder {
    if builder.r#type.is_none() {
        builder.r#type = "no value was set".parse::<crate::types::EgressFilterType>().ok()
    }
    builder
}

pub(crate) fn grpc_gateway_route_correct_errors(
    mut builder: crate::types::builders::GrpcGatewayRouteBuilder,
) -> crate::types::builders::GrpcGatewayRouteBuilder {
    if builder.r#match.is_none() {
        builder.r#match = {
            let builder = crate::types::builders::GrpcGatewayRouteMatchBuilder::default();
            Some(builder.build())
        }
    }
    if builder.action.is_none() {
        builder.action = {
            let builder = crate::types::builders::GrpcGatewayRouteActionBuilder::default();
            Some(crate::serde_util::grpc_gateway_route_action_correct_errors(builder).build())
        }
    }
    builder
}

pub(crate) fn grpc_route_correct_errors(mut builder: crate::types::builders::GrpcRouteBuilder) -> crate::types::builders::GrpcRouteBuilder {
    if builder.action.is_none() {
        builder.action = {
            let builder = crate::types::builders::GrpcRouteActionBuilder::default();
            crate::serde_util::grpc_route_action_correct_errors(builder).build().ok()
        }
    }
    if builder.r#match.is_none() {
        builder.r#match = {
            let builder = crate::types::builders::GrpcRouteMatchBuilder::default();
            Some(builder.build())
        }
    }
    builder
}

pub(crate) fn http_gateway_route_correct_errors(
    mut builder: crate::types::builders::HttpGatewayRouteBuilder,
) -> crate::types::builders::HttpGatewayRouteBuilder {
    if builder.r#match.is_none() {
        builder.r#match = {
            let builder = crate::types::builders::HttpGatewayRouteMatchBuilder::default();
            Some(builder.build())
        }
    }
    if builder.action.is_none() {
        builder.action = {
            let builder = crate::types::builders::HttpGatewayRouteActionBuilder::default();
            Some(crate::serde_util::http_gateway_route_action_correct_errors(builder).build())
        }
    }
    builder
}

pub(crate) fn http_route_correct_errors(mut builder: crate::types::builders::HttpRouteBuilder) -> crate::types::builders::HttpRouteBuilder {
    if builder.r#match.is_none() {
        builder.r#match = {
            let builder = crate::types::builders::HttpRouteMatchBuilder::default();
            Some(builder.build())
        }
    }
    if builder.action.is_none() {
        builder.action = {
            let builder = crate::types::builders::HttpRouteActionBuilder::default();
            crate::serde_util::http_route_action_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn tcp_route_correct_errors(mut builder: crate::types::builders::TcpRouteBuilder) -> crate::types::builders::TcpRouteBuilder {
    if builder.action.is_none() {
        builder.action = {
            let builder = crate::types::builders::TcpRouteActionBuilder::default();
            crate::serde_util::tcp_route_action_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn aws_cloud_map_service_discovery_correct_errors(
    mut builder: crate::types::builders::AwsCloudMapServiceDiscoveryBuilder,
) -> crate::types::builders::AwsCloudMapServiceDiscoveryBuilder {
    if builder.namespace_name.is_none() {
        builder.namespace_name = Some(Default::default())
    }
    if builder.service_name.is_none() {
        builder.service_name = Some(Default::default())
    }
    builder
}

pub(crate) fn dns_service_discovery_correct_errors(
    mut builder: crate::types::builders::DnsServiceDiscoveryBuilder,
) -> crate::types::builders::DnsServiceDiscoveryBuilder {
    if builder.hostname.is_none() {
        builder.hostname = Some(Default::default())
    }
    builder
}

pub(crate) fn grpc_gateway_route_action_correct_errors(
    mut builder: crate::types::builders::GrpcGatewayRouteActionBuilder,
) -> crate::types::builders::GrpcGatewayRouteActionBuilder {
    if builder.target.is_none() {
        builder.target = {
            let builder = crate::types::builders::GatewayRouteTargetBuilder::default();
            Some(crate::serde_util::gateway_route_target_correct_errors(builder).build())
        }
    }
    builder
}

pub(crate) fn grpc_retry_policy_correct_errors(
    mut builder: crate::types::builders::GrpcRetryPolicyBuilder,
) -> crate::types::builders::GrpcRetryPolicyBuilder {
    if builder.per_retry_timeout.is_none() {
        builder.per_retry_timeout = {
            let builder = crate::types::builders::DurationBuilder::default();
            Some(builder.build())
        }
    }
    if builder.max_retries.is_none() {
        builder.max_retries = Some(Default::default())
    }
    builder
}

pub(crate) fn grpc_route_action_correct_errors(
    mut builder: crate::types::builders::GrpcRouteActionBuilder,
) -> crate::types::builders::GrpcRouteActionBuilder {
    if builder.weighted_targets.is_none() {
        builder.weighted_targets = Some(Default::default())
    }
    builder
}

pub(crate) fn http_gateway_route_action_correct_errors(
    mut builder: crate::types::builders::HttpGatewayRouteActionBuilder,
) -> crate::types::builders::HttpGatewayRouteActionBuilder {
    if builder.target.is_none() {
        builder.target = {
            let builder = crate::types::builders::GatewayRouteTargetBuilder::default();
            Some(crate::serde_util::gateway_route_target_correct_errors(builder).build())
        }
    }
    builder
}

pub(crate) fn http_retry_policy_correct_errors(
    mut builder: crate::types::builders::HttpRetryPolicyBuilder,
) -> crate::types::builders::HttpRetryPolicyBuilder {
    if builder.per_retry_timeout.is_none() {
        builder.per_retry_timeout = {
            let builder = crate::types::builders::DurationBuilder::default();
            Some(builder.build())
        }
    }
    if builder.max_retries.is_none() {
        builder.max_retries = Some(Default::default())
    }
    builder
}

pub(crate) fn http_route_action_correct_errors(
    mut builder: crate::types::builders::HttpRouteActionBuilder,
) -> crate::types::builders::HttpRouteActionBuilder {
    if builder.weighted_targets.is_none() {
        builder.weighted_targets = Some(Default::default())
    }
    builder
}

pub(crate) fn listener_correct_errors(mut builder: crate::types::builders::ListenerBuilder) -> crate::types::builders::ListenerBuilder {
    if builder.port_mapping.is_none() {
        builder.port_mapping = {
            let builder = crate::types::builders::PortMappingBuilder::default();
            crate::serde_util::port_mapping_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn tcp_route_action_correct_errors(
    mut builder: crate::types::builders::TcpRouteActionBuilder,
) -> crate::types::builders::TcpRouteActionBuilder {
    if builder.weighted_targets.is_none() {
        builder.weighted_targets = Some(Default::default())
    }
    builder
}

pub(crate) fn virtual_gateway_listener_correct_errors(
    mut builder: crate::types::builders::VirtualGatewayListenerBuilder,
) -> crate::types::builders::VirtualGatewayListenerBuilder {
    if builder.port_mapping.is_none() {
        builder.port_mapping = {
            let builder = crate::types::builders::VirtualGatewayPortMappingBuilder::default();
            crate::serde_util::virtual_gateway_port_mapping_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn virtual_node_service_provider_correct_errors(
    mut builder: crate::types::builders::VirtualNodeServiceProviderBuilder,
) -> crate::types::builders::VirtualNodeServiceProviderBuilder {
    if builder.virtual_node_name.is_none() {
        builder.virtual_node_name = Some(Default::default())
    }
    builder
}

pub(crate) fn virtual_router_listener_correct_errors(
    mut builder: crate::types::builders::VirtualRouterListenerBuilder,
) -> crate::types::builders::VirtualRouterListenerBuilder {
    if builder.port_mapping.is_none() {
        builder.port_mapping = {
            let builder = crate::types::builders::PortMappingBuilder::default();
            crate::serde_util::port_mapping_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn virtual_router_service_provider_correct_errors(
    mut builder: crate::types::builders::VirtualRouterServiceProviderBuilder,
) -> crate::types::builders::VirtualRouterServiceProviderBuilder {
    if builder.virtual_router_name.is_none() {
        builder.virtual_router_name = Some(Default::default())
    }
    builder
}

pub(crate) fn client_policy_tls_correct_errors(
    mut builder: crate::types::builders::ClientPolicyTlsBuilder,
) -> crate::types::builders::ClientPolicyTlsBuilder {
    if builder.validation.is_none() {
        builder.validation = {
            let builder = crate::types::builders::TlsValidationContextBuilder::default();
            Some(crate::serde_util::tls_validation_context_correct_errors(builder).build())
        }
    }
    builder
}

pub(crate) fn file_access_log_correct_errors(
    mut builder: crate::types::builders::FileAccessLogBuilder,
) -> crate::types::builders::FileAccessLogBuilder {
    if builder.path.is_none() {
        builder.path = Some(Default::default())
    }
    builder
}

pub(crate) fn gateway_route_target_correct_errors(
    mut builder: crate::types::builders::GatewayRouteTargetBuilder,
) -> crate::types::builders::GatewayRouteTargetBuilder {
    if builder.virtual_service.is_none() {
        builder.virtual_service = {
            let builder = crate::types::builders::GatewayRouteVirtualServiceBuilder::default();
            crate::serde_util::gateway_route_virtual_service_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn health_check_policy_correct_errors(
    mut builder: crate::types::builders::HealthCheckPolicyBuilder,
) -> crate::types::builders::HealthCheckPolicyBuilder {
    if builder.timeout_millis.is_none() {
        builder.timeout_millis = Some(Default::default())
    }
    if builder.interval_millis.is_none() {
        builder.interval_millis = Some(Default::default())
    }
    if builder.protocol.is_none() {
        builder.protocol = "no value was set".parse::<crate::types::PortProtocol>().ok()
    }
    if builder.healthy_threshold.is_none() {
        builder.healthy_threshold = Some(Default::default())
    }
    if builder.unhealthy_threshold.is_none() {
        builder.unhealthy_threshold = Some(Default::default())
    }
    builder
}

pub(crate) fn listener_tls_correct_errors(mut builder: crate::types::builders::ListenerTlsBuilder) -> crate::types::builders::ListenerTlsBuilder {
    if builder.mode.is_none() {
        builder.mode = "no value was set".parse::<crate::types::ListenerTlsMode>().ok()
    }
    if builder.certificate.is_none() {
        builder.certificate = Some(crate::types::ListenerTlsCertificate::Unknown)
    }
    builder
}

pub(crate) fn outlier_detection_correct_errors(
    mut builder: crate::types::builders::OutlierDetectionBuilder,
) -> crate::types::builders::OutlierDetectionBuilder {
    if builder.max_server_errors.is_none() {
        builder.max_server_errors = Some(Default::default())
    }
    if builder.interval.is_none() {
        builder.interval = {
            let builder = crate::types::builders::DurationBuilder::default();
            Some(builder.build())
        }
    }
    if builder.base_ejection_duration.is_none() {
        builder.base_ejection_duration = {
            let builder = crate::types::builders::DurationBuilder::default();
            Some(builder.build())
        }
    }
    if builder.max_ejection_percent.is_none() {
        builder.max_ejection_percent = Some(Default::default())
    }
    builder
}

pub(crate) fn port_mapping_correct_errors(mut builder: crate::types::builders::PortMappingBuilder) -> crate::types::builders::PortMappingBuilder {
    if builder.port.is_none() {
        builder.port = Some(Default::default())
    }
    if builder.protocol.is_none() {
        builder.protocol = "no value was set".parse::<crate::types::PortProtocol>().ok()
    }
    builder
}

pub(crate) fn virtual_gateway_client_policy_tls_correct_errors(
    mut builder: crate::types::builders::VirtualGatewayClientPolicyTlsBuilder,
) -> crate::types::builders::VirtualGatewayClientPolicyTlsBuilder {
    if builder.validation.is_none() {
        builder.validation = {
            let builder = crate::types::builders::VirtualGatewayTlsValidationContextBuilder::default();
            Some(crate::serde_util::virtual_gateway_tls_validation_context_correct_errors(builder).build())
        }
    }
    builder
}

pub(crate) fn virtual_gateway_file_access_log_correct_errors(
    mut builder: crate::types::builders::VirtualGatewayFileAccessLogBuilder,
) -> crate::types::builders::VirtualGatewayFileAccessLogBuilder {
    if builder.path.is_none() {
        builder.path = Some(Default::default())
    }
    builder
}

pub(crate) fn virtual_gateway_health_check_policy_correct_errors(
    mut builder: crate::types::builders::VirtualGatewayHealthCheckPolicyBuilder,
) -> crate::types::builders::VirtualGatewayHealthCheckPolicyBuilder {
    if builder.timeout_millis.is_none() {
        builder.timeout_millis = Some(Default::default())
    }
    if builder.interval_millis.is_none() {
        builder.interval_millis = Some(Default::default())
    }
    if builder.protocol.is_none() {
        builder.protocol = "no value was set".parse::<crate::types::VirtualGatewayPortProtocol>().ok()
    }
    if builder.healthy_threshold.is_none() {
        builder.healthy_threshold = Some(Default::default())
    }
    if builder.unhealthy_threshold.is_none() {
        builder.unhealthy_threshold = Some(Default::default())
    }
    builder
}

pub(crate) fn virtual_gateway_listener_tls_correct_errors(
    mut builder: crate::types::builders::VirtualGatewayListenerTlsBuilder,
) -> crate::types::builders::VirtualGatewayListenerTlsBuilder {
    if builder.mode.is_none() {
        builder.mode = "no value was set".parse::<crate::types::VirtualGatewayListenerTlsMode>().ok()
    }
    if builder.certificate.is_none() {
        builder.certificate = Some(crate::types::VirtualGatewayListenerTlsCertificate::Unknown)
    }
    builder
}

pub(crate) fn virtual_gateway_port_mapping_correct_errors(
    mut builder: crate::types::builders::VirtualGatewayPortMappingBuilder,
) -> crate::types::builders::VirtualGatewayPortMappingBuilder {
    if builder.port.is_none() {
        builder.port = Some(Default::default())
    }
    if builder.protocol.is_none() {
        builder.protocol = "no value was set".parse::<crate::types::VirtualGatewayPortProtocol>().ok()
    }
    builder
}

pub(crate) fn virtual_service_backend_correct_errors(
    mut builder: crate::types::builders::VirtualServiceBackendBuilder,
) -> crate::types::builders::VirtualServiceBackendBuilder {
    if builder.virtual_service_name.is_none() {
        builder.virtual_service_name = Some(Default::default())
    }
    builder
}

pub(crate) fn aws_cloud_map_instance_attribute_correct_errors(
    mut builder: crate::types::builders::AwsCloudMapInstanceAttributeBuilder,
) -> crate::types::builders::AwsCloudMapInstanceAttributeBuilder {
    if builder.key.is_none() {
        builder.key = Some(Default::default())
    }
    if builder.value.is_none() {
        builder.value = Some(Default::default())
    }
    builder
}

pub(crate) fn gateway_route_virtual_service_correct_errors(
    mut builder: crate::types::builders::GatewayRouteVirtualServiceBuilder,
) -> crate::types::builders::GatewayRouteVirtualServiceBuilder {
    if builder.virtual_service_name.is_none() {
        builder.virtual_service_name = Some(Default::default())
    }
    builder
}

pub(crate) fn grpc_gateway_route_metadata_correct_errors(
    mut builder: crate::types::builders::GrpcGatewayRouteMetadataBuilder,
) -> crate::types::builders::GrpcGatewayRouteMetadataBuilder {
    if builder.name.is_none() {
        builder.name = Some(Default::default())
    }
    builder
}

pub(crate) fn grpc_route_metadata_correct_errors(
    mut builder: crate::types::builders::GrpcRouteMetadataBuilder,
) -> crate::types::builders::GrpcRouteMetadataBuilder {
    if builder.name.is_none() {
        builder.name = Some(Default::default())
    }
    builder
}

pub(crate) fn http_gateway_route_header_correct_errors(
    mut builder: crate::types::builders::HttpGatewayRouteHeaderBuilder,
) -> crate::types::builders::HttpGatewayRouteHeaderBuilder {
    if builder.name.is_none() {
        builder.name = Some(Default::default())
    }
    builder
}

pub(crate) fn http_query_parameter_correct_errors(
    mut builder: crate::types::builders::HttpQueryParameterBuilder,
) -> crate::types::builders::HttpQueryParameterBuilder {
    if builder.name.is_none() {
        builder.name = Some(Default::default())
    }
    builder
}

pub(crate) fn http_route_header_correct_errors(
    mut builder: crate::types::builders::HttpRouteHeaderBuilder,
) -> crate::types::builders::HttpRouteHeaderBuilder {
    if builder.name.is_none() {
        builder.name = Some(Default::default())
    }
    builder
}

pub(crate) fn listener_tls_validation_context_correct_errors(
    mut builder: crate::types::builders::ListenerTlsValidationContextBuilder,
) -> crate::types::builders::ListenerTlsValidationContextBuilder {
    if builder.trust.is_none() {
        builder.trust = Some(crate::types::ListenerTlsValidationContextTrust::Unknown)
    }
    builder
}

pub(crate) fn tls_validation_context_correct_errors(
    mut builder: crate::types::builders::TlsValidationContextBuilder,
) -> crate::types::builders::TlsValidationContextBuilder {
    if builder.trust.is_none() {
        builder.trust = Some(crate::types::TlsValidationContextTrust::Unknown)
    }
    builder
}

pub(crate) fn virtual_gateway_grpc_connection_pool_correct_errors(
    mut builder: crate::types::builders::VirtualGatewayGrpcConnectionPoolBuilder,
) -> crate::types::builders::VirtualGatewayGrpcConnectionPoolBuilder {
    if builder.max_requests.is_none() {
        builder.max_requests = Some(Default::default())
    }
    builder
}

pub(crate) fn virtual_gateway_http2_connection_pool_correct_errors(
    mut builder: crate::types::builders::VirtualGatewayHttp2ConnectionPoolBuilder,
) -> crate::types::builders::VirtualGatewayHttp2ConnectionPoolBuilder {
    if builder.max_requests.is_none() {
        builder.max_requests = Some(Default::default())
    }
    builder
}

pub(crate) fn virtual_gateway_http_connection_pool_correct_errors(
    mut builder: crate::types::builders::VirtualGatewayHttpConnectionPoolBuilder,
) -> crate::types::builders::VirtualGatewayHttpConnectionPoolBuilder {
    if builder.max_connections.is_none() {
        builder.max_connections = Some(Default::default())
    }
    builder
}

pub(crate) fn virtual_gateway_listener_tls_validation_context_correct_errors(
    mut builder: crate::types::builders::VirtualGatewayListenerTlsValidationContextBuilder,
) -> crate::types::builders::VirtualGatewayListenerTlsValidationContextBuilder {
    if builder.trust.is_none() {
        builder.trust = Some(crate::types::VirtualGatewayListenerTlsValidationContextTrust::Unknown)
    }
    builder
}

pub(crate) fn virtual_gateway_tls_validation_context_correct_errors(
    mut builder: crate::types::builders::VirtualGatewayTlsValidationContextBuilder,
) -> crate::types::builders::VirtualGatewayTlsValidationContextBuilder {
    if builder.trust.is_none() {
        builder.trust = Some(crate::types::VirtualGatewayTlsValidationContextTrust::Unknown)
    }
    builder
}

pub(crate) fn virtual_node_grpc_connection_pool_correct_errors(
    mut builder: crate::types::builders::VirtualNodeGrpcConnectionPoolBuilder,
) -> crate::types::builders::VirtualNodeGrpcConnectionPoolBuilder {
    if builder.max_requests.is_none() {
        builder.max_requests = Some(Default::default())
    }
    builder
}

pub(crate) fn virtual_node_http2_connection_pool_correct_errors(
    mut builder: crate::types::builders::VirtualNodeHttp2ConnectionPoolBuilder,
) -> crate::types::builders::VirtualNodeHttp2ConnectionPoolBuilder {
    if builder.max_requests.is_none() {
        builder.max_requests = Some(Default::default())
    }
    builder
}

pub(crate) fn virtual_node_http_connection_pool_correct_errors(
    mut builder: crate::types::builders::VirtualNodeHttpConnectionPoolBuilder,
) -> crate::types::builders::VirtualNodeHttpConnectionPoolBuilder {
    if builder.max_connections.is_none() {
        builder.max_connections = Some(Default::default())
    }
    builder
}

pub(crate) fn virtual_node_tcp_connection_pool_correct_errors(
    mut builder: crate::types::builders::VirtualNodeTcpConnectionPoolBuilder,
) -> crate::types::builders::VirtualNodeTcpConnectionPoolBuilder {
    if builder.max_connections.is_none() {
        builder.max_connections = Some(Default::default())
    }
    builder
}

pub(crate) fn weighted_target_correct_errors(
    mut builder: crate::types::builders::WeightedTargetBuilder,
) -> crate::types::builders::WeightedTargetBuilder {
    if builder.virtual_node.is_none() {
        builder.virtual_node = Some(Default::default())
    }
    if builder.weight.is_none() {
        builder.weight = Some(Default::default())
    }
    builder
}

pub(crate) fn listener_tls_acm_certificate_correct_errors(
    mut builder: crate::types::builders::ListenerTlsAcmCertificateBuilder,
) -> crate::types::builders::ListenerTlsAcmCertificateBuilder {
    if builder.certificate_arn.is_none() {
        builder.certificate_arn = Some(Default::default())
    }
    builder
}

pub(crate) fn listener_tls_file_certificate_correct_errors(
    mut builder: crate::types::builders::ListenerTlsFileCertificateBuilder,
) -> crate::types::builders::ListenerTlsFileCertificateBuilder {
    if builder.certificate_chain.is_none() {
        builder.certificate_chain = Some(Default::default())
    }
    if builder.private_key.is_none() {
        builder.private_key = Some(Default::default())
    }
    builder
}

pub(crate) fn listener_tls_sds_certificate_correct_errors(
    mut builder: crate::types::builders::ListenerTlsSdsCertificateBuilder,
) -> crate::types::builders::ListenerTlsSdsCertificateBuilder {
    if builder.secret_name.is_none() {
        builder.secret_name = Some(Default::default())
    }
    builder
}

pub(crate) fn subject_alternative_names_correct_errors(
    mut builder: crate::types::builders::SubjectAlternativeNamesBuilder,
) -> crate::types::builders::SubjectAlternativeNamesBuilder {
    if builder.r#match.is_none() {
        builder.r#match = {
            let builder = crate::types::builders::SubjectAlternativeNameMatchersBuilder::default();
            crate::serde_util::subject_alternative_name_matchers_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn virtual_gateway_listener_tls_acm_certificate_correct_errors(
    mut builder: crate::types::builders::VirtualGatewayListenerTlsAcmCertificateBuilder,
) -> crate::types::builders::VirtualGatewayListenerTlsAcmCertificateBuilder {
    if builder.certificate_arn.is_none() {
        builder.certificate_arn = Some(Default::default())
    }
    builder
}

pub(crate) fn virtual_gateway_listener_tls_file_certificate_correct_errors(
    mut builder: crate::types::builders::VirtualGatewayListenerTlsFileCertificateBuilder,
) -> crate::types::builders::VirtualGatewayListenerTlsFileCertificateBuilder {
    if builder.certificate_chain.is_none() {
        builder.certificate_chain = Some(Default::default())
    }
    if builder.private_key.is_none() {
        builder.private_key = Some(Default::default())
    }
    builder
}

pub(crate) fn virtual_gateway_listener_tls_sds_certificate_correct_errors(
    mut builder: crate::types::builders::VirtualGatewayListenerTlsSdsCertificateBuilder,
) -> crate::types::builders::VirtualGatewayListenerTlsSdsCertificateBuilder {
    if builder.secret_name.is_none() {
        builder.secret_name = Some(Default::default())
    }
    builder
}

pub(crate) fn json_format_ref_correct_errors(
    mut builder: crate::types::builders::JsonFormatRefBuilder,
) -> crate::types::builders::JsonFormatRefBuilder {
    if builder.key.is_none() {
        builder.key = Some(Default::default())
    }
    if builder.value.is_none() {
        builder.value = Some(Default::default())
    }
    builder
}

pub(crate) fn match_range_correct_errors(mut builder: crate::types::builders::MatchRangeBuilder) -> crate::types::builders::MatchRangeBuilder {
    if builder.start.is_none() {
        builder.start = Some(Default::default())
    }
    if builder.end.is_none() {
        builder.end = Some(Default::default())
    }
    builder
}

pub(crate) fn subject_alternative_name_matchers_correct_errors(
    mut builder: crate::types::builders::SubjectAlternativeNameMatchersBuilder,
) -> crate::types::builders::SubjectAlternativeNameMatchersBuilder {
    if builder.exact.is_none() {
        builder.exact = Some(Default::default())
    }
    builder
}

pub(crate) fn tls_validation_context_acm_trust_correct_errors(
    mut builder: crate::types::builders::TlsValidationContextAcmTrustBuilder,
) -> crate::types::builders::TlsValidationContextAcmTrustBuilder {
    if builder.certificate_authority_arns.is_none() {
        builder.certificate_authority_arns = Some(Default::default())
    }
    builder
}

pub(crate) fn tls_validation_context_file_trust_correct_errors(
    mut builder: crate::types::builders::TlsValidationContextFileTrustBuilder,
) -> crate::types::builders::TlsValidationContextFileTrustBuilder {
    if builder.certificate_chain.is_none() {
        builder.certificate_chain = Some(Default::default())
    }
    builder
}

pub(crate) fn tls_validation_context_sds_trust_correct_errors(
    mut builder: crate::types::builders::TlsValidationContextSdsTrustBuilder,
) -> crate::types::builders::TlsValidationContextSdsTrustBuilder {
    if builder.secret_name.is_none() {
        builder.secret_name = Some(Default::default())
    }
    builder
}

pub(crate) fn virtual_gateway_tls_validation_context_acm_trust_correct_errors(
    mut builder: crate::types::builders::VirtualGatewayTlsValidationContextAcmTrustBuilder,
) -> crate::types::builders::VirtualGatewayTlsValidationContextAcmTrustBuilder {
    if builder.certificate_authority_arns.is_none() {
        builder.certificate_authority_arns = Some(Default::default())
    }
    builder
}

pub(crate) fn virtual_gateway_tls_validation_context_file_trust_correct_errors(
    mut builder: crate::types::builders::VirtualGatewayTlsValidationContextFileTrustBuilder,
) -> crate::types::builders::VirtualGatewayTlsValidationContextFileTrustBuilder {
    if builder.certificate_chain.is_none() {
        builder.certificate_chain = Some(Default::default())
    }
    builder
}

pub(crate) fn virtual_gateway_tls_validation_context_sds_trust_correct_errors(
    mut builder: crate::types::builders::VirtualGatewayTlsValidationContextSdsTrustBuilder,
) -> crate::types::builders::VirtualGatewayTlsValidationContextSdsTrustBuilder {
    if builder.secret_name.is_none() {
        builder.secret_name = Some(Default::default())
    }
    builder
}