AWS SDK

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_recording_group.rs

@@ -159,159 +358,366 @@

     /// <p><b>Required and optional fields</b></p>
     /// <p>The <code>recordingStrategy</code> field is optional when you set the <code>allSupported</code> field of <a href="https://docs.aws.amazon.com/config/latest/APIReference/API_RecordingGroup.html">RecordingGroup</a> to <code>true</code>.</p>
     /// <p>The <code>recordingStrategy</code> field is optional when you list resource types in the <code>resourceTypes</code> field of <a href="https://docs.aws.amazon.com/config/latest/APIReference/API_RecordingGroup.html">RecordingGroup</a>.</p>
     /// <p>The <code>recordingStrategy</code> field is required if you list resource types to exclude from recording in the <code>resourceTypes</code> field of <a href="https://docs.aws.amazon.com/config/latest/APIReference/API_ExclusionByResourceTypes.html">ExclusionByResourceTypes</a>.</p>
     /// </note> <note>
     /// <p><b>Overriding fields</b></p>
     /// <p>If you choose <code>EXCLUSION_BY_RESOURCE_TYPES</code> for the recording strategy, the <code>exclusionByResourceTypes</code> field will override other properties in the request.</p>
     /// <p>For example, even if you set <code>includeGlobalResourceTypes</code> to false, global IAM resource types will still be automatically recorded in this option unless those resource types are specifically listed as exclusions in the <code>resourceTypes</code> field of <code>exclusionByResourceTypes</code>.</p>
     /// </note> <note>
     /// <p><b>Global resources types and the resource exclusion recording strategy</b></p>
     /// <p>By default, if you choose the <code>EXCLUSION_BY_RESOURCE_TYPES</code> recording strategy, when Config adds support for a new resource type in the Region where you set up the configuration recorder, including global resource types, Config starts recording resources of that type automatically.</p>
     /// <p>Unless specifically listed as exclusions, <code>AWS::RDS::GlobalCluster</code> will be recorded automatically in all supported Config Regions were the configuration recorder is enabled.</p>
     /// <p>IAM users, groups, roles, and customer managed policies will be recorded in the Region where you set up the configuration recorder if that is a Region where Config was available before February 2022. You cannot be record the global IAM resouce types in Regions supported by Config after February 2022. For a list of those Regions, see <a href="https://docs.aws.amazon.com/config/latest/developerguide/select-resources.html#select-resources-all">Recording Amazon Web Services Resources | Global Resources</a>.</p>
     /// </note>
     pub fn recording_strategy(&self) -> ::std::option::Option<&crate::types::RecordingStrategy> {
         self.recording_strategy.as_ref()
-175
+    }
-176
+}
 static RECORDINGGROUP_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.configservice#RecordingGroup",

     "com.amazonaws.configservice",
     "RecordingGroup",
 );
 static RECORDINGGROUP_MEMBER_ALL_SUPPORTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RecordingGroup$allSupported",
         "com.amazonaws.configservice",
         "RecordingGroup",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "all_supported",
     "allSupported",
 ,
 );
 static RECORDINGGROUP_MEMBER_INCLUDE_GLOBAL_RESOURCE_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RecordingGroup$includeGlobalResourceTypes",
         "com.amazonaws.configservice",
         "RecordingGroup",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "include_global_resource_types",
     "includeGlobalResourceTypes",
 ,
 );
 static RECORDINGGROUP_MEMBER_RESOURCE_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RecordingGroup$resourceTypes",
         "com.amazonaws.configservice",
         "RecordingGroup",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "resource_types",
     "resourceTypes",
 ,
 );
 static RECORDINGGROUP_MEMBER_EXCLUSION_BY_RESOURCE_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RecordingGroup$exclusionByResourceTypes",
         "com.amazonaws.configservice",
         "RecordingGroup",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "exclusion_by_resource_types",
     "exclusionByResourceTypes",
 ,
 );
 static RECORDINGGROUP_MEMBER_RECORDING_STRATEGY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RecordingGroup$recordingStrategy",
         "com.amazonaws.configservice",
         "RecordingGroup",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "recording_strategy",
     "recordingStrategy",
 ,
 );
 static RECORDINGGROUP_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RECORDINGGROUP_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &RECORDINGGROUP_MEMBER_ALL_SUPPORTED,
         &RECORDINGGROUP_MEMBER_INCLUDE_GLOBAL_RESOURCE_TYPES,
         &RECORDINGGROUP_MEMBER_RESOURCE_TYPES,
         &RECORDINGGROUP_MEMBER_EXCLUSION_BY_RESOURCE_TYPES,
         &RECORDINGGROUP_MEMBER_RECORDING_STRATEGY,
     ],
 );
 impl RecordingGroup {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RECORDINGGROUP_SCHEMA;
-246
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RecordingGroup {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
-253
+        {
             let val = &self.all_supported;
             ser.write_boolean(&RECORDINGGROUP_MEMBER_ALL_SUPPORTED, *val)?;
-256
+        }
-257
+        {
             let val = &self.include_global_resource_types;
             ser.write_boolean(&RECORDINGGROUP_MEMBER_INCLUDE_GLOBAL_RESOURCE_TYPES, *val)?;
-260
+        }
         if let Some(ref val) = self.resource_types {
             ser.write_list(
                 &RECORDINGGROUP_MEMBER_RESOURCE_TYPES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
-267
+                    }
                     Ok(())
                 },
             )?;
-271
+        }
         if let Some(ref val) = self.exclusion_by_resource_types {
             ser.write_struct(&RECORDINGGROUP_MEMBER_EXCLUSION_BY_RESOURCE_TYPES, val)?;
-274
+        }
         if let Some(ref val) = self.recording_strategy {
             ser.write_struct(&RECORDINGGROUP_MEMBER_RECORDING_STRATEGY, val)?;
-277
+        }
         Ok(())
-279
+    }
-280
+}
 impl RecordingGroup {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&RECORDINGGROUP_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RECORDINGGROUP_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.all_supported = Some(deser.read_boolean(member)?);
-299
+                }
                 Some(1) => {
                     builder.include_global_resource_types = Some(deser.read_boolean(member)?);
-302
+                }
                 Some(2) => {
                     builder.resource_types = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::ResourceType::from(deser.read_string(member)?.as_str()));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ResourceType::from(deser.read_string(member)?.as_str()));
                             Ok(())
                         })?;
                         container
                     });
-312
+                }
                 Some(3) => {
                     builder.exclusion_by_resource_types = Some(crate::types::ExclusionByResourceTypes::deserialize(deser)?);
-315
+                }
                 Some(4) => {
                     builder.recording_strategy = Some(crate::types::RecordingStrategy::deserialize(deser)?);
-318
+                }
                 _ => {}
-320
+            }
             Ok(())
         })?;
         Ok(builder.build())
-324
+    }
-325
+}
 impl RecordingGroup {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl RecordingGroup {
     /// Creates a new builder-style object to manufacture [`RecordingGroup`](crate::types::RecordingGroup).
     pub fn builder() -> crate::types::builders::RecordingGroupBuilder {
         crate::types::builders::RecordingGroupBuilder::default()
-341
+    }
-342
+}
-343
 /// A builder for [`RecordingGroup`](crate::types::RecordingGroup).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RecordingGroupBuilder {
     pub(crate) all_supported: ::std::option::Option<bool>,
     pub(crate) include_global_resource_types: ::std::option::Option<bool>,
     pub(crate) resource_types: ::std::option::Option<::std::vec::Vec<crate::types::ResourceType>>,
     pub(crate) exclusion_by_resource_types: ::std::option::Option<crate::types::ExclusionByResourceTypes>,
     pub(crate) recording_strategy: ::std::option::Option<crate::types::RecordingStrategy>,
-353
+}
 impl RecordingGroupBuilder {
     /// <p>Specifies whether Config records configuration changes for all supported resource types, excluding the global IAM resource types.</p>
     /// <p>If you set this field to <code>true</code>, when Config adds support for a new resource type, Config starts recording resources of that type automatically.</p>
     /// <p>If you set this field to <code>true</code>, you cannot enumerate specific resource types to record in the <code>resourceTypes</code> field of <a href="https://docs.aws.amazon.com/config/latest/APIReference/API_RecordingGroup.html">RecordingGroup</a>, or to exclude in the <code>resourceTypes</code> field of <a href="https://docs.aws.amazon.com/config/latest/APIReference/API_ExclusionByResourceTypes.html">ExclusionByResourceTypes</a>.</p><note>
     /// <p><b>Region availability</b></p>
     /// <p>Check <a href="https://docs.aws.amazon.com/config/latest/developerguide/what-is-resource-config-coverage.html">Resource Coverage by Region Availability</a> to see if a resource type is supported in the Amazon Web Services Region where you set up Config.</p>
     /// </note>
     pub fn all_supported(mut self, input: bool) -> Self {
         self.all_supported = ::std::option::Option::Some(input);
         self
-364
+    }
     /// <p>Specifies whether Config records configuration changes for all supported resource types, excluding the global IAM resource types.</p>
     /// <p>If you set this field to <code>true</code>, when Config adds support for a new resource type, Config starts recording resources of that type automatically.</p>

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_recording_mode.rs

@@ -37,37 +183,191 @@

↥ Expand context

     /// <p><code>AWS::Config::ResourceCompliance</code></p></li>
     /// <li>
     /// <p><code>AWS::Config::ConformancePackCompliance</code></p></li>
     /// <li>
     /// <p><code>AWS::Config::ConfigurationRecorder</code></p></li>
     /// </ul>
     /// <p>For the <b>allSupported</b> (<code>ALL_SUPPORTED_RESOURCE_TYPES</code>) recording strategy, these resource types will be set to Continuous recording.</p>
     /// </important>
     pub fn recording_frequency(&self) -> &crate::types::RecordingFrequency {
         &self.recording_frequency
-47
+    }
     /// <p>An array of <code>recordingModeOverride</code> objects for you to specify your overrides for the recording mode. The <code>recordingModeOverride</code> object in the <code>recordingModeOverrides</code> array consists of three fields: a <code>description</code>, the new <code>recordingFrequency</code>, and an array of <code>resourceTypes</code> to override.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.recording_mode_overrides.is_none()`.
     pub fn recording_mode_overrides(&self) -> &[crate::types::RecordingModeOverride] {
         self.recording_mode_overrides.as_deref().unwrap_or_default()
-53
+    }
-54
+}
 static RECORDINGMODE_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.configservice#RecordingMode",

     "com.amazonaws.configservice",
     "RecordingMode",
 );
 static RECORDINGMODE_MEMBER_RECORDING_FREQUENCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RecordingMode$recordingFrequency",
         "com.amazonaws.configservice",
         "RecordingMode",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "recording_frequency",
     "recordingFrequency",
 ,
 );
 static RECORDINGMODE_MEMBER_RECORDING_MODE_OVERRIDES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RecordingMode$recordingModeOverrides",
         "com.amazonaws.configservice",
         "RecordingMode",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "recording_mode_overrides",
     "recordingModeOverrides",
 ,
 );
 static RECORDINGMODE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RECORDINGMODE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&RECORDINGMODE_MEMBER_RECORDING_FREQUENCY, &RECORDINGMODE_MEMBER_RECORDING_MODE_OVERRIDES],
 );
 impl RecordingMode {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RECORDINGMODE_SCHEMA;
-88
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RecordingMode {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
-95
+        {
             let val = &self.recording_frequency;
             ser.write_string(&RECORDINGMODE_MEMBER_RECORDING_FREQUENCY, val.as_str())?;
-98
+        }
         if let Some(ref val) = self.recording_mode_overrides {
             ser.write_list(
                 &RECORDINGMODE_MEMBER_RECORDING_MODE_OVERRIDES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::RecordingModeOverride::SCHEMA, item)?;
-105
+                    }
                     Ok(())
                 },
             )?;
-109
+        }
         Ok(())
-111
+    }
-112
+}
 impl RecordingMode {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&RECORDINGMODE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RECORDINGMODE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.recording_frequency = Some(crate::types::RecordingFrequency::from(deser.read_string(member)?.as_str()));
-131
+                }
                 Some(1) => {
                     builder.recording_mode_overrides = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::RecordingModeOverride::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::RecordingModeOverride::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-141
+                }
                 _ => {}
-143
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-149
+    }
-150
+}
 impl RecordingMode {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl RecordingMode {
     /// Creates a new builder-style object to manufacture [`RecordingMode`](crate::types::RecordingMode).
     pub fn builder() -> crate::types::builders::RecordingModeBuilder {
         crate::types::builders::RecordingModeBuilder::default()
-166
+    }
-167
+}
-168
 /// A builder for [`RecordingMode`](crate::types::RecordingMode).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RecordingModeBuilder {
     pub(crate) recording_frequency: ::std::option::Option<crate::types::RecordingFrequency>,
     pub(crate) recording_mode_overrides: ::std::option::Option<::std::vec::Vec<crate::types::RecordingModeOverride>>,
-175
+}
 impl RecordingModeBuilder {
     /// <p>The default recording frequency that Config uses to record configuration changes.</p><important>
     /// <p>Daily recording cannot be specified for the following resource types:</p>
     /// <ul>
     /// <li>
     /// <p><code>AWS::Config::ResourceCompliance</code></p></li>
     /// <li>
     /// <p><code>AWS::Config::ConformancePackCompliance</code></p></li>
     /// <li>
     /// <p><code>AWS::Config::ConfigurationRecorder</code></p></li>
     /// </ul>
     /// <p>For the <b>allSupported</b> (<code>ALL_SUPPORTED_RESOURCE_TYPES</code>) recording strategy, these resource types will be set to Continuous recording.</p>
     /// </important>
     /// This field is required.
     pub fn recording_frequency(mut self, input: crate::types::RecordingFrequency) -> Self {
         self.recording_frequency = ::std::option::Option::Some(input);

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_recording_mode_override.rs

@@ -57,57 +215,224 @@

↥ Expand context

     /// <p>Daily recording allows you to receive a configuration item (CI) representing the most recent state of your resources over the last 24-hour period, only if it’s different from the previous CI recorded.</p></li>
     /// </ul><note>
     /// <p>Firewall Manager depends on continuous recording to monitor your resources. If you are using Firewall Manager, it is recommended that you set the recording frequency to Continuous.</p>
     /// </note>
     pub fn recording_frequency(&self) -> &crate::types::RecordingFrequency {
         &self.recording_frequency
-63
+    }
-64
+}
 static RECORDINGMODEOVERRIDE_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.configservice#RecordingModeOverride",
     "com.amazonaws.configservice",
     "RecordingModeOverride",
 );
 static RECORDINGMODEOVERRIDE_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RecordingModeOverride$description",
         "com.amazonaws.configservice",
         "RecordingModeOverride",
     ),
     ::aws_smithy_schema::ShapeType::String,

     "description",
 ,
 );
 static RECORDINGMODEOVERRIDE_MEMBER_RESOURCE_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RecordingModeOverride$resourceTypes",
         "com.amazonaws.configservice",
         "RecordingModeOverride",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "resource_types",
     "resourceTypes",
 ,
 );
 static RECORDINGMODEOVERRIDE_MEMBER_RECORDING_FREQUENCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RecordingModeOverride$recordingFrequency",
         "com.amazonaws.configservice",
         "RecordingModeOverride",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "recording_frequency",
     "recordingFrequency",
 ,
 );
 static RECORDINGMODEOVERRIDE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RECORDINGMODEOVERRIDE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &RECORDINGMODEOVERRIDE_MEMBER_DESCRIPTION,
         &RECORDINGMODEOVERRIDE_MEMBER_RESOURCE_TYPES,
         &RECORDINGMODEOVERRIDE_MEMBER_RECORDING_FREQUENCY,
     ],
 );
 impl RecordingModeOverride {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RECORDINGMODEOVERRIDE_SCHEMA;
-112
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RecordingModeOverride {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.description {
             ser.write_string(&RECORDINGMODEOVERRIDE_MEMBER_DESCRIPTION, val)?;
-121
+        }
-122
+        {
             let val = &self.resource_types;
-124
             ser.write_list(
                 &RECORDINGMODEOVERRIDE_MEMBER_RESOURCE_TYPES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
-130
+                    }
                     Ok(())
                 },
             )?;
-134
+        }
-135
+        {
             let val = &self.recording_frequency;
             ser.write_string(&RECORDINGMODEOVERRIDE_MEMBER_RECORDING_FREQUENCY, val.as_str())?;
-138
+        }
         Ok(())
-140
+    }
-141
+}
 impl RecordingModeOverride {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&RECORDINGMODEOVERRIDE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RECORDINGMODEOVERRIDE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.description = Some(deser.read_string(member)?);
-160
+                }
                 Some(1) => {
                     builder.resource_types = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::ResourceType::from(deser.read_string(member)?.as_str()));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ResourceType::from(deser.read_string(member)?.as_str()));
                             Ok(())
                         })?;
                         container
                     });
-170
+                }
                 Some(2) => {
                     builder.recording_frequency = Some(crate::types::RecordingFrequency::from(deser.read_string(member)?.as_str()));
-173
+                }
                 _ => {}
-175
+            }
             Ok(())
         })?;
         builder.resource_types = builder.resource_types.or(Some(Vec::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-182
+    }
-183
+}
 impl RecordingModeOverride {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl RecordingModeOverride {
     /// Creates a new builder-style object to manufacture [`RecordingModeOverride`](crate::types::RecordingModeOverride).
     pub fn builder() -> crate::types::builders::RecordingModeOverrideBuilder {
         crate::types::builders::RecordingModeOverrideBuilder::default()
-199
+    }
-200
+}
-201
 /// A builder for [`RecordingModeOverride`](crate::types::RecordingModeOverride).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RecordingModeOverrideBuilder {
     pub(crate) description: ::std::option::Option<::std::string::String>,
     pub(crate) resource_types: ::std::option::Option<::std::vec::Vec<crate::types::ResourceType>>,
     pub(crate) recording_frequency: ::std::option::Option<crate::types::RecordingFrequency>,
-209
+}
 impl RecordingModeOverrideBuilder {
     /// <p>A description that you provide for the override.</p>
     pub fn description(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.description = ::std::option::Option::Some(input.into());
         self
-215
+    }
     /// <p>A description that you provide for the override.</p>
     pub fn set_description(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.description = input;
         self
-220
+    }
     /// <p>A description that you provide for the override.</p>
     pub fn get_description(&self) -> &::std::option::Option<::std::string::String> {
         &self.description
-224
+    }

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_recording_strategy.rs

@@ -74,74 +183,194 @@

↥ Expand context

     /// <li>
     /// <p>Asia Pacific (Melbourne)</p></li>
     /// <li>
     /// <p>Canada West (Calgary)</p></li>
     /// <li>
     /// <p>Europe (Spain)</p></li>
     /// <li>
     /// <p>Europe (Zurich)</p></li>
     /// <li>
     /// <p>Israel (Tel Aviv)</p></li>
     /// <li>
     /// <p>Middle East (UAE)</p></li>
     /// </ul>
     /// </note>
     pub fn use_only(&self) -> ::std::option::Option<&crate::types::RecordingStrategyType> {
         self.use_only.as_ref()
-90
+    }
-91
+}
 static RECORDINGSTRATEGY_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.configservice#RecordingStrategy",

     "com.amazonaws.configservice",
     "RecordingStrategy",
 );
 static RECORDINGSTRATEGY_MEMBER_USE_ONLY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RecordingStrategy$useOnly",
         "com.amazonaws.configservice",
         "RecordingStrategy",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "use_only",
     "useOnly",
 ,
 );
 static RECORDINGSTRATEGY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RECORDINGSTRATEGY_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&RECORDINGSTRATEGY_MEMBER_USE_ONLY],
 );
 impl RecordingStrategy {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RECORDINGSTRATEGY_SCHEMA;
-115
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RecordingStrategy {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.use_only {
             ser.write_string(&RECORDINGSTRATEGY_MEMBER_USE_ONLY, val.as_str())?;
-124
+        }
         Ok(())
-126
+    }
-127
+}
 impl RecordingStrategy {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&RECORDINGSTRATEGY_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RECORDINGSTRATEGY_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.use_only = Some(crate::types::RecordingStrategyType::from(deser.read_string(member)?.as_str()));
-146
+                }
                 _ => {}
-148
+            }
             Ok(())
         })?;
         Ok(builder.build())
-152
+    }
-153
+}
 impl RecordingStrategy {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl RecordingStrategy {
     /// Creates a new builder-style object to manufacture [`RecordingStrategy`](crate::types::RecordingStrategy).
     pub fn builder() -> crate::types::builders::RecordingStrategyBuilder {
         crate::types::builders::RecordingStrategyBuilder::default()
-169
+    }
-170
+}
-171
 /// A builder for [`RecordingStrategy`](crate::types::RecordingStrategy).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RecordingStrategyBuilder {
     pub(crate) use_only: ::std::option::Option<crate::types::RecordingStrategyType>,
-177
+}
 impl RecordingStrategyBuilder {
     /// <p>The recording strategy for the configuration recorder.</p>
     /// <ul>
     /// <li>
     /// <p>If you set this option to <code>ALL_SUPPORTED_RESOURCE_TYPES</code>, Config records configuration changes for all supported resource types, excluding the global IAM resource types. You also must set the <code>allSupported</code> field of <a href="https://docs.aws.amazon.com/config/latest/APIReference/API_RecordingGroup.html">RecordingGroup</a> to <code>true</code>. When Config adds support for a new resource type, Config automatically starts recording resources of that type. For a list of supported resource types, see <a href="https://docs.aws.amazon.com/config/latest/developerguide/resource-config-reference.html#supported-resources">Supported Resource Types</a> in the <i>Config developer guide</i>.</p></li>
     /// <li>
     /// <p>If you set this option to <code>INCLUSION_BY_RESOURCE_TYPES</code>, Config records configuration changes for only the resource types that you specify in the <code>resourceTypes</code> field of <a href="https://docs.aws.amazon.com/config/latest/APIReference/API_RecordingGroup.html">RecordingGroup</a>.</p></li>
     /// <li>
     /// <p>If you set this option to <code>EXCLUSION_BY_RESOURCE_TYPES</code>, Config records configuration changes for all supported resource types, except the resource types that you specify to exclude from being recorded in the <code>resourceTypes</code> field of <a href="https://docs.aws.amazon.com/config/latest/APIReference/API_ExclusionByResourceTypes.html">ExclusionByResourceTypes</a>.</p></li>
     /// </ul><note>
     /// <p><b>Required and optional fields</b></p>
     /// <p>The <code>recordingStrategy</code> field is optional when you set the <code>allSupported</code> field of <a href="https://docs.aws.amazon.com/config/latest/APIReference/API_RecordingGroup.html">RecordingGroup</a> to <code>true</code>.</p>
     /// <p>The <code>recordingStrategy</code> field is optional when you list resource types in the <code>resourceTypes</code> field of <a href="https://docs.aws.amazon.com/config/latest/APIReference/API_RecordingGroup.html">RecordingGroup</a>.</p>
     /// <p>The <code>recordingStrategy</code> field is required if you list resource types to exclude from recording in the <code>resourceTypes</code> field of <a href="https://docs.aws.amazon.com/config/latest/APIReference/API_ExclusionByResourceTypes.html">ExclusionByResourceTypes</a>.</p>
     /// </note> <note>
     /// <p><b>Overriding fields</b></p>
     /// <p>If you choose <code>EXCLUSION_BY_RESOURCE_TYPES</code> for the recording strategy, the <code>exclusionByResourceTypes</code> field will override other properties in the request.</p>

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_relationship.rs

@@ -13,13 +175,186 @@

↥ Expand context

     /// <p>The type of relationship with the related resource.</p>
     pub relationship_name: ::std::option::Option<::std::string::String>,
-15
+}
 impl Relationship {
     /// <p>The resource type of the related resource.</p>
     pub fn resource_type(&self) -> ::std::option::Option<&crate::types::ResourceType> {
         self.resource_type.as_ref()
-20
+    }
     /// <p>The ID of the related resource (for example, <code>sg-xxxxxx</code>).</p>
     pub fn resource_id(&self) -> ::std::option::Option<&str> {
         self.resource_id.as_deref()
-24
+    }
     /// <p>The custom name of the related resource, if available.</p>
     pub fn resource_name(&self) -> ::std::option::Option<&str> {
         self.resource_name.as_deref()
-28
+    }
     /// <p>The type of relationship with the related resource.</p>
     pub fn relationship_name(&self) -> ::std::option::Option<&str> {
         self.relationship_name.as_deref()
-32
+    }

-33
+}
 static RELATIONSHIP_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.configservice#Relationship", "com.amazonaws.configservice", "Relationship");
 static RELATIONSHIP_MEMBER_RESOURCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#Relationship$resourceType",
         "com.amazonaws.configservice",
         "Relationship",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_type",
     "resourceType",
 ,
 );
 static RELATIONSHIP_MEMBER_RESOURCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#Relationship$resourceId",
         "com.amazonaws.configservice",
         "Relationship",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_id",
     "resourceId",
 ,
 );
 static RELATIONSHIP_MEMBER_RESOURCE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#Relationship$resourceName",
         "com.amazonaws.configservice",
         "Relationship",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_name",
     "resourceName",
 ,
 );
 static RELATIONSHIP_MEMBER_RELATIONSHIP_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#Relationship$relationshipName",
         "com.amazonaws.configservice",
         "Relationship",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "relationship_name",
     "relationshipName",
 ,
 );
 static RELATIONSHIP_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RELATIONSHIP_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &RELATIONSHIP_MEMBER_RESOURCE_TYPE,
         &RELATIONSHIP_MEMBER_RESOURCE_ID,
         &RELATIONSHIP_MEMBER_RESOURCE_NAME,
         &RELATIONSHIP_MEMBER_RELATIONSHIP_NAME,
     ],
 );
 impl Relationship {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RELATIONSHIP_SCHEMA;
-89
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for Relationship {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.resource_type {
             ser.write_string(&RELATIONSHIP_MEMBER_RESOURCE_TYPE, val.as_str())?;
-98
+        }
         if let Some(ref val) = self.resource_id {
             ser.write_string(&RELATIONSHIP_MEMBER_RESOURCE_ID, val)?;
-101
+        }
         if let Some(ref val) = self.resource_name {
             ser.write_string(&RELATIONSHIP_MEMBER_RESOURCE_NAME, val)?;
-104
+        }
         if let Some(ref val) = self.relationship_name {
             ser.write_string(&RELATIONSHIP_MEMBER_RELATIONSHIP_NAME, val)?;
-107
+        }
         Ok(())
-109
+    }
-110
+}
 impl Relationship {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&RELATIONSHIP_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RELATIONSHIP_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.resource_type = Some(crate::types::ResourceType::from(deser.read_string(member)?.as_str()));
-129
+                }
                 Some(1) => {
                     builder.resource_id = Some(deser.read_string(member)?);
-132
+                }
                 Some(2) => {
                     builder.resource_name = Some(deser.read_string(member)?);
-135
+                }
                 Some(3) => {
                     builder.relationship_name = Some(deser.read_string(member)?);
-138
+                }
                 _ => {}
-140
+            }
             Ok(())
         })?;
         Ok(builder.build())
-144
+    }
-145
+}
 impl Relationship {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl Relationship {
     /// Creates a new builder-style object to manufacture [`Relationship`](crate::types::Relationship).
     pub fn builder() -> crate::types::builders::RelationshipBuilder {
         crate::types::builders::RelationshipBuilder::default()
-161
+    }
-162
+}
-163
 /// A builder for [`Relationship`](crate::types::Relationship).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RelationshipBuilder {
     pub(crate) resource_type: ::std::option::Option<crate::types::ResourceType>,
     pub(crate) resource_id: ::std::option::Option<::std::string::String>,
     pub(crate) resource_name: ::std::option::Option<::std::string::String>,
     pub(crate) relationship_name: ::std::option::Option<::std::string::String>,
-172
+}
 impl RelationshipBuilder {
     /// <p>The resource type of the related resource.</p>
     pub fn resource_type(mut self, input: crate::types::ResourceType) -> Self {
         self.resource_type = ::std::option::Option::Some(input);
         self
-178
+    }
     /// <p>The resource type of the related resource.</p>
     pub fn set_resource_type(mut self, input: ::std::option::Option<crate::types::ResourceType>) -> Self {
         self.resource_type = input;
         self
-183
+    }
     /// <p>The resource type of the related resource.</p>
     pub fn get_resource_type(&self) -> &::std::option::Option<crate::types::ResourceType> {
         &self.resource_type

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_remediation_configuration.rs

@@ -74,74 +244,244 @@

↥ Expand context

     /// <p>For example, if you specify MaximumAutomaticAttempts as 5 with RetryAttemptSeconds as 50 seconds, Config will put a RemediationException on your behalf for the failing resource after the 5th failed attempt within 50 seconds.</p>
     pub fn maximum_automatic_attempts(&self) -> ::std::option::Option<i32> {
         self.maximum_automatic_attempts
-77
+    }
     /// <p>Time window to determine whether or not to add a remediation exception to prevent infinite remediation attempts. If <code>MaximumAutomaticAttempts</code> remediation attempts have been made under <code>RetryAttemptSeconds</code>, a remediation exception will be added to the resource. If you do not select a number, the default is 60 seconds.</p>
     /// <p>For example, if you specify <code>RetryAttemptSeconds</code> as 50 seconds and <code>MaximumAutomaticAttempts</code> as 5, Config will run auto-remediations 5 times within 50 seconds before adding a remediation exception to the resource.</p>
     pub fn retry_attempt_seconds(&self) -> ::std::option::Option<i64> {
         self.retry_attempt_seconds
-82
+    }
     /// <p>Amazon Resource Name (ARN) of remediation configuration.</p>
     pub fn arn(&self) -> ::std::option::Option<&str> {
         self.arn.as_deref()
-86
+    }
     /// <p>Name of the service that owns the service-linked rule, if applicable.</p>
     pub fn created_by_service(&self) -> ::std::option::Option<&str> {
         self.created_by_service.as_deref()
-90
+    }
-91
+}
 static REMEDIATIONCONFIGURATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.configservice#RemediationConfiguration",

     "com.amazonaws.configservice",
     "RemediationConfiguration",
 );
 static REMEDIATIONCONFIGURATION_MEMBER_CONFIG_RULE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationConfiguration$ConfigRuleName",
         "com.amazonaws.configservice",
         "RemediationConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "config_rule_name",
     "ConfigRuleName",
 ,
 );
 static REMEDIATIONCONFIGURATION_MEMBER_TARGET_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationConfiguration$TargetType",
         "com.amazonaws.configservice",
         "RemediationConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "target_type",
     "TargetType",
 ,
 );
 static REMEDIATIONCONFIGURATION_MEMBER_TARGET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationConfiguration$TargetId",
         "com.amazonaws.configservice",
         "RemediationConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "target_id",
     "TargetId",
 ,
 );
 static REMEDIATIONCONFIGURATION_MEMBER_TARGET_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationConfiguration$TargetVersion",
         "com.amazonaws.configservice",
         "RemediationConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "target_version",
     "TargetVersion",
 ,
 );
 static REMEDIATIONCONFIGURATION_MEMBER_PARAMETERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationConfiguration$Parameters",
         "com.amazonaws.configservice",
         "RemediationConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "parameters",
     "Parameters",
 ,
 );
 static REMEDIATIONCONFIGURATION_MEMBER_RESOURCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationConfiguration$ResourceType",
         "com.amazonaws.configservice",
         "RemediationConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_type",
     "ResourceType",
 ,
 );
 static REMEDIATIONCONFIGURATION_MEMBER_AUTOMATIC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationConfiguration$Automatic",
         "com.amazonaws.configservice",
         "RemediationConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "automatic",
     "Automatic",
 ,
 );
 static REMEDIATIONCONFIGURATION_MEMBER_EXECUTION_CONTROLS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationConfiguration$ExecutionControls",
         "com.amazonaws.configservice",
         "RemediationConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "execution_controls",
     "ExecutionControls",
 ,
 );
 static REMEDIATIONCONFIGURATION_MEMBER_MAXIMUM_AUTOMATIC_ATTEMPTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationConfiguration$MaximumAutomaticAttempts",
         "com.amazonaws.configservice",
         "RemediationConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "maximum_automatic_attempts",
     "MaximumAutomaticAttempts",
 ,
 );
 static REMEDIATIONCONFIGURATION_MEMBER_RETRY_ATTEMPT_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationConfiguration$RetryAttemptSeconds",
         "com.amazonaws.configservice",
         "RemediationConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "retry_attempt_seconds",
     "RetryAttemptSeconds",
 ,
 );
 static REMEDIATIONCONFIGURATION_MEMBER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationConfiguration$Arn",
         "com.amazonaws.configservice",
         "RemediationConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "arn",
     "Arn",
 ,
 );
 static REMEDIATIONCONFIGURATION_MEMBER_CREATED_BY_SERVICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationConfiguration$CreatedByService",
         "com.amazonaws.configservice",
         "RemediationConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "created_by_service",
     "CreatedByService",
 ,
 );
 static REMEDIATIONCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     REMEDIATIONCONFIGURATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &REMEDIATIONCONFIGURATION_MEMBER_CONFIG_RULE_NAME,
         &REMEDIATIONCONFIGURATION_MEMBER_TARGET_TYPE,
         &REMEDIATIONCONFIGURATION_MEMBER_TARGET_ID,
         &REMEDIATIONCONFIGURATION_MEMBER_TARGET_VERSION,

↧ Expand context

         &REMEDIATIONCONFIGURATION_MEMBER_PARAMETERS,
         &REMEDIATIONCONFIGURATION_MEMBER_RESOURCE_TYPE,
         &REMEDIATIONCONFIGURATION_MEMBER_AUTOMATIC,
         &REMEDIATIONCONFIGURATION_MEMBER_EXECUTION_CONTROLS,
         &REMEDIATIONCONFIGURATION_MEMBER_MAXIMUM_AUTOMATIC_ATTEMPTS,
         &REMEDIATIONCONFIGURATION_MEMBER_RETRY_ATTEMPT_SECONDS,
         &REMEDIATIONCONFIGURATION_MEMBER_ARN,
         &REMEDIATIONCONFIGURATION_MEMBER_CREATED_BY_SERVICE,
     ],
 );
 impl RemediationConfiguration {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &REMEDIATIONCONFIGURATION_SCHEMA;
-238
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RemediationConfiguration {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {

@@ -269,269 +397,407 @@

↥ Expand context

                 },
             )?;
-271
+        }
         if let Some(ref val) = self.resource_type {
             ser.write_string(&REMEDIATIONCONFIGURATION_MEMBER_RESOURCE_TYPE, val)?;
-274
+        }
-275
+        {
             let val = &self.automatic;
             ser.write_boolean(&REMEDIATIONCONFIGURATION_MEMBER_AUTOMATIC, *val)?;
-278
+        }
         if let Some(ref val) = self.execution_controls {
             ser.write_struct(&REMEDIATIONCONFIGURATION_MEMBER_EXECUTION_CONTROLS, val)?;
-281
+        }
         if let Some(ref val) = self.maximum_automatic_attempts {
             ser.write_integer(&REMEDIATIONCONFIGURATION_MEMBER_MAXIMUM_AUTOMATIC_ATTEMPTS, *val)?;
-284
+        }
         if let Some(ref val) = self.retry_attempt_seconds {
             ser.write_long(&REMEDIATIONCONFIGURATION_MEMBER_RETRY_ATTEMPT_SECONDS, *val)?;
-287
+        }
         if let Some(ref val) = self.arn {

             ser.write_string(&REMEDIATIONCONFIGURATION_MEMBER_ARN, val)?;
-290
+        }
         if let Some(ref val) = self.created_by_service {
             ser.write_string(&REMEDIATIONCONFIGURATION_MEMBER_CREATED_BY_SERVICE, val)?;
-293
+        }
         Ok(())
-295
+    }
-296
+}
 impl RemediationConfiguration {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&REMEDIATIONCONFIGURATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&REMEDIATIONCONFIGURATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.config_rule_name = Some(deser.read_string(member)?);
-315
+                }
                 Some(1) => {
                     builder.target_type = Some(crate::types::RemediationTargetType::from(deser.read_string(member)?.as_str()));
-318
+                }
                 Some(2) => {
                     builder.target_id = Some(deser.read_string(member)?);
-321
+                }
                 Some(3) => {
                     builder.target_version = Some(deser.read_string(member)?);
-324
+                }
                 Some(4) => {
                     builder.parameters = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, crate::types::RemediationParameterValue::deserialize(deser)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::RemediationParameterValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-334
+                }
                 Some(5) => {
                     builder.resource_type = Some(deser.read_string(member)?);
-337
+                }
                 Some(6) => {
                     builder.automatic = Some(deser.read_boolean(member)?);
-340
+                }
                 Some(7) => {
                     builder.execution_controls = Some(crate::types::ExecutionControls::deserialize(deser)?);
-343
+                }
                 Some(8) => {
                     builder.maximum_automatic_attempts = Some(deser.read_integer(member)?);
-346
+                }
                 Some(9) => {
                     builder.retry_attempt_seconds = Some(deser.read_long(member)?);
-349
+                }
                 Some(10) => {
                     builder.arn = Some(deser.read_string(member)?);
-352
+                }
                 Some(11) => {
                     builder.created_by_service = Some(deser.read_string(member)?);
-355
+                }
                 _ => {}
-357
+            }
             Ok(())
         })?;
         builder.config_rule_name = builder.config_rule_name.or(Some(String::new()));
         builder.target_id = builder.target_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-365
+    }
-366
+}
 impl RemediationConfiguration {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl RemediationConfiguration {
     /// Creates a new builder-style object to manufacture [`RemediationConfiguration`](crate::types::RemediationConfiguration).
     pub fn builder() -> crate::types::builders::RemediationConfigurationBuilder {
         crate::types::builders::RemediationConfigurationBuilder::default()
-382
+    }
-383
+}
-384
 /// A builder for [`RemediationConfiguration`](crate::types::RemediationConfiguration).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RemediationConfigurationBuilder {
     pub(crate) config_rule_name: ::std::option::Option<::std::string::String>,
     pub(crate) target_type: ::std::option::Option<crate::types::RemediationTargetType>,
     pub(crate) target_id: ::std::option::Option<::std::string::String>,
     pub(crate) target_version: ::std::option::Option<::std::string::String>,
     pub(crate) parameters: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::RemediationParameterValue>>,
     pub(crate) resource_type: ::std::option::Option<::std::string::String>,
     pub(crate) automatic: ::std::option::Option<bool>,
     pub(crate) execution_controls: ::std::option::Option<crate::types::ExecutionControls>,
     pub(crate) maximum_automatic_attempts: ::std::option::Option<i32>,
     pub(crate) retry_attempt_seconds: ::std::option::Option<i64>,
     pub(crate) arn: ::std::option::Option<::std::string::String>,
     pub(crate) created_by_service: ::std::option::Option<::std::string::String>,
-401
+}
 impl RemediationConfigurationBuilder {
     /// <p>The name of the Config rule.</p>
     /// This field is required.
     pub fn config_rule_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.config_rule_name = ::std::option::Option::Some(input.into());
         self

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_remediation_exception.rs

@@ -25,25 +209,223 @@

↥ Expand context

     pub fn resource_type(&self) -> &str {
         use std::ops::Deref;
         self.resource_type.deref()
-28
+    }
     /// <p>The ID of the resource (for example., sg-xxxxxx).</p>
     pub fn resource_id(&self) -> &str {
         use std::ops::Deref;
         self.resource_id.deref()
-33
+    }
     /// <p>An explanation of an remediation exception.</p>
     pub fn message(&self) -> ::std::option::Option<&str> {
         self.message.as_deref()
-37
+    }
     /// <p>The time when the remediation exception will be deleted.</p>
     pub fn expiration_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.expiration_time.as_ref()
-41
+    }
-42
+}
 static REMEDIATIONEXCEPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.configservice#RemediationException",

     "com.amazonaws.configservice",
     "RemediationException",
 );
 static REMEDIATIONEXCEPTION_MEMBER_CONFIG_RULE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationException$ConfigRuleName",
         "com.amazonaws.configservice",
         "RemediationException",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "config_rule_name",
     "ConfigRuleName",
 ,
 );
 static REMEDIATIONEXCEPTION_MEMBER_RESOURCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationException$ResourceType",
         "com.amazonaws.configservice",
         "RemediationException",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_type",
     "ResourceType",
 ,
 );
 static REMEDIATIONEXCEPTION_MEMBER_RESOURCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationException$ResourceId",
         "com.amazonaws.configservice",
         "RemediationException",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_id",
     "ResourceId",
 ,
 );
 static REMEDIATIONEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationException$Message",
         "com.amazonaws.configservice",
         "RemediationException",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
 );
 static REMEDIATIONEXCEPTION_MEMBER_EXPIRATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationException$ExpirationTime",
         "com.amazonaws.configservice",
         "RemediationException",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "expiration_time",
     "ExpirationTime",
 ,
 );
 static REMEDIATIONEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     REMEDIATIONEXCEPTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &REMEDIATIONEXCEPTION_MEMBER_CONFIG_RULE_NAME,
         &REMEDIATIONEXCEPTION_MEMBER_RESOURCE_TYPE,
         &REMEDIATIONEXCEPTION_MEMBER_RESOURCE_ID,
         &REMEDIATIONEXCEPTION_MEMBER_MESSAGE,
         &REMEDIATIONEXCEPTION_MEMBER_EXPIRATION_TIME,
     ],
 );
 impl RemediationException {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &REMEDIATIONEXCEPTION_SCHEMA;
-112
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RemediationException {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
-119
+        {
             let val = &self.config_rule_name;
             ser.write_string(&REMEDIATIONEXCEPTION_MEMBER_CONFIG_RULE_NAME, val)?;
-122
+        }
-123
+        {
             let val = &self.resource_type;
             ser.write_string(&REMEDIATIONEXCEPTION_MEMBER_RESOURCE_TYPE, val)?;
-126
+        }
-127
+        {
             let val = &self.resource_id;
             ser.write_string(&REMEDIATIONEXCEPTION_MEMBER_RESOURCE_ID, val)?;
-130
+        }
         if let Some(ref val) = self.message {
             ser.write_string(&REMEDIATIONEXCEPTION_MEMBER_MESSAGE, val)?;
-133
+        }
         if let Some(ref val) = self.expiration_time {
             ser.write_timestamp(&REMEDIATIONEXCEPTION_MEMBER_EXPIRATION_TIME, val)?;
-136
+        }
         Ok(())
-138
+    }
-139
+}
 impl RemediationException {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&REMEDIATIONEXCEPTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&REMEDIATIONEXCEPTION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.config_rule_name = Some(deser.read_string(member)?);
-158
+                }
                 Some(1) => {
                     builder.resource_type = Some(deser.read_string(member)?);
-161
+                }
                 Some(2) => {
                     builder.resource_id = Some(deser.read_string(member)?);
-164
+                }
                 Some(3) => {
                     builder.message = Some(deser.read_string(member)?);
-167
+                }
                 Some(4) => {
                     builder.expiration_time = Some(deser.read_timestamp(member)?);
-170
+                }
                 _ => {}
-172
+            }
             Ok(())
         })?;
         builder.config_rule_name = builder.config_rule_name.or(Some(String::new()));
         builder.resource_type = builder.resource_type.or(Some(String::new()));
         builder.resource_id = builder.resource_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-181
+    }
-182
+}
 impl RemediationException {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl RemediationException {
     /// Creates a new builder-style object to manufacture [`RemediationException`](crate::types::RemediationException).
     pub fn builder() -> crate::types::builders::RemediationExceptionBuilder {
         crate::types::builders::RemediationExceptionBuilder::default()
-198
+    }
-199
+}
-200
 /// A builder for [`RemediationException`](crate::types::RemediationException).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RemediationExceptionBuilder {
     pub(crate) config_rule_name: ::std::option::Option<::std::string::String>,
     pub(crate) resource_type: ::std::option::Option<::std::string::String>,
     pub(crate) resource_id: ::std::option::Option<::std::string::String>,
     pub(crate) message: ::std::option::Option<::std::string::String>,
     pub(crate) expiration_time: ::std::option::Option<::aws_smithy_types::DateTime>,
-210
+}
 impl RemediationExceptionBuilder {
     /// <p>The name of the Config rule.</p>
     /// This field is required.
     pub fn config_rule_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.config_rule_name = ::std::option::Option::Some(input.into());
         self
-217
+    }
     /// <p>The name of the Config rule.</p>
     pub fn set_config_rule_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.config_rule_name = input;
         self
-222
+    }
     /// <p>The name of the Config rule.</p>

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_remediation_exception_resource_key.rs

@@ -4,4 +132,143 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct RemediationExceptionResourceKey {
     /// <p>The type of a resource.</p>
     pub resource_type: ::std::option::Option<::std::string::String>,
     /// <p>The ID of the resource (for example., sg-xxxxxx).</p>
     pub resource_id: ::std::option::Option<::std::string::String>,
-11
+}
 impl RemediationExceptionResourceKey {
     /// <p>The type of a resource.</p>
     pub fn resource_type(&self) -> ::std::option::Option<&str> {
         self.resource_type.as_deref()
-16
+    }
     /// <p>The ID of the resource (for example., sg-xxxxxx).</p>
     pub fn resource_id(&self) -> ::std::option::Option<&str> {
         self.resource_id.as_deref()
-20
+    }
-21
+}
 static REMEDIATIONEXCEPTIONRESOURCEKEY_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.configservice#RemediationExceptionResourceKey",

     "com.amazonaws.configservice",
     "RemediationExceptionResourceKey",
 );
 static REMEDIATIONEXCEPTIONRESOURCEKEY_MEMBER_RESOURCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationExceptionResourceKey$ResourceType",
         "com.amazonaws.configservice",
         "RemediationExceptionResourceKey",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_type",
     "ResourceType",
 ,
 );
 static REMEDIATIONEXCEPTIONRESOURCEKEY_MEMBER_RESOURCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationExceptionResourceKey$ResourceId",
         "com.amazonaws.configservice",
         "RemediationExceptionResourceKey",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_id",
     "ResourceId",
 ,
 );
 static REMEDIATIONEXCEPTIONRESOURCEKEY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     REMEDIATIONEXCEPTIONRESOURCEKEY_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &REMEDIATIONEXCEPTIONRESOURCEKEY_MEMBER_RESOURCE_TYPE,
         &REMEDIATIONEXCEPTIONRESOURCEKEY_MEMBER_RESOURCE_ID,
     ],
 );
 impl RemediationExceptionResourceKey {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &REMEDIATIONEXCEPTIONRESOURCEKEY_SCHEMA;
-58
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RemediationExceptionResourceKey {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.resource_type {
             ser.write_string(&REMEDIATIONEXCEPTIONRESOURCEKEY_MEMBER_RESOURCE_TYPE, val)?;
-67
+        }
         if let Some(ref val) = self.resource_id {
             ser.write_string(&REMEDIATIONEXCEPTIONRESOURCEKEY_MEMBER_RESOURCE_ID, val)?;
-70
+        }
         Ok(())
-72
+    }
-73
+}
 impl RemediationExceptionResourceKey {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&REMEDIATIONEXCEPTIONRESOURCEKEY_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&REMEDIATIONEXCEPTIONRESOURCEKEY_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.resource_type = Some(deser.read_string(member)?);
-92
+                }
                 Some(1) => {
                     builder.resource_id = Some(deser.read_string(member)?);
-95
+                }
                 _ => {}
-97
+            }
             Ok(())
         })?;
         Ok(builder.build())
-101
+    }
-102
+}
 impl RemediationExceptionResourceKey {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl RemediationExceptionResourceKey {
     /// Creates a new builder-style object to manufacture [`RemediationExceptionResourceKey`](crate::types::RemediationExceptionResourceKey).
     pub fn builder() -> crate::types::builders::RemediationExceptionResourceKeyBuilder {
         crate::types::builders::RemediationExceptionResourceKeyBuilder::default()
-118
+    }
-119
+}
-120
 /// A builder for [`RemediationExceptionResourceKey`](crate::types::RemediationExceptionResourceKey).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RemediationExceptionResourceKeyBuilder {
     pub(crate) resource_type: ::std::option::Option<::std::string::String>,
     pub(crate) resource_id: ::std::option::Option<::std::string::String>,
-127
+}
 impl RemediationExceptionResourceKeyBuilder {
     /// <p>The type of a resource.</p>
     pub fn resource_type(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.resource_type = ::std::option::Option::Some(input.into());
         self
-133
+    }
     /// <p>The type of a resource.</p>
     pub fn set_resource_type(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.resource_type = input;
         self
-138
+    }
     /// <p>The type of a resource.</p>
     pub fn get_resource_type(&self) -> &::std::option::Option<::std::string::String> {
         &self.resource_type
-142
+    }
     /// <p>The ID of the resource (for example., sg-xxxxxx).</p>

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_remediation_execution_status.rs

@@ -24,24 +221,229 @@

↥ Expand context

     pub fn state(&self) -> ::std::option::Option<&crate::types::RemediationExecutionState> {
         self.state.as_ref()
-26
+    }
     /// <p>Details of every step.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.step_details.is_none()`.
     pub fn step_details(&self) -> &[crate::types::RemediationExecutionStep] {
         self.step_details.as_deref().unwrap_or_default()
-32
+    }
     /// <p>Start time when the remediation was executed.</p>
     pub fn invocation_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.invocation_time.as_ref()
-36
+    }
     /// <p>The time when the remediation execution was last updated.</p>
     pub fn last_updated_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.last_updated_time.as_ref()
-40
+    }
-41
+}
 static REMEDIATIONEXECUTIONSTATUS_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.configservice#RemediationExecutionStatus",

     "com.amazonaws.configservice",
     "RemediationExecutionStatus",
 );
 static REMEDIATIONEXECUTIONSTATUS_MEMBER_RESOURCE_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationExecutionStatus$ResourceKey",
         "com.amazonaws.configservice",
         "RemediationExecutionStatus",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "resource_key",
     "ResourceKey",
 ,
 );
 static REMEDIATIONEXECUTIONSTATUS_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationExecutionStatus$State",
         "com.amazonaws.configservice",
         "RemediationExecutionStatus",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "state",
     "State",
 ,
 );
 static REMEDIATIONEXECUTIONSTATUS_MEMBER_STEP_DETAILS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationExecutionStatus$StepDetails",
         "com.amazonaws.configservice",
         "RemediationExecutionStatus",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "step_details",
     "StepDetails",
 ,
 );
 static REMEDIATIONEXECUTIONSTATUS_MEMBER_INVOCATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationExecutionStatus$InvocationTime",
         "com.amazonaws.configservice",
         "RemediationExecutionStatus",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "invocation_time",
     "InvocationTime",
 ,
 );
 static REMEDIATIONEXECUTIONSTATUS_MEMBER_LAST_UPDATED_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationExecutionStatus$LastUpdatedTime",
         "com.amazonaws.configservice",
         "RemediationExecutionStatus",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "last_updated_time",
     "LastUpdatedTime",
 ,
 );
 static REMEDIATIONEXECUTIONSTATUS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     REMEDIATIONEXECUTIONSTATUS_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &REMEDIATIONEXECUTIONSTATUS_MEMBER_RESOURCE_KEY,
         &REMEDIATIONEXECUTIONSTATUS_MEMBER_STATE,
         &REMEDIATIONEXECUTIONSTATUS_MEMBER_STEP_DETAILS,
         &REMEDIATIONEXECUTIONSTATUS_MEMBER_INVOCATION_TIME,
         &REMEDIATIONEXECUTIONSTATUS_MEMBER_LAST_UPDATED_TIME,
     ],
 );
 impl RemediationExecutionStatus {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &REMEDIATIONEXECUTIONSTATUS_SCHEMA;
-111
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RemediationExecutionStatus {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.resource_key {
             ser.write_struct(&REMEDIATIONEXECUTIONSTATUS_MEMBER_RESOURCE_KEY, val)?;
-120
+        }
         if let Some(ref val) = self.state {
             ser.write_string(&REMEDIATIONEXECUTIONSTATUS_MEMBER_STATE, val.as_str())?;
-123
+        }
         if let Some(ref val) = self.step_details {
             ser.write_list(
                 &REMEDIATIONEXECUTIONSTATUS_MEMBER_STEP_DETAILS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::RemediationExecutionStep::SCHEMA, item)?;
-130
+                    }
                     Ok(())
                 },
             )?;
-134
+        }
         if let Some(ref val) = self.invocation_time {
             ser.write_timestamp(&REMEDIATIONEXECUTIONSTATUS_MEMBER_INVOCATION_TIME, val)?;
-137
+        }
         if let Some(ref val) = self.last_updated_time {
             ser.write_timestamp(&REMEDIATIONEXECUTIONSTATUS_MEMBER_LAST_UPDATED_TIME, val)?;
-140
+        }
         Ok(())
-142
+    }
-143
+}
 impl RemediationExecutionStatus {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&REMEDIATIONEXECUTIONSTATUS_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&REMEDIATIONEXECUTIONSTATUS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.resource_key = Some(crate::types::ResourceKey::deserialize(deser)?);
-162
+                }
                 Some(1) => {
                     builder.state = Some(crate::types::RemediationExecutionState::from(deser.read_string(member)?.as_str()));
-165
+                }
                 Some(2) => {
                     builder.step_details = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::RemediationExecutionStep::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::RemediationExecutionStep::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-175
+                }
                 Some(3) => {
                     builder.invocation_time = Some(deser.read_timestamp(member)?);
-178
+                }
                 Some(4) => {
                     builder.last_updated_time = Some(deser.read_timestamp(member)?);
-181
+                }
                 _ => {}
-183
+            }
             Ok(())
         })?;
         Ok(builder.build())
-187
+    }
-188
+}
 impl RemediationExecutionStatus {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl RemediationExecutionStatus {
     /// Creates a new builder-style object to manufacture [`RemediationExecutionStatus`](crate::types::RemediationExecutionStatus).
     pub fn builder() -> crate::types::builders::RemediationExecutionStatusBuilder {
         crate::types::builders::RemediationExecutionStatusBuilder::default()
-204
+    }
-205
+}
-206
 /// A builder for [`RemediationExecutionStatus`](crate::types::RemediationExecutionStatus).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RemediationExecutionStatusBuilder {
     pub(crate) resource_key: ::std::option::Option<crate::types::ResourceKey>,
     pub(crate) state: ::std::option::Option<crate::types::RemediationExecutionState>,
     pub(crate) step_details: ::std::option::Option<::std::vec::Vec<crate::types::RemediationExecutionStep>>,
     pub(crate) invocation_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) last_updated_time: ::std::option::Option<::aws_smithy_types::DateTime>,
-216
+}
 impl RemediationExecutionStatusBuilder {
     /// <p>The details that identify a resource within Config, including the resource type and resource ID.</p>
     pub fn resource_key(mut self, input: crate::types::ResourceKey) -> Self {
         self.resource_key = ::std::option::Option::Some(input);
         self
-222
+    }
     /// <p>The details that identify a resource within Config, including the resource type and resource ID.</p>
     pub fn set_resource_key(mut self, input: ::std::option::Option<crate::types::ResourceKey>) -> Self {
         self.resource_key = input;
         self
-227
+    }
     /// <p>The details that identify a resource within Config, including the resource type and resource ID.</p>
     pub fn get_resource_key(&self) -> &::std::option::Option<crate::types::ResourceKey> {

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_remediation_execution_step.rs

@@ -22,22 +201,212 @@

↥ Expand context

-22
+    }
     /// <p>The valid status of the step.</p>
     pub fn state(&self) -> ::std::option::Option<&crate::types::RemediationExecutionStepState> {
         self.state.as_ref()
-26
+    }
     /// <p>An error message if the step was interrupted during execution.</p>
     pub fn error_message(&self) -> ::std::option::Option<&str> {
         self.error_message.as_deref()
-30
+    }
     /// <p>The time when the step started.</p>
     pub fn start_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.start_time.as_ref()
-34
+    }
     /// <p>The time when the step stopped.</p>
     pub fn stop_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.stop_time.as_ref()
-38
+    }
-39
+}
 static REMEDIATIONEXECUTIONSTEP_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.configservice#RemediationExecutionStep",

     "com.amazonaws.configservice",
     "RemediationExecutionStep",
 );
 static REMEDIATIONEXECUTIONSTEP_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationExecutionStep$Name",
         "com.amazonaws.configservice",
         "RemediationExecutionStep",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "name",
     "Name",
 ,
 );
 static REMEDIATIONEXECUTIONSTEP_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationExecutionStep$State",
         "com.amazonaws.configservice",
         "RemediationExecutionStep",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "state",
     "State",
 ,
 );
 static REMEDIATIONEXECUTIONSTEP_MEMBER_ERROR_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationExecutionStep$ErrorMessage",
         "com.amazonaws.configservice",
         "RemediationExecutionStep",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "error_message",
     "ErrorMessage",
 ,
 );
 static REMEDIATIONEXECUTIONSTEP_MEMBER_START_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationExecutionStep$StartTime",
         "com.amazonaws.configservice",
         "RemediationExecutionStep",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "start_time",
     "StartTime",
 ,
 );
 static REMEDIATIONEXECUTIONSTEP_MEMBER_STOP_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationExecutionStep$StopTime",
         "com.amazonaws.configservice",
         "RemediationExecutionStep",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "stop_time",
     "StopTime",
 ,
 );
 static REMEDIATIONEXECUTIONSTEP_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     REMEDIATIONEXECUTIONSTEP_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &REMEDIATIONEXECUTIONSTEP_MEMBER_NAME,
         &REMEDIATIONEXECUTIONSTEP_MEMBER_STATE,
         &REMEDIATIONEXECUTIONSTEP_MEMBER_ERROR_MESSAGE,
         &REMEDIATIONEXECUTIONSTEP_MEMBER_START_TIME,
         &REMEDIATIONEXECUTIONSTEP_MEMBER_STOP_TIME,
     ],
 );
 impl RemediationExecutionStep {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &REMEDIATIONEXECUTIONSTEP_SCHEMA;
-109
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RemediationExecutionStep {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.name {
             ser.write_string(&REMEDIATIONEXECUTIONSTEP_MEMBER_NAME, val)?;
-118
+        }
         if let Some(ref val) = self.state {
             ser.write_string(&REMEDIATIONEXECUTIONSTEP_MEMBER_STATE, val.as_str())?;
-121
+        }
         if let Some(ref val) = self.error_message {
             ser.write_string(&REMEDIATIONEXECUTIONSTEP_MEMBER_ERROR_MESSAGE, val)?;
-124
+        }
         if let Some(ref val) = self.start_time {
             ser.write_timestamp(&REMEDIATIONEXECUTIONSTEP_MEMBER_START_TIME, val)?;
-127
+        }
         if let Some(ref val) = self.stop_time {
             ser.write_timestamp(&REMEDIATIONEXECUTIONSTEP_MEMBER_STOP_TIME, val)?;
-130
+        }
         Ok(())
-132
+    }
-133
+}
 impl RemediationExecutionStep {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&REMEDIATIONEXECUTIONSTEP_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&REMEDIATIONEXECUTIONSTEP_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.name = Some(deser.read_string(member)?);
-152
+                }
                 Some(1) => {
                     builder.state = Some(crate::types::RemediationExecutionStepState::from(deser.read_string(member)?.as_str()));
-155
+                }
                 Some(2) => {
                     builder.error_message = Some(deser.read_string(member)?);
-158
+                }
                 Some(3) => {
                     builder.start_time = Some(deser.read_timestamp(member)?);
-161
+                }
                 Some(4) => {
                     builder.stop_time = Some(deser.read_timestamp(member)?);
-164
+                }
                 _ => {}
-166
+            }
             Ok(())
         })?;
         Ok(builder.build())
-170
+    }
-171
+}
 impl RemediationExecutionStep {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl RemediationExecutionStep {
     /// Creates a new builder-style object to manufacture [`RemediationExecutionStep`](crate::types::RemediationExecutionStep).
     pub fn builder() -> crate::types::builders::RemediationExecutionStepBuilder {
         crate::types::builders::RemediationExecutionStepBuilder::default()
-187
+    }
-188
+}
-189
 /// A builder for [`RemediationExecutionStep`](crate::types::RemediationExecutionStep).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RemediationExecutionStepBuilder {
     pub(crate) name: ::std::option::Option<::std::string::String>,
     pub(crate) state: ::std::option::Option<crate::types::RemediationExecutionStepState>,
     pub(crate) error_message: ::std::option::Option<::std::string::String>,
     pub(crate) start_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) stop_time: ::std::option::Option<::aws_smithy_types::DateTime>,
-199
+}
 impl RemediationExecutionStepBuilder {
     /// <p>The details of the step.</p>
     pub fn name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.name = ::std::option::Option::Some(input.into());
         self
-205
+    }
     /// <p>The details of the step.</p>
     pub fn set_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.name = input;
         self
-210
+    }
     /// <p>The details of the step.</p>
     pub fn get_name(&self) -> &::std::option::Option<::std::string::String> {

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_remediation_parameter_value.rs

@@ -4,4 +132,143 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct RemediationParameterValue {
     /// <p>The value is dynamic and changes at run-time.</p>
     pub resource_value: ::std::option::Option<crate::types::ResourceValue>,
     /// <p>The value is static and does not change at run-time.</p>
     pub static_value: ::std::option::Option<crate::types::StaticValue>,
-11
+}
 impl RemediationParameterValue {
     /// <p>The value is dynamic and changes at run-time.</p>
     pub fn resource_value(&self) -> ::std::option::Option<&crate::types::ResourceValue> {
         self.resource_value.as_ref()
-16
+    }
     /// <p>The value is static and does not change at run-time.</p>
     pub fn static_value(&self) -> ::std::option::Option<&crate::types::StaticValue> {
         self.static_value.as_ref()
-20
+    }
-21
+}
 static REMEDIATIONPARAMETERVALUE_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.configservice#RemediationParameterValue",

     "com.amazonaws.configservice",
     "RemediationParameterValue",
 );
 static REMEDIATIONPARAMETERVALUE_MEMBER_RESOURCE_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationParameterValue$ResourceValue",
         "com.amazonaws.configservice",
         "RemediationParameterValue",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "resource_value",
     "ResourceValue",
 ,
 );
 static REMEDIATIONPARAMETERVALUE_MEMBER_STATIC_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#RemediationParameterValue$StaticValue",
         "com.amazonaws.configservice",
         "RemediationParameterValue",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "static_value",
     "StaticValue",
 ,
 );
 static REMEDIATIONPARAMETERVALUE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     REMEDIATIONPARAMETERVALUE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &REMEDIATIONPARAMETERVALUE_MEMBER_RESOURCE_VALUE,
         &REMEDIATIONPARAMETERVALUE_MEMBER_STATIC_VALUE,
     ],
 );
 impl RemediationParameterValue {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &REMEDIATIONPARAMETERVALUE_SCHEMA;
-58
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RemediationParameterValue {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.resource_value {
             ser.write_struct(&REMEDIATIONPARAMETERVALUE_MEMBER_RESOURCE_VALUE, val)?;
-67
+        }
         if let Some(ref val) = self.static_value {
             ser.write_struct(&REMEDIATIONPARAMETERVALUE_MEMBER_STATIC_VALUE, val)?;
-70
+        }
         Ok(())
-72
+    }
-73
+}
 impl RemediationParameterValue {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&REMEDIATIONPARAMETERVALUE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&REMEDIATIONPARAMETERVALUE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.resource_value = Some(crate::types::ResourceValue::deserialize(deser)?);
-92
+                }
                 Some(1) => {
                     builder.static_value = Some(crate::types::StaticValue::deserialize(deser)?);
-95
+                }
                 _ => {}
-97
+            }
             Ok(())
         })?;
         Ok(builder.build())
-101
+    }
-102
+}
 impl RemediationParameterValue {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl RemediationParameterValue {
     /// Creates a new builder-style object to manufacture [`RemediationParameterValue`](crate::types::RemediationParameterValue).
     pub fn builder() -> crate::types::builders::RemediationParameterValueBuilder {
         crate::types::builders::RemediationParameterValueBuilder::default()
-118
+    }
-119
+}
-120
 /// A builder for [`RemediationParameterValue`](crate::types::RemediationParameterValue).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RemediationParameterValueBuilder {
     pub(crate) resource_value: ::std::option::Option<crate::types::ResourceValue>,
     pub(crate) static_value: ::std::option::Option<crate::types::StaticValue>,
-127
+}
 impl RemediationParameterValueBuilder {
     /// <p>The value is dynamic and changes at run-time.</p>
     pub fn resource_value(mut self, input: crate::types::ResourceValue) -> Self {
         self.resource_value = ::std::option::Option::Some(input);
         self
-133
+    }
     /// <p>The value is dynamic and changes at run-time.</p>
     pub fn set_resource_value(mut self, input: ::std::option::Option<crate::types::ResourceValue>) -> Self {
         self.resource_value = input;
         self
-138
+    }
     /// <p>The value is dynamic and changes at run-time.</p>
     pub fn get_resource_value(&self) -> &::std::option::Option<crate::types::ResourceValue> {
         &self.resource_value
-142
+    }
     /// <p>The value is static and does not change at run-time.</p>

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_resource_count.rs

@@ -4,4 +130,141 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ResourceCount {
     /// <p>The resource type (for example, <code>"AWS::EC2::Instance"</code>).</p>
     pub resource_type: ::std::option::Option<crate::types::ResourceType>,
     /// <p>The number of resources.</p>
     pub count: i64,
-11
+}
 impl ResourceCount {
     /// <p>The resource type (for example, <code>"AWS::EC2::Instance"</code>).</p>
     pub fn resource_type(&self) -> ::std::option::Option<&crate::types::ResourceType> {
         self.resource_type.as_ref()
-16
+    }
     /// <p>The number of resources.</p>
     pub fn count(&self) -> i64 {
         self.count
-20
+    }
-21
+}
 static RESOURCECOUNT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.configservice#ResourceCount",

     "com.amazonaws.configservice",
     "ResourceCount",
 );
 static RESOURCECOUNT_MEMBER_RESOURCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#ResourceCount$resourceType",
         "com.amazonaws.configservice",
         "ResourceCount",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_type",
     "resourceType",
 ,
 );
 static RESOURCECOUNT_MEMBER_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#ResourceCount$count",
         "com.amazonaws.configservice",
         "ResourceCount",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "count",
 ,
 );
 static RESOURCECOUNT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RESOURCECOUNT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&RESOURCECOUNT_MEMBER_RESOURCE_TYPE, &RESOURCECOUNT_MEMBER_COUNT],
 );
 impl ResourceCount {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESOURCECOUNT_SCHEMA;
-55
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ResourceCount {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.resource_type {
             ser.write_string(&RESOURCECOUNT_MEMBER_RESOURCE_TYPE, val.as_str())?;
-64
+        }
-65
+        {
             let val = &self.count;
             ser.write_long(&RESOURCECOUNT_MEMBER_COUNT, *val)?;
-68
+        }
         Ok(())
-70
+    }
-71
+}
 impl ResourceCount {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&RESOURCECOUNT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RESOURCECOUNT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.resource_type = Some(crate::types::ResourceType::from(deser.read_string(member)?.as_str()));
-90
+                }
                 Some(1) => {
                     builder.count = Some(deser.read_long(member)?);
-93
+                }
                 _ => {}
-95
+            }
             Ok(())
         })?;
         Ok(builder.build())
-99
+    }
-100
+}
 impl ResourceCount {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ResourceCount {
     /// Creates a new builder-style object to manufacture [`ResourceCount`](crate::types::ResourceCount).
     pub fn builder() -> crate::types::builders::ResourceCountBuilder {
         crate::types::builders::ResourceCountBuilder::default()
-116
+    }
-117
+}
-118
 /// A builder for [`ResourceCount`](crate::types::ResourceCount).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ResourceCountBuilder {
     pub(crate) resource_type: ::std::option::Option<crate::types::ResourceType>,
     pub(crate) count: ::std::option::Option<i64>,
-125
+}
 impl ResourceCountBuilder {
     /// <p>The resource type (for example, <code>"AWS::EC2::Instance"</code>).</p>
     pub fn resource_type(mut self, input: crate::types::ResourceType) -> Self {
         self.resource_type = ::std::option::Option::Some(input);
         self
-131
+    }
     /// <p>The resource type (for example, <code>"AWS::EC2::Instance"</code>).</p>
     pub fn set_resource_type(mut self, input: ::std::option::Option<crate::types::ResourceType>) -> Self {
         self.resource_type = input;
         self
-136
+    }
     /// <p>The resource type (for example, <code>"AWS::EC2::Instance"</code>).</p>
     pub fn get_resource_type(&self) -> &::std::option::Option<crate::types::ResourceType> {
         &self.resource_type
-140
+    }
     /// <p>The number of resources.</p>

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_resource_count_filters.rs

@@ -10,10 +155,166 @@

↥ Expand context

     pub account_id: ::std::option::Option<::std::string::String>,
     /// <p>The region where the account is located.</p>
     pub region: ::std::option::Option<::std::string::String>,
-13
+}
 impl ResourceCountFilters {
     /// <p>The type of the Amazon Web Services resource.</p>
     pub fn resource_type(&self) -> ::std::option::Option<&crate::types::ResourceType> {
         self.resource_type.as_ref()
-18
+    }
     /// <p>The 12-digit ID of the account.</p>
     pub fn account_id(&self) -> ::std::option::Option<&str> {
         self.account_id.as_deref()
-22
+    }
     /// <p>The region where the account is located.</p>
     pub fn region(&self) -> ::std::option::Option<&str> {
         self.region.as_deref()
-26
+    }
-27
+}
 static RESOURCECOUNTFILTERS_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.configservice#ResourceCountFilters",

     "com.amazonaws.configservice",
     "ResourceCountFilters",
 );
 static RESOURCECOUNTFILTERS_MEMBER_RESOURCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#ResourceCountFilters$ResourceType",
         "com.amazonaws.configservice",
         "ResourceCountFilters",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_type",
     "ResourceType",
 ,
 );
 static RESOURCECOUNTFILTERS_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#ResourceCountFilters$AccountId",
         "com.amazonaws.configservice",
         "ResourceCountFilters",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "account_id",
     "AccountId",
 ,
 );
 static RESOURCECOUNTFILTERS_MEMBER_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#ResourceCountFilters$Region",
         "com.amazonaws.configservice",
         "ResourceCountFilters",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "region",
     "Region",
 ,
 );
 static RESOURCECOUNTFILTERS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RESOURCECOUNTFILTERS_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &RESOURCECOUNTFILTERS_MEMBER_RESOURCE_TYPE,
         &RESOURCECOUNTFILTERS_MEMBER_ACCOUNT_ID,
         &RESOURCECOUNTFILTERS_MEMBER_REGION,
     ],
 );
 impl ResourceCountFilters {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESOURCECOUNTFILTERS_SCHEMA;
-75
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ResourceCountFilters {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.resource_type {
             ser.write_string(&RESOURCECOUNTFILTERS_MEMBER_RESOURCE_TYPE, val.as_str())?;
-84
+        }
         if let Some(ref val) = self.account_id {
             ser.write_string(&RESOURCECOUNTFILTERS_MEMBER_ACCOUNT_ID, val)?;
-87
+        }
         if let Some(ref val) = self.region {
             ser.write_string(&RESOURCECOUNTFILTERS_MEMBER_REGION, val)?;
-90
+        }
         Ok(())
-92
+    }
-93
+}
 impl ResourceCountFilters {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&RESOURCECOUNTFILTERS_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RESOURCECOUNTFILTERS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.resource_type = Some(crate::types::ResourceType::from(deser.read_string(member)?.as_str()));
-112
+                }
                 Some(1) => {
                     builder.account_id = Some(deser.read_string(member)?);
-115
+                }
                 Some(2) => {
                     builder.region = Some(deser.read_string(member)?);
-118
+                }
                 _ => {}
-120
+            }
             Ok(())
         })?;
         Ok(builder.build())
-124
+    }
-125
+}
 impl ResourceCountFilters {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ResourceCountFilters {
     /// Creates a new builder-style object to manufacture [`ResourceCountFilters`](crate::types::ResourceCountFilters).
     pub fn builder() -> crate::types::builders::ResourceCountFiltersBuilder {
         crate::types::builders::ResourceCountFiltersBuilder::default()
-141
+    }
-142
+}
-143
 /// A builder for [`ResourceCountFilters`](crate::types::ResourceCountFilters).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ResourceCountFiltersBuilder {
     pub(crate) resource_type: ::std::option::Option<crate::types::ResourceType>,
     pub(crate) account_id: ::std::option::Option<::std::string::String>,
     pub(crate) region: ::std::option::Option<::std::string::String>,
-151
+}
 impl ResourceCountFiltersBuilder {
     /// <p>The type of the Amazon Web Services resource.</p>
     pub fn resource_type(mut self, input: crate::types::ResourceType) -> Self {
         self.resource_type = ::std::option::Option::Some(input);
         self
-157
+    }
     /// <p>The type of the Amazon Web Services resource.</p>
     pub fn set_resource_type(mut self, input: ::std::option::Option<crate::types::ResourceType>) -> Self {
         self.resource_type = input;
         self
-162
+    }
     /// <p>The type of the Amazon Web Services resource.</p>
     pub fn get_resource_type(&self) -> &::std::option::Option<crate::types::ResourceType> {
         &self.resource_type
-166
+    }

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_resource_details.rs

@@ -25,25 +193,207 @@

↥ Expand context

     /// <p>The type of resource being evaluated.</p>
     pub fn resource_type(&self) -> &str {
         use std::ops::Deref;
         self.resource_type.deref()
-29
+    }
     /// <p>The resource definition to be evaluated as per the resource configuration schema type.</p>
     pub fn resource_configuration(&self) -> &str {
         use std::ops::Deref;
         self.resource_configuration.deref()
-34
+    }
     /// <p>The schema type of the resource configuration.</p><note>
     /// <p>You can find the <a href="https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/resource-type-schema.html">Resource type schema</a>, or <code>CFN_RESOURCE_SCHEMA</code>, in "<i>Amazon Web Services public extensions</i>" within the CloudFormation registry or with the following CLI commmand: <code>aws cloudformation describe-type --type-name "AWS::S3::Bucket" --type RESOURCE</code>.</p>
     /// <p>For more information, see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry.html#registry-view">Managing extensions through the CloudFormation registry</a> and <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html">Amazon Web Services resource and property types reference</a> in the CloudFormation User Guide.</p>
     /// </note>
     pub fn resource_configuration_schema_type(&self) -> ::std::option::Option<&crate::types::ResourceConfigurationSchemaType> {
         self.resource_configuration_schema_type.as_ref()
-41
+    }
-42
+}
 static RESOURCEDETAILS_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.configservice#ResourceDetails",

     "com.amazonaws.configservice",
     "ResourceDetails",
 );
 static RESOURCEDETAILS_MEMBER_RESOURCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#ResourceDetails$ResourceId",
         "com.amazonaws.configservice",
         "ResourceDetails",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_id",
     "ResourceId",
 ,
 );
 static RESOURCEDETAILS_MEMBER_RESOURCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#ResourceDetails$ResourceType",
         "com.amazonaws.configservice",
         "ResourceDetails",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_type",
     "ResourceType",
 ,
 );
 static RESOURCEDETAILS_MEMBER_RESOURCE_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#ResourceDetails$ResourceConfiguration",
         "com.amazonaws.configservice",
         "ResourceDetails",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_configuration",
     "ResourceConfiguration",
 ,
 );
 static RESOURCEDETAILS_MEMBER_RESOURCE_CONFIGURATION_SCHEMA_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#ResourceDetails$ResourceConfigurationSchemaType",
         "com.amazonaws.configservice",
         "ResourceDetails",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_configuration_schema_type",
     "ResourceConfigurationSchemaType",
 ,
 );
 static RESOURCEDETAILS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RESOURCEDETAILS_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &RESOURCEDETAILS_MEMBER_RESOURCE_ID,
         &RESOURCEDETAILS_MEMBER_RESOURCE_TYPE,
         &RESOURCEDETAILS_MEMBER_RESOURCE_CONFIGURATION,
         &RESOURCEDETAILS_MEMBER_RESOURCE_CONFIGURATION_SCHEMA_TYPE,
     ],
 );
 impl ResourceDetails {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESOURCEDETAILS_SCHEMA;
-101
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ResourceDetails {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
-108
+        {
             let val = &self.resource_id;
             ser.write_string(&RESOURCEDETAILS_MEMBER_RESOURCE_ID, val)?;
-111
+        }
-112
+        {
             let val = &self.resource_type;
             ser.write_string(&RESOURCEDETAILS_MEMBER_RESOURCE_TYPE, val)?;
-115
+        }
-116
+        {
             let val = &self.resource_configuration;
             ser.write_string(&RESOURCEDETAILS_MEMBER_RESOURCE_CONFIGURATION, val)?;
-119
+        }
         if let Some(ref val) = self.resource_configuration_schema_type {
             ser.write_string(&RESOURCEDETAILS_MEMBER_RESOURCE_CONFIGURATION_SCHEMA_TYPE, val.as_str())?;
-122
+        }
         Ok(())
-124
+    }
-125
+}
 impl ResourceDetails {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&RESOURCEDETAILS_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RESOURCEDETAILS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.resource_id = Some(deser.read_string(member)?);
-144
+                }
                 Some(1) => {
                     builder.resource_type = Some(deser.read_string(member)?);
-147
+                }
                 Some(2) => {
                     builder.resource_configuration = Some(deser.read_string(member)?);
-150
+                }
                 Some(3) => {
                     builder.resource_configuration_schema_type =
                         Some(crate::types::ResourceConfigurationSchemaType::from(deser.read_string(member)?.as_str()));
-154
+                }
                 _ => {}
-156
+            }
             Ok(())
         })?;
         builder.resource_id = builder.resource_id.or(Some(String::new()));
         builder.resource_type = builder.resource_type.or(Some(String::new()));
         builder.resource_configuration = builder.resource_configuration.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-165
+    }
-166
+}
 impl ResourceDetails {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ResourceDetails {
     /// Creates a new builder-style object to manufacture [`ResourceDetails`](crate::types::ResourceDetails).
     pub fn builder() -> crate::types::builders::ResourceDetailsBuilder {
         crate::types::builders::ResourceDetailsBuilder::default()
-182
+    }
-183
+}
-184
 /// A builder for [`ResourceDetails`](crate::types::ResourceDetails).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ResourceDetailsBuilder {
     pub(crate) resource_id: ::std::option::Option<::std::string::String>,
     pub(crate) resource_type: ::std::option::Option<::std::string::String>,
     pub(crate) resource_configuration: ::std::option::Option<::std::string::String>,
     pub(crate) resource_configuration_schema_type: ::std::option::Option<crate::types::ResourceConfigurationSchemaType>,
-193
+}
 impl ResourceDetailsBuilder {
     /// <p>A unique resource ID for an evaluation.</p>
     /// This field is required.
     pub fn resource_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.resource_id = ::std::option::Option::Some(input.into());
         self
-200
+    }
     /// <p>A unique resource ID for an evaluation.</p>
     pub fn set_resource_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.resource_id = input;
         self
-205
+    }
     /// <p>A unique resource ID for an evaluation.</p>
     pub fn get_resource_id(&self) -> &::std::option::Option<::std::string::String> {

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_resource_evaluation.rs

@@ -10,10 +155,166 @@

↥ Expand context

     pub evaluation_mode: ::std::option::Option<crate::types::EvaluationMode>,
     /// <p>The starting time of an execution.</p>
     pub evaluation_start_timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
-13
+}
 impl ResourceEvaluation {
     /// <p>The ResourceEvaluationId of a evaluation.</p>
     pub fn resource_evaluation_id(&self) -> ::std::option::Option<&str> {
         self.resource_evaluation_id.as_deref()
-18
+    }
     /// <p>The mode of an evaluation. The valid values are Detective or Proactive.</p>
     pub fn evaluation_mode(&self) -> ::std::option::Option<&crate::types::EvaluationMode> {
         self.evaluation_mode.as_ref()
-22
+    }
     /// <p>The starting time of an execution.</p>
     pub fn evaluation_start_timestamp(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.evaluation_start_timestamp.as_ref()
-26
+    }
-27
+}
 static RESOURCEEVALUATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.configservice#ResourceEvaluation",

     "com.amazonaws.configservice",
     "ResourceEvaluation",
 );
 static RESOURCEEVALUATION_MEMBER_RESOURCE_EVALUATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#ResourceEvaluation$ResourceEvaluationId",
         "com.amazonaws.configservice",
         "ResourceEvaluation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_evaluation_id",
     "ResourceEvaluationId",
 ,
 );
 static RESOURCEEVALUATION_MEMBER_EVALUATION_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#ResourceEvaluation$EvaluationMode",
         "com.amazonaws.configservice",
         "ResourceEvaluation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "evaluation_mode",
     "EvaluationMode",
 ,
 );
 static RESOURCEEVALUATION_MEMBER_EVALUATION_START_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#ResourceEvaluation$EvaluationStartTimestamp",
         "com.amazonaws.configservice",
         "ResourceEvaluation",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "evaluation_start_timestamp",
     "EvaluationStartTimestamp",
 ,
 );
 static RESOURCEEVALUATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RESOURCEEVALUATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &RESOURCEEVALUATION_MEMBER_RESOURCE_EVALUATION_ID,
         &RESOURCEEVALUATION_MEMBER_EVALUATION_MODE,
         &RESOURCEEVALUATION_MEMBER_EVALUATION_START_TIMESTAMP,
     ],
 );
 impl ResourceEvaluation {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESOURCEEVALUATION_SCHEMA;
-75
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ResourceEvaluation {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.resource_evaluation_id {
             ser.write_string(&RESOURCEEVALUATION_MEMBER_RESOURCE_EVALUATION_ID, val)?;
-84
+        }
         if let Some(ref val) = self.evaluation_mode {
             ser.write_string(&RESOURCEEVALUATION_MEMBER_EVALUATION_MODE, val.as_str())?;
-87
+        }
         if let Some(ref val) = self.evaluation_start_timestamp {
             ser.write_timestamp(&RESOURCEEVALUATION_MEMBER_EVALUATION_START_TIMESTAMP, val)?;
-90
+        }
         Ok(())
-92
+    }
-93
+}
 impl ResourceEvaluation {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&RESOURCEEVALUATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RESOURCEEVALUATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.resource_evaluation_id = Some(deser.read_string(member)?);
-112
+                }
                 Some(1) => {
                     builder.evaluation_mode = Some(crate::types::EvaluationMode::from(deser.read_string(member)?.as_str()));
-115
+                }
                 Some(2) => {
                     builder.evaluation_start_timestamp = Some(deser.read_timestamp(member)?);
-118
+                }
                 _ => {}
-120
+            }
             Ok(())
         })?;
         Ok(builder.build())
-124
+    }
-125
+}
 impl ResourceEvaluation {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ResourceEvaluation {
     /// Creates a new builder-style object to manufacture [`ResourceEvaluation`](crate::types::ResourceEvaluation).
     pub fn builder() -> crate::types::builders::ResourceEvaluationBuilder {
         crate::types::builders::ResourceEvaluationBuilder::default()
-141
+    }
-142
+}
-143
 /// A builder for [`ResourceEvaluation`](crate::types::ResourceEvaluation).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ResourceEvaluationBuilder {
     pub(crate) resource_evaluation_id: ::std::option::Option<::std::string::String>,
     pub(crate) evaluation_mode: ::std::option::Option<crate::types::EvaluationMode>,
     pub(crate) evaluation_start_timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
-151
+}
 impl ResourceEvaluationBuilder {
     /// <p>The ResourceEvaluationId of a evaluation.</p>
     pub fn resource_evaluation_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.resource_evaluation_id = ::std::option::Option::Some(input.into());
         self
-157
+    }
     /// <p>The ResourceEvaluationId of a evaluation.</p>
     pub fn set_resource_evaluation_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.resource_evaluation_id = input;
         self
-162
+    }
     /// <p>The ResourceEvaluationId of a evaluation.</p>
     pub fn get_resource_evaluation_id(&self) -> &::std::option::Option<::std::string::String> {
         &self.resource_evaluation_id
-166
+    }

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_resource_evaluation_filters.rs

@@ -14,14 +159,170 @@

↥ Expand context

     pub evaluation_context_identifier: ::std::option::Option<::std::string::String>,
-15
+}
 impl ResourceEvaluationFilters {
     /// <p>Filters all resource evaluations results based on an evaluation mode.</p><important>
     /// <p>Currently, <code>DECTECTIVE</code> is not supported as a valid value. Ignore other documentation stating otherwise.</p>
     /// </important>
     pub fn evaluation_mode(&self) -> ::std::option::Option<&crate::types::EvaluationMode> {
         self.evaluation_mode.as_ref()
-22
+    }
     /// <p>Returns a <code>TimeWindow</code> object.</p>
     pub fn time_window(&self) -> ::std::option::Option<&crate::types::TimeWindow> {
         self.time_window.as_ref()
-26
+    }
     /// <p>Filters evaluations for a given infrastructure deployment. For example: CFN Stack.</p>
     pub fn evaluation_context_identifier(&self) -> ::std::option::Option<&str> {
         self.evaluation_context_identifier.as_deref()
-30
+    }
-31
+}
 static RESOURCEEVALUATIONFILTERS_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.configservice#ResourceEvaluationFilters",

     "com.amazonaws.configservice",
     "ResourceEvaluationFilters",
 );
 static RESOURCEEVALUATIONFILTERS_MEMBER_EVALUATION_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#ResourceEvaluationFilters$EvaluationMode",
         "com.amazonaws.configservice",
         "ResourceEvaluationFilters",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "evaluation_mode",
     "EvaluationMode",
 ,
 );
 static RESOURCEEVALUATIONFILTERS_MEMBER_TIME_WINDOW: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#ResourceEvaluationFilters$TimeWindow",
         "com.amazonaws.configservice",
         "ResourceEvaluationFilters",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "time_window",
     "TimeWindow",
 ,
 );
 static RESOURCEEVALUATIONFILTERS_MEMBER_EVALUATION_CONTEXT_IDENTIFIER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice#ResourceEvaluationFilters$EvaluationContextIdentifier",
         "com.amazonaws.configservice",
         "ResourceEvaluationFilters",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "evaluation_context_identifier",
     "EvaluationContextIdentifier",
 ,
 );
 static RESOURCEEVALUATIONFILTERS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RESOURCEEVALUATIONFILTERS_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &RESOURCEEVALUATIONFILTERS_MEMBER_EVALUATION_MODE,
         &RESOURCEEVALUATIONFILTERS_MEMBER_TIME_WINDOW,
         &RESOURCEEVALUATIONFILTERS_MEMBER_EVALUATION_CONTEXT_IDENTIFIER,
     ],
 );
 impl ResourceEvaluationFilters {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESOURCEEVALUATIONFILTERS_SCHEMA;
-79
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ResourceEvaluationFilters {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.evaluation_mode {
             ser.write_string(&RESOURCEEVALUATIONFILTERS_MEMBER_EVALUATION_MODE, val.as_str())?;
-88
+        }
         if let Some(ref val) = self.time_window {
             ser.write_struct(&RESOURCEEVALUATIONFILTERS_MEMBER_TIME_WINDOW, val)?;
-91
+        }
         if let Some(ref val) = self.evaluation_context_identifier {
             ser.write_string(&RESOURCEEVALUATIONFILTERS_MEMBER_EVALUATION_CONTEXT_IDENTIFIER, val)?;
-94
+        }
         Ok(())
-96
+    }
-97
+}
 impl ResourceEvaluationFilters {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&RESOURCEEVALUATIONFILTERS_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RESOURCEEVALUATIONFILTERS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.evaluation_mode = Some(crate::types::EvaluationMode::from(deser.read_string(member)?.as_str()));
-116
+                }
                 Some(1) => {
                     builder.time_window = Some(crate::types::TimeWindow::deserialize(deser)?);
-119
+                }
                 Some(2) => {
                     builder.evaluation_context_identifier = Some(deser.read_string(member)?);
-122
+                }
                 _ => {}
-124
+            }
             Ok(())
         })?;
         Ok(builder.build())
-128
+    }
-129
+}
 impl ResourceEvaluationFilters {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ResourceEvaluationFilters {
     /// Creates a new builder-style object to manufacture [`ResourceEvaluationFilters`](crate::types::ResourceEvaluationFilters).
     pub fn builder() -> crate::types::builders::ResourceEvaluationFiltersBuilder {
         crate::types::builders::ResourceEvaluationFiltersBuilder::default()
-145
+    }
-146
+}
-147
 /// A builder for [`ResourceEvaluationFilters`](crate::types::ResourceEvaluationFilters).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ResourceEvaluationFiltersBuilder {
     pub(crate) evaluation_mode: ::std::option::Option<crate::types::EvaluationMode>,
     pub(crate) time_window: ::std::option::Option<crate::types::TimeWindow>,
     pub(crate) evaluation_context_identifier: ::std::option::Option<::std::string::String>,
-155
+}
 impl ResourceEvaluationFiltersBuilder {
     /// <p>Filters all resource evaluations results based on an evaluation mode.</p><important>
     /// <p>Currently, <code>DECTECTIVE</code> is not supported as a valid value. Ignore other documentation stating otherwise.</p>
     /// </important>
     pub fn evaluation_mode(mut self, input: crate::types::EvaluationMode) -> Self {
         self.evaluation_mode = ::std::option::Option::Some(input);
         self
-163
+    }
     /// <p>Filters all resource evaluations results based on an evaluation mode.</p><important>
     /// <p>Currently, <code>DECTECTIVE</code> is not supported as a valid value. Ignore other documentation stating otherwise.</p>
     /// </important>
     pub fn set_evaluation_mode(mut self, input: ::std::option::Option<crate::types::EvaluationMode>) -> Self {
         self.evaluation_mode = input;
         self
-170
+    }

AWS SDK

Files changed: