144 150 | crate::operation::get_conformance_pack_compliance_details::GetConformancePackComplianceDetailsError,
|
145 151 | >::new());
|
146 152 |
|
147 153 | ::std::borrow::Cow::Owned(rcb)
|
148 154 | }
|
149 155 | }
|
150 156 |
|
151 157 | #[derive(Debug)]
|
152 158 | struct GetConformancePackComplianceDetailsResponseDeserializer;
|
153 159 | impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetConformancePackComplianceDetailsResponseDeserializer {
|
154 - | fn deserialize_nonstreaming(
|
160 + | fn deserialize_nonstreaming_with_config(
|
155 161 | &self,
|
156 162 | response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
|
163 + | _cfg: &::aws_smithy_types::config_bag::ConfigBag,
|
157 164 | ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
|
158 165 | let (success, status) = (response.status().is_success(), response.status().as_u16());
|
159 - | let headers = response.headers();
|
160 - | let body = response.body().bytes().expect("body loaded");
|
161 166 | #[allow(unused_mut)]
|
162 167 | let mut force_error = false;
|
163 168 | ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
|
164 - | let parse_result = if !success && status != 200 || force_error {
|
165 - | crate::protocol_serde::shape_get_conformance_pack_compliance_details::de_get_conformance_pack_compliance_details_http_error(
|
166 - | status, headers, body,
|
167 - | )
|
169 + | if !success && status != 200 || force_error {
|
170 + | let headers = response.headers();
|
171 + | let body = response.body().bytes().expect("body loaded");
|
172 + | #[allow(unused_mut)]
|
173 + | let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
|
174 + | ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
|
175 + | })?;
|
176 + | generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
|
177 + | let generic = generic_builder.build();
|
178 + | let error_code = match generic.code() {
|
179 + | ::std::option::Option::Some(code) => code,
|
180 + | ::std::option::Option::None => {
|
181 + | return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
|
182 + | ::aws_smithy_runtime_api::box_error::BoxError::from(
|
183 + | crate::operation::get_conformance_pack_compliance_details::GetConformancePackComplianceDetailsError::unhandled(generic),
|
184 + | ),
|
185 + | ))
|
186 + | }
|
187 + | };
|
188 + | let _error_message = generic.message().map(|msg| msg.to_owned());
|
189 + | let protocol = _cfg
|
190 + | .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
|
191 + | .expect("a SharedClientProtocol is required");
|
192 + | let err = match error_code {
|
193 + | "InvalidLimitException" => crate::operation::get_conformance_pack_compliance_details::GetConformancePackComplianceDetailsError::InvalidLimitException({
|
194 + | let mut tmp = match protocol.deserialize_response(response, crate::types::error::InvalidLimitException::SCHEMA, _cfg)
|
195 + | .and_then(|mut deser| crate::types::error::InvalidLimitException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
|
196 + | {
|
197 + | ::std::result::Result::Ok(val) => val,
|
198 + | ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
|
199 + | };
|
200 + | tmp.meta = generic;
|
201 + | if tmp.message.is_none() {
|
202 + | tmp.message = _error_message;
|
203 + | }
|
204 + | tmp
|
205 + | }),
|
206 + | "InvalidNextTokenException" => crate::operation::get_conformance_pack_compliance_details::GetConformancePackComplianceDetailsError::InvalidNextTokenException({
|
207 + | let mut tmp = match protocol.deserialize_response(response, crate::types::error::InvalidNextTokenException::SCHEMA, _cfg)
|
208 + | .and_then(|mut deser| crate::types::error::InvalidNextTokenException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
|
209 + | {
|
210 + | ::std::result::Result::Ok(val) => val,
|
211 + | ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
|
212 + | };
|
213 + | tmp.meta = generic;
|
214 + | if tmp.message.is_none() {
|
215 + | tmp.message = _error_message;
|
216 + | }
|
217 + | tmp
|
218 + | }),
|
219 + | "InvalidParameterValueException" => crate::operation::get_conformance_pack_compliance_details::GetConformancePackComplianceDetailsError::InvalidParameterValueException({
|
220 + | let mut tmp = match protocol.deserialize_response(response, crate::types::error::InvalidParameterValueException::SCHEMA, _cfg)
|
221 + | .and_then(|mut deser| crate::types::error::InvalidParameterValueException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
|
222 + | {
|
223 + | ::std::result::Result::Ok(val) => val,
|
224 + | ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
|
225 + | };
|
226 + | tmp.meta = generic;
|
227 + | if tmp.message.is_none() {
|
228 + | tmp.message = _error_message;
|
229 + | }
|
230 + | tmp
|
231 + | }),
|
232 + | "NoSuchConfigRuleInConformancePackException" => crate::operation::get_conformance_pack_compliance_details::GetConformancePackComplianceDetailsError::NoSuchConfigRuleInConformancePackException({
|
233 + | let mut tmp = match protocol.deserialize_response(response, crate::types::error::NoSuchConfigRuleInConformancePackException::SCHEMA, _cfg)
|
234 + | .and_then(|mut deser| crate::types::error::NoSuchConfigRuleInConformancePackException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
|
235 + | {
|
236 + | ::std::result::Result::Ok(val) => val,
|
237 + | ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
|
238 + | };
|
239 + | tmp.meta = generic;
|
240 + | if tmp.message.is_none() {
|
241 + | tmp.message = _error_message;
|
242 + | }
|
243 + | tmp
|
244 + | }),
|
245 + | "NoSuchConformancePackException" => crate::operation::get_conformance_pack_compliance_details::GetConformancePackComplianceDetailsError::NoSuchConformancePackException({
|
246 + | let mut tmp = match protocol.deserialize_response(response, crate::types::error::NoSuchConformancePackException::SCHEMA, _cfg)
|
247 + | .and_then(|mut deser| crate::types::error::NoSuchConformancePackException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
|
248 + | {
|
249 + | ::std::result::Result::Ok(val) => val,
|
250 + | ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
|
251 + | };
|
252 + | tmp.meta = generic;
|
253 + | if tmp.message.is_none() {
|
254 + | tmp.message = _error_message;
|
255 + | }
|
256 + | tmp
|
257 + | }),
|
258 + | _ => crate::operation::get_conformance_pack_compliance_details::GetConformancePackComplianceDetailsError::generic(generic)
|
259 + | };
|
260 + | ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
|
261 + | ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
|
262 + | ))
|
168 263 | } else {
|
169 - | crate::protocol_serde::shape_get_conformance_pack_compliance_details::de_get_conformance_pack_compliance_details_http_response(
|
170 - | status, headers, body,
|
264 + | let protocol = _cfg
|
265 + | .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
|
266 + | .expect("a SharedClientProtocol is required");
|
267 + | let mut deser = protocol
|
268 + | .deserialize_response(response, GetConformancePackComplianceDetails::OUTPUT_SCHEMA, _cfg)
|
269 + | .map_err(|e| {
|
270 + | ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
|
271 + | })?;
|
272 + | let body = response.body().bytes().expect("body loaded");
|
273 + | let output =
|
274 + | crate::operation::get_conformance_pack_compliance_details::GetConformancePackComplianceDetailsOutput::deserialize_with_response(
|
275 + | &mut *deser,
|
276 + | response.headers(),
|
277 + | response.status().into(),
|
278 + | body,
|
171 279 | )
|
172 - | };
|
173 - | crate::protocol_serde::type_erase_result(parse_result)
|
280 + | .map_err(|e| {
|
281 + | ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
|
282 + | })?;
|
283 + | ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
|
284 + | }
|
174 285 | }
|
175 286 | }
|
176 287 | #[derive(Debug)]
|
177 288 | struct GetConformancePackComplianceDetailsRequestSerializer;
|
178 289 | impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetConformancePackComplianceDetailsRequestSerializer {
|
179 290 | #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
|
180 291 | fn serialize_input(
|
181 292 | &self,
|
182 293 | input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
|
183 294 | _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
|
184 295 | ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
|
185 296 | let input = input
|
186 297 | .downcast::<crate::operation::get_conformance_pack_compliance_details::GetConformancePackComplianceDetailsInput>()
|
187 298 | .expect("correct type");
|
188 - | let _header_serialization_settings = _cfg
|
189 - | .load::<crate::serialization_settings::HeaderSerializationSettings>()
|
190 - | .cloned()
|
191 - | .unwrap_or_default();
|
192 - | let mut request_builder = {
|
193 - | #[allow(clippy::uninlined_format_args)]
|
194 - | fn uri_base(
|
195 - | _input: &crate::operation::get_conformance_pack_compliance_details::GetConformancePackComplianceDetailsInput,
|
196 - | output: &mut ::std::string::String,
|
197 - | ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
|
198 - | use ::std::fmt::Write as _;
|
199 - | ::std::write!(output, "/").expect("formatting should succeed");
|
200 - | ::std::result::Result::Ok(())
|
201 - | }
|
202 - | #[allow(clippy::unnecessary_wraps)]
|
203 - | fn update_http_builder(
|
204 - | input: &crate::operation::get_conformance_pack_compliance_details::GetConformancePackComplianceDetailsInput,
|
205 - | builder: ::http_1x::request::Builder,
|
206 - | ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
|
207 - | let mut uri = ::std::string::String::new();
|
208 - | uri_base(input, &mut uri)?;
|
209 - | ::std::result::Result::Ok(builder.method("POST").uri(uri))
|
210 - | }
|
211 - | let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
|
212 - | builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
|
213 - | builder = _header_serialization_settings.set_default_header(
|
214 - | builder,
|
215 - | ::http_1x::header::HeaderName::from_static("x-amz-target"),
|
216 - | "StarlingDoveService.GetConformancePackComplianceDetails",
|
217 - | );
|
218 - | builder
|
219 - | };
|
220 - | let body = ::aws_smithy_types::body::SdkBody::from(
|
221 - | crate::protocol_serde::shape_get_conformance_pack_compliance_details::ser_get_conformance_pack_compliance_details_input(&input)?,
|
222 - | );
|
223 - | if let Some(content_length) = body.content_length() {
|
224 - | let content_length = content_length.to_string();
|
225 - | request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
|
226 - | }
|
227 - | ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
|
299 + | let protocol = _cfg
|
300 + | .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
|
301 + | .expect("a SharedClientProtocol is required");
|
302 + | let mut request = protocol
|
303 + | .serialize_request(&input, GetConformancePackComplianceDetails::INPUT_SCHEMA, "", _cfg)
|
304 + | .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
|
305 + |
|
306 + | return ::std::result::Result::Ok(request);
|
228 307 | }
|
229 308 | }
|
230 309 | #[derive(Debug)]
|
231 310 | struct GetConformancePackComplianceDetailsEndpointParamsInterceptor;
|
232 311 |
|
233 312 | impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetConformancePackComplianceDetailsEndpointParamsInterceptor {
|
234 313 | fn name(&self) -> &'static str {
|
235 314 | "GetConformancePackComplianceDetailsEndpointParamsInterceptor"
|
236 315 | }
|
237 316 |
|