1#[non_exhaustive]
4#[derive(::std::fmt::Debug)]
5pub enum Error {
6 AccessPointNotFoundException(crate::types::error::AccessPointNotFoundException),
8 CertificateNotFoundException(crate::types::error::CertificateNotFoundException),
10 DependencyThrottleException(crate::types::error::DependencyThrottleException),
12 DuplicateAccessPointNameException(crate::types::error::DuplicateAccessPointNameException),
14 DuplicateListenerException(crate::types::error::DuplicateListenerException),
16 DuplicatePolicyNameException(crate::types::error::DuplicatePolicyNameException),
18 DuplicateTagKeysException(crate::types::error::DuplicateTagKeysException),
20 InvalidConfigurationRequestException(crate::types::error::InvalidConfigurationRequestException),
22 InvalidEndPointException(crate::types::error::InvalidEndPointException),
24 InvalidSchemeException(crate::types::error::InvalidSchemeException),
26 InvalidSecurityGroupException(crate::types::error::InvalidSecurityGroupException),
28 InvalidSubnetException(crate::types::error::InvalidSubnetException),
30 ListenerNotFoundException(crate::types::error::ListenerNotFoundException),
32 LoadBalancerAttributeNotFoundException(crate::types::error::LoadBalancerAttributeNotFoundException),
34 OperationNotPermittedException(crate::types::error::OperationNotPermittedException),
36 PolicyNotFoundException(crate::types::error::PolicyNotFoundException),
38 PolicyTypeNotFoundException(crate::types::error::PolicyTypeNotFoundException),
40 SubnetNotFoundException(crate::types::error::SubnetNotFoundException),
42 TooManyAccessPointsException(crate::types::error::TooManyAccessPointsException),
44 TooManyPoliciesException(crate::types::error::TooManyPoliciesException),
46 TooManyTagsException(crate::types::error::TooManyTagsException),
48 UnsupportedProtocolException(crate::types::error::UnsupportedProtocolException),
50 #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
52 variable wildcard pattern and check `.code()`:
53 \
54 `err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
55 \
56 See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-Error) for what information is available for the error.")]
57 Unhandled(crate::error::sealed_unhandled::Unhandled),
58}
59impl ::std::fmt::Display for Error {
60 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
61 match self {
62 Error::AccessPointNotFoundException(inner) => inner.fmt(f),
63 Error::CertificateNotFoundException(inner) => inner.fmt(f),
64 Error::DependencyThrottleException(inner) => inner.fmt(f),
65 Error::DuplicateAccessPointNameException(inner) => inner.fmt(f),
66 Error::DuplicateListenerException(inner) => inner.fmt(f),
67 Error::DuplicatePolicyNameException(inner) => inner.fmt(f),
68 Error::DuplicateTagKeysException(inner) => inner.fmt(f),
69 Error::InvalidConfigurationRequestException(inner) => inner.fmt(f),
70 Error::InvalidEndPointException(inner) => inner.fmt(f),
71 Error::InvalidSchemeException(inner) => inner.fmt(f),
72 Error::InvalidSecurityGroupException(inner) => inner.fmt(f),
73 Error::InvalidSubnetException(inner) => inner.fmt(f),
74 Error::ListenerNotFoundException(inner) => inner.fmt(f),
75 Error::LoadBalancerAttributeNotFoundException(inner) => inner.fmt(f),
76 Error::OperationNotPermittedException(inner) => inner.fmt(f),
77 Error::PolicyNotFoundException(inner) => inner.fmt(f),
78 Error::PolicyTypeNotFoundException(inner) => inner.fmt(f),
79 Error::SubnetNotFoundException(inner) => inner.fmt(f),
80 Error::TooManyAccessPointsException(inner) => inner.fmt(f),
81 Error::TooManyPoliciesException(inner) => inner.fmt(f),
82 Error::TooManyTagsException(inner) => inner.fmt(f),
83 Error::UnsupportedProtocolException(inner) => inner.fmt(f),
84 Error::Unhandled(_) => {
85 if let ::std::option::Option::Some(code) = ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self) {
86 write!(f, "unhandled error ({code})")
87 } else {
88 f.write_str("unhandled error")
89 }
90 }
91 }
92 }
93}
94impl From<::aws_smithy_types::error::operation::BuildError> for Error {
95 fn from(value: ::aws_smithy_types::error::operation::BuildError) -> Self {
96 Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
97 source: value.into(),
98 meta: ::std::default::Default::default(),
99 })
100 }
101}
102impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for Error {
103 fn meta(&self) -> &::aws_smithy_types::error::metadata::ErrorMetadata {
104 match self {
105 Self::AccessPointNotFoundException(inner) => inner.meta(),
106 Self::CertificateNotFoundException(inner) => inner.meta(),
107 Self::DependencyThrottleException(inner) => inner.meta(),
108 Self::DuplicateAccessPointNameException(inner) => inner.meta(),
109 Self::DuplicateListenerException(inner) => inner.meta(),
110 Self::DuplicatePolicyNameException(inner) => inner.meta(),
111 Self::DuplicateTagKeysException(inner) => inner.meta(),
112 Self::InvalidConfigurationRequestException(inner) => inner.meta(),
113 Self::InvalidEndPointException(inner) => inner.meta(),
114 Self::InvalidSchemeException(inner) => inner.meta(),
115 Self::InvalidSecurityGroupException(inner) => inner.meta(),
116 Self::InvalidSubnetException(inner) => inner.meta(),
117 Self::ListenerNotFoundException(inner) => inner.meta(),
118 Self::LoadBalancerAttributeNotFoundException(inner) => inner.meta(),
119 Self::OperationNotPermittedException(inner) => inner.meta(),
120 Self::PolicyNotFoundException(inner) => inner.meta(),
121 Self::PolicyTypeNotFoundException(inner) => inner.meta(),
122 Self::SubnetNotFoundException(inner) => inner.meta(),
123 Self::TooManyAccessPointsException(inner) => inner.meta(),
124 Self::TooManyPoliciesException(inner) => inner.meta(),
125 Self::TooManyTagsException(inner) => inner.meta(),
126 Self::UnsupportedProtocolException(inner) => inner.meta(),
127 Self::Unhandled(inner) => &inner.meta,
128 }
129 }
130}
131impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::add_tags::AddTagsError, R>> for Error
132where
133 R: Send + Sync + std::fmt::Debug + 'static,
134{
135 fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::add_tags::AddTagsError, R>) -> Self {
136 match err {
137 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
138 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
139 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
140 source: err.into(),
141 }),
142 }
143 }
144}
145impl From<crate::operation::add_tags::AddTagsError> for Error {
146 fn from(err: crate::operation::add_tags::AddTagsError) -> Self {
147 match err {
148 crate::operation::add_tags::AddTagsError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
149 crate::operation::add_tags::AddTagsError::DuplicateTagKeysException(inner) => Error::DuplicateTagKeysException(inner),
150 crate::operation::add_tags::AddTagsError::TooManyTagsException(inner) => Error::TooManyTagsException(inner),
151 crate::operation::add_tags::AddTagsError::Unhandled(inner) => Error::Unhandled(inner),
152 }
153 }
154}
155impl<R>
156 From<
157 ::aws_smithy_runtime_api::client::result::SdkError<
158 crate::operation::apply_security_groups_to_load_balancer::ApplySecurityGroupsToLoadBalancerError,
159 R,
160 >,
161 > for Error
162where
163 R: Send + Sync + std::fmt::Debug + 'static,
164{
165 fn from(
166 err: ::aws_smithy_runtime_api::client::result::SdkError<
167 crate::operation::apply_security_groups_to_load_balancer::ApplySecurityGroupsToLoadBalancerError,
168 R,
169 >,
170 ) -> Self {
171 match err {
172 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
173 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
174 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
175 source: err.into(),
176 }),
177 }
178 }
179}
180impl From<crate::operation::apply_security_groups_to_load_balancer::ApplySecurityGroupsToLoadBalancerError> for Error {
181 fn from(err: crate::operation::apply_security_groups_to_load_balancer::ApplySecurityGroupsToLoadBalancerError) -> Self {
182 match err {
183 crate::operation::apply_security_groups_to_load_balancer::ApplySecurityGroupsToLoadBalancerError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
184 crate::operation::apply_security_groups_to_load_balancer::ApplySecurityGroupsToLoadBalancerError::InvalidConfigurationRequestException(inner) => Error::InvalidConfigurationRequestException(inner),
185 crate::operation::apply_security_groups_to_load_balancer::ApplySecurityGroupsToLoadBalancerError::InvalidSecurityGroupException(inner) => Error::InvalidSecurityGroupException(inner),
186 crate::operation::apply_security_groups_to_load_balancer::ApplySecurityGroupsToLoadBalancerError::Unhandled(inner) => Error::Unhandled(inner),
187 }
188 }
189}
190impl<R>
191 From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::attach_load_balancer_to_subnets::AttachLoadBalancerToSubnetsError, R>>
192 for Error
193where
194 R: Send + Sync + std::fmt::Debug + 'static,
195{
196 fn from(
197 err: ::aws_smithy_runtime_api::client::result::SdkError<
198 crate::operation::attach_load_balancer_to_subnets::AttachLoadBalancerToSubnetsError,
199 R,
200 >,
201 ) -> Self {
202 match err {
203 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
204 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
205 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
206 source: err.into(),
207 }),
208 }
209 }
210}
211impl From<crate::operation::attach_load_balancer_to_subnets::AttachLoadBalancerToSubnetsError> for Error {
212 fn from(err: crate::operation::attach_load_balancer_to_subnets::AttachLoadBalancerToSubnetsError) -> Self {
213 match err {
214 crate::operation::attach_load_balancer_to_subnets::AttachLoadBalancerToSubnetsError::AccessPointNotFoundException(inner) => {
215 Error::AccessPointNotFoundException(inner)
216 }
217 crate::operation::attach_load_balancer_to_subnets::AttachLoadBalancerToSubnetsError::InvalidConfigurationRequestException(inner) => {
218 Error::InvalidConfigurationRequestException(inner)
219 }
220 crate::operation::attach_load_balancer_to_subnets::AttachLoadBalancerToSubnetsError::InvalidSubnetException(inner) => {
221 Error::InvalidSubnetException(inner)
222 }
223 crate::operation::attach_load_balancer_to_subnets::AttachLoadBalancerToSubnetsError::SubnetNotFoundException(inner) => {
224 Error::SubnetNotFoundException(inner)
225 }
226 crate::operation::attach_load_balancer_to_subnets::AttachLoadBalancerToSubnetsError::Unhandled(inner) => Error::Unhandled(inner),
227 }
228 }
229}
230impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::configure_health_check::ConfigureHealthCheckError, R>> for Error
231where
232 R: Send + Sync + std::fmt::Debug + 'static,
233{
234 fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::configure_health_check::ConfigureHealthCheckError, R>) -> Self {
235 match err {
236 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
237 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
238 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
239 source: err.into(),
240 }),
241 }
242 }
243}
244impl From<crate::operation::configure_health_check::ConfigureHealthCheckError> for Error {
245 fn from(err: crate::operation::configure_health_check::ConfigureHealthCheckError) -> Self {
246 match err {
247 crate::operation::configure_health_check::ConfigureHealthCheckError::AccessPointNotFoundException(inner) => {
248 Error::AccessPointNotFoundException(inner)
249 }
250 crate::operation::configure_health_check::ConfigureHealthCheckError::Unhandled(inner) => Error::Unhandled(inner),
251 }
252 }
253}
254impl<R>
255 From<
256 ::aws_smithy_runtime_api::client::result::SdkError<
257 crate::operation::create_app_cookie_stickiness_policy::CreateAppCookieStickinessPolicyError,
258 R,
259 >,
260 > for Error
261where
262 R: Send + Sync + std::fmt::Debug + 'static,
263{
264 fn from(
265 err: ::aws_smithy_runtime_api::client::result::SdkError<
266 crate::operation::create_app_cookie_stickiness_policy::CreateAppCookieStickinessPolicyError,
267 R,
268 >,
269 ) -> Self {
270 match err {
271 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
272 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
273 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
274 source: err.into(),
275 }),
276 }
277 }
278}
279impl From<crate::operation::create_app_cookie_stickiness_policy::CreateAppCookieStickinessPolicyError> for Error {
280 fn from(err: crate::operation::create_app_cookie_stickiness_policy::CreateAppCookieStickinessPolicyError) -> Self {
281 match err {
282 crate::operation::create_app_cookie_stickiness_policy::CreateAppCookieStickinessPolicyError::AccessPointNotFoundException(inner) => {
283 Error::AccessPointNotFoundException(inner)
284 }
285 crate::operation::create_app_cookie_stickiness_policy::CreateAppCookieStickinessPolicyError::DuplicatePolicyNameException(inner) => {
286 Error::DuplicatePolicyNameException(inner)
287 }
288 crate::operation::create_app_cookie_stickiness_policy::CreateAppCookieStickinessPolicyError::InvalidConfigurationRequestException(
289 inner,
290 ) => Error::InvalidConfigurationRequestException(inner),
291 crate::operation::create_app_cookie_stickiness_policy::CreateAppCookieStickinessPolicyError::TooManyPoliciesException(inner) => {
292 Error::TooManyPoliciesException(inner)
293 }
294 crate::operation::create_app_cookie_stickiness_policy::CreateAppCookieStickinessPolicyError::Unhandled(inner) => Error::Unhandled(inner),
295 }
296 }
297}
298impl<R>
299 From<
300 ::aws_smithy_runtime_api::client::result::SdkError<
301 crate::operation::create_lb_cookie_stickiness_policy::CreateLBCookieStickinessPolicyError,
302 R,
303 >,
304 > for Error
305where
306 R: Send + Sync + std::fmt::Debug + 'static,
307{
308 fn from(
309 err: ::aws_smithy_runtime_api::client::result::SdkError<
310 crate::operation::create_lb_cookie_stickiness_policy::CreateLBCookieStickinessPolicyError,
311 R,
312 >,
313 ) -> Self {
314 match err {
315 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
316 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
317 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
318 source: err.into(),
319 }),
320 }
321 }
322}
323impl From<crate::operation::create_lb_cookie_stickiness_policy::CreateLBCookieStickinessPolicyError> for Error {
324 fn from(err: crate::operation::create_lb_cookie_stickiness_policy::CreateLBCookieStickinessPolicyError) -> Self {
325 match err {
326 crate::operation::create_lb_cookie_stickiness_policy::CreateLBCookieStickinessPolicyError::AccessPointNotFoundException(inner) => {
327 Error::AccessPointNotFoundException(inner)
328 }
329 crate::operation::create_lb_cookie_stickiness_policy::CreateLBCookieStickinessPolicyError::DuplicatePolicyNameException(inner) => {
330 Error::DuplicatePolicyNameException(inner)
331 }
332 crate::operation::create_lb_cookie_stickiness_policy::CreateLBCookieStickinessPolicyError::InvalidConfigurationRequestException(
333 inner,
334 ) => Error::InvalidConfigurationRequestException(inner),
335 crate::operation::create_lb_cookie_stickiness_policy::CreateLBCookieStickinessPolicyError::TooManyPoliciesException(inner) => {
336 Error::TooManyPoliciesException(inner)
337 }
338 crate::operation::create_lb_cookie_stickiness_policy::CreateLBCookieStickinessPolicyError::Unhandled(inner) => Error::Unhandled(inner),
339 }
340 }
341}
342impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_load_balancer::CreateLoadBalancerError, R>> for Error
343where
344 R: Send + Sync + std::fmt::Debug + 'static,
345{
346 fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_load_balancer::CreateLoadBalancerError, R>) -> Self {
347 match err {
348 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
349 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
350 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
351 source: err.into(),
352 }),
353 }
354 }
355}
356impl From<crate::operation::create_load_balancer::CreateLoadBalancerError> for Error {
357 fn from(err: crate::operation::create_load_balancer::CreateLoadBalancerError) -> Self {
358 match err {
359 crate::operation::create_load_balancer::CreateLoadBalancerError::CertificateNotFoundException(inner) => {
360 Error::CertificateNotFoundException(inner)
361 }
362 crate::operation::create_load_balancer::CreateLoadBalancerError::DuplicateAccessPointNameException(inner) => {
363 Error::DuplicateAccessPointNameException(inner)
364 }
365 crate::operation::create_load_balancer::CreateLoadBalancerError::DuplicateTagKeysException(inner) => {
366 Error::DuplicateTagKeysException(inner)
367 }
368 crate::operation::create_load_balancer::CreateLoadBalancerError::InvalidConfigurationRequestException(inner) => {
369 Error::InvalidConfigurationRequestException(inner)
370 }
371 crate::operation::create_load_balancer::CreateLoadBalancerError::InvalidSchemeException(inner) => Error::InvalidSchemeException(inner),
372 crate::operation::create_load_balancer::CreateLoadBalancerError::InvalidSecurityGroupException(inner) => {
373 Error::InvalidSecurityGroupException(inner)
374 }
375 crate::operation::create_load_balancer::CreateLoadBalancerError::InvalidSubnetException(inner) => Error::InvalidSubnetException(inner),
376 crate::operation::create_load_balancer::CreateLoadBalancerError::OperationNotPermittedException(inner) => {
377 Error::OperationNotPermittedException(inner)
378 }
379 crate::operation::create_load_balancer::CreateLoadBalancerError::SubnetNotFoundException(inner) => Error::SubnetNotFoundException(inner),
380 crate::operation::create_load_balancer::CreateLoadBalancerError::TooManyAccessPointsException(inner) => {
381 Error::TooManyAccessPointsException(inner)
382 }
383 crate::operation::create_load_balancer::CreateLoadBalancerError::TooManyTagsException(inner) => Error::TooManyTagsException(inner),
384 crate::operation::create_load_balancer::CreateLoadBalancerError::UnsupportedProtocolException(inner) => {
385 Error::UnsupportedProtocolException(inner)
386 }
387 crate::operation::create_load_balancer::CreateLoadBalancerError::Unhandled(inner) => Error::Unhandled(inner),
388 }
389 }
390}
391impl<R>
392 From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_load_balancer_listeners::CreateLoadBalancerListenersError, R>>
393 for Error
394where
395 R: Send + Sync + std::fmt::Debug + 'static,
396{
397 fn from(
398 err: ::aws_smithy_runtime_api::client::result::SdkError<
399 crate::operation::create_load_balancer_listeners::CreateLoadBalancerListenersError,
400 R,
401 >,
402 ) -> Self {
403 match err {
404 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
405 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
406 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
407 source: err.into(),
408 }),
409 }
410 }
411}
412impl From<crate::operation::create_load_balancer_listeners::CreateLoadBalancerListenersError> for Error {
413 fn from(err: crate::operation::create_load_balancer_listeners::CreateLoadBalancerListenersError) -> Self {
414 match err {
415 crate::operation::create_load_balancer_listeners::CreateLoadBalancerListenersError::AccessPointNotFoundException(inner) => {
416 Error::AccessPointNotFoundException(inner)
417 }
418 crate::operation::create_load_balancer_listeners::CreateLoadBalancerListenersError::CertificateNotFoundException(inner) => {
419 Error::CertificateNotFoundException(inner)
420 }
421 crate::operation::create_load_balancer_listeners::CreateLoadBalancerListenersError::DuplicateListenerException(inner) => {
422 Error::DuplicateListenerException(inner)
423 }
424 crate::operation::create_load_balancer_listeners::CreateLoadBalancerListenersError::InvalidConfigurationRequestException(inner) => {
425 Error::InvalidConfigurationRequestException(inner)
426 }
427 crate::operation::create_load_balancer_listeners::CreateLoadBalancerListenersError::UnsupportedProtocolException(inner) => {
428 Error::UnsupportedProtocolException(inner)
429 }
430 crate::operation::create_load_balancer_listeners::CreateLoadBalancerListenersError::Unhandled(inner) => Error::Unhandled(inner),
431 }
432 }
433}
434impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_load_balancer_policy::CreateLoadBalancerPolicyError, R>>
435 for Error
436where
437 R: Send + Sync + std::fmt::Debug + 'static,
438{
439 fn from(
440 err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_load_balancer_policy::CreateLoadBalancerPolicyError, R>,
441 ) -> Self {
442 match err {
443 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
444 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
445 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
446 source: err.into(),
447 }),
448 }
449 }
450}
451impl From<crate::operation::create_load_balancer_policy::CreateLoadBalancerPolicyError> for Error {
452 fn from(err: crate::operation::create_load_balancer_policy::CreateLoadBalancerPolicyError) -> Self {
453 match err {
454 crate::operation::create_load_balancer_policy::CreateLoadBalancerPolicyError::AccessPointNotFoundException(inner) => {
455 Error::AccessPointNotFoundException(inner)
456 }
457 crate::operation::create_load_balancer_policy::CreateLoadBalancerPolicyError::DuplicatePolicyNameException(inner) => {
458 Error::DuplicatePolicyNameException(inner)
459 }
460 crate::operation::create_load_balancer_policy::CreateLoadBalancerPolicyError::InvalidConfigurationRequestException(inner) => {
461 Error::InvalidConfigurationRequestException(inner)
462 }
463 crate::operation::create_load_balancer_policy::CreateLoadBalancerPolicyError::PolicyTypeNotFoundException(inner) => {
464 Error::PolicyTypeNotFoundException(inner)
465 }
466 crate::operation::create_load_balancer_policy::CreateLoadBalancerPolicyError::TooManyPoliciesException(inner) => {
467 Error::TooManyPoliciesException(inner)
468 }
469 crate::operation::create_load_balancer_policy::CreateLoadBalancerPolicyError::Unhandled(inner) => Error::Unhandled(inner),
470 }
471 }
472}
473impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::delete_load_balancer::DeleteLoadBalancerError, R>> for Error
474where
475 R: Send + Sync + std::fmt::Debug + 'static,
476{
477 fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::delete_load_balancer::DeleteLoadBalancerError, R>) -> Self {
478 match err {
479 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
480 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
481 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
482 source: err.into(),
483 }),
484 }
485 }
486}
487impl From<crate::operation::delete_load_balancer::DeleteLoadBalancerError> for Error {
488 fn from(err: crate::operation::delete_load_balancer::DeleteLoadBalancerError) -> Self {
489 match err {
490 crate::operation::delete_load_balancer::DeleteLoadBalancerError::Unhandled(inner) => Error::Unhandled(inner),
491 }
492 }
493}
494impl<R>
495 From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::delete_load_balancer_listeners::DeleteLoadBalancerListenersError, R>>
496 for Error
497where
498 R: Send + Sync + std::fmt::Debug + 'static,
499{
500 fn from(
501 err: ::aws_smithy_runtime_api::client::result::SdkError<
502 crate::operation::delete_load_balancer_listeners::DeleteLoadBalancerListenersError,
503 R,
504 >,
505 ) -> Self {
506 match err {
507 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
508 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
509 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
510 source: err.into(),
511 }),
512 }
513 }
514}
515impl From<crate::operation::delete_load_balancer_listeners::DeleteLoadBalancerListenersError> for Error {
516 fn from(err: crate::operation::delete_load_balancer_listeners::DeleteLoadBalancerListenersError) -> Self {
517 match err {
518 crate::operation::delete_load_balancer_listeners::DeleteLoadBalancerListenersError::AccessPointNotFoundException(inner) => {
519 Error::AccessPointNotFoundException(inner)
520 }
521 crate::operation::delete_load_balancer_listeners::DeleteLoadBalancerListenersError::Unhandled(inner) => Error::Unhandled(inner),
522 }
523 }
524}
525impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::delete_load_balancer_policy::DeleteLoadBalancerPolicyError, R>>
526 for Error
527where
528 R: Send + Sync + std::fmt::Debug + 'static,
529{
530 fn from(
531 err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::delete_load_balancer_policy::DeleteLoadBalancerPolicyError, R>,
532 ) -> Self {
533 match err {
534 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
535 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
536 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
537 source: err.into(),
538 }),
539 }
540 }
541}
542impl From<crate::operation::delete_load_balancer_policy::DeleteLoadBalancerPolicyError> for Error {
543 fn from(err: crate::operation::delete_load_balancer_policy::DeleteLoadBalancerPolicyError) -> Self {
544 match err {
545 crate::operation::delete_load_balancer_policy::DeleteLoadBalancerPolicyError::AccessPointNotFoundException(inner) => {
546 Error::AccessPointNotFoundException(inner)
547 }
548 crate::operation::delete_load_balancer_policy::DeleteLoadBalancerPolicyError::InvalidConfigurationRequestException(inner) => {
549 Error::InvalidConfigurationRequestException(inner)
550 }
551 crate::operation::delete_load_balancer_policy::DeleteLoadBalancerPolicyError::Unhandled(inner) => Error::Unhandled(inner),
552 }
553 }
554}
555impl<R>
556 From<
557 ::aws_smithy_runtime_api::client::result::SdkError<
558 crate::operation::deregister_instances_from_load_balancer::DeregisterInstancesFromLoadBalancerError,
559 R,
560 >,
561 > for Error
562where
563 R: Send + Sync + std::fmt::Debug + 'static,
564{
565 fn from(
566 err: ::aws_smithy_runtime_api::client::result::SdkError<
567 crate::operation::deregister_instances_from_load_balancer::DeregisterInstancesFromLoadBalancerError,
568 R,
569 >,
570 ) -> Self {
571 match err {
572 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
573 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
574 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
575 source: err.into(),
576 }),
577 }
578 }
579}
580impl From<crate::operation::deregister_instances_from_load_balancer::DeregisterInstancesFromLoadBalancerError> for Error {
581 fn from(err: crate::operation::deregister_instances_from_load_balancer::DeregisterInstancesFromLoadBalancerError) -> Self {
582 match err {
583 crate::operation::deregister_instances_from_load_balancer::DeregisterInstancesFromLoadBalancerError::AccessPointNotFoundException(
584 inner,
585 ) => Error::AccessPointNotFoundException(inner),
586 crate::operation::deregister_instances_from_load_balancer::DeregisterInstancesFromLoadBalancerError::InvalidEndPointException(inner) => {
587 Error::InvalidEndPointException(inner)
588 }
589 crate::operation::deregister_instances_from_load_balancer::DeregisterInstancesFromLoadBalancerError::Unhandled(inner) => {
590 Error::Unhandled(inner)
591 }
592 }
593 }
594}
595impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::describe_account_limits::DescribeAccountLimitsError, R>> for Error
596where
597 R: Send + Sync + std::fmt::Debug + 'static,
598{
599 fn from(
600 err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::describe_account_limits::DescribeAccountLimitsError, R>,
601 ) -> Self {
602 match err {
603 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
604 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
605 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
606 source: err.into(),
607 }),
608 }
609 }
610}
611impl From<crate::operation::describe_account_limits::DescribeAccountLimitsError> for Error {
612 fn from(err: crate::operation::describe_account_limits::DescribeAccountLimitsError) -> Self {
613 match err {
614 crate::operation::describe_account_limits::DescribeAccountLimitsError::Unhandled(inner) => Error::Unhandled(inner),
615 }
616 }
617}
618impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::describe_instance_health::DescribeInstanceHealthError, R>> for Error
619where
620 R: Send + Sync + std::fmt::Debug + 'static,
621{
622 fn from(
623 err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::describe_instance_health::DescribeInstanceHealthError, R>,
624 ) -> Self {
625 match err {
626 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
627 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
628 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
629 source: err.into(),
630 }),
631 }
632 }
633}
634impl From<crate::operation::describe_instance_health::DescribeInstanceHealthError> for Error {
635 fn from(err: crate::operation::describe_instance_health::DescribeInstanceHealthError) -> Self {
636 match err {
637 crate::operation::describe_instance_health::DescribeInstanceHealthError::AccessPointNotFoundException(inner) => {
638 Error::AccessPointNotFoundException(inner)
639 }
640 crate::operation::describe_instance_health::DescribeInstanceHealthError::InvalidEndPointException(inner) => {
641 Error::InvalidEndPointException(inner)
642 }
643 crate::operation::describe_instance_health::DescribeInstanceHealthError::Unhandled(inner) => Error::Unhandled(inner),
644 }
645 }
646}
647impl<R>
648 From<
649 ::aws_smithy_runtime_api::client::result::SdkError<
650 crate::operation::describe_load_balancer_attributes::DescribeLoadBalancerAttributesError,
651 R,
652 >,
653 > for Error
654where
655 R: Send + Sync + std::fmt::Debug + 'static,
656{
657 fn from(
658 err: ::aws_smithy_runtime_api::client::result::SdkError<
659 crate::operation::describe_load_balancer_attributes::DescribeLoadBalancerAttributesError,
660 R,
661 >,
662 ) -> Self {
663 match err {
664 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
665 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
666 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
667 source: err.into(),
668 }),
669 }
670 }
671}
672impl From<crate::operation::describe_load_balancer_attributes::DescribeLoadBalancerAttributesError> for Error {
673 fn from(err: crate::operation::describe_load_balancer_attributes::DescribeLoadBalancerAttributesError) -> Self {
674 match err {
675 crate::operation::describe_load_balancer_attributes::DescribeLoadBalancerAttributesError::AccessPointNotFoundException(inner) => {
676 Error::AccessPointNotFoundException(inner)
677 }
678 crate::operation::describe_load_balancer_attributes::DescribeLoadBalancerAttributesError::LoadBalancerAttributeNotFoundException(
679 inner,
680 ) => Error::LoadBalancerAttributeNotFoundException(inner),
681 crate::operation::describe_load_balancer_attributes::DescribeLoadBalancerAttributesError::Unhandled(inner) => Error::Unhandled(inner),
682 }
683 }
684}
685impl<R>
686 From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::describe_load_balancer_policies::DescribeLoadBalancerPoliciesError, R>>
687 for Error
688where
689 R: Send + Sync + std::fmt::Debug + 'static,
690{
691 fn from(
692 err: ::aws_smithy_runtime_api::client::result::SdkError<
693 crate::operation::describe_load_balancer_policies::DescribeLoadBalancerPoliciesError,
694 R,
695 >,
696 ) -> Self {
697 match err {
698 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
699 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
700 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
701 source: err.into(),
702 }),
703 }
704 }
705}
706impl From<crate::operation::describe_load_balancer_policies::DescribeLoadBalancerPoliciesError> for Error {
707 fn from(err: crate::operation::describe_load_balancer_policies::DescribeLoadBalancerPoliciesError) -> Self {
708 match err {
709 crate::operation::describe_load_balancer_policies::DescribeLoadBalancerPoliciesError::AccessPointNotFoundException(inner) => {
710 Error::AccessPointNotFoundException(inner)
711 }
712 crate::operation::describe_load_balancer_policies::DescribeLoadBalancerPoliciesError::PolicyNotFoundException(inner) => {
713 Error::PolicyNotFoundException(inner)
714 }
715 crate::operation::describe_load_balancer_policies::DescribeLoadBalancerPoliciesError::Unhandled(inner) => Error::Unhandled(inner),
716 }
717 }
718}
719impl<R>
720 From<
721 ::aws_smithy_runtime_api::client::result::SdkError<
722 crate::operation::describe_load_balancer_policy_types::DescribeLoadBalancerPolicyTypesError,
723 R,
724 >,
725 > for Error
726where
727 R: Send + Sync + std::fmt::Debug + 'static,
728{
729 fn from(
730 err: ::aws_smithy_runtime_api::client::result::SdkError<
731 crate::operation::describe_load_balancer_policy_types::DescribeLoadBalancerPolicyTypesError,
732 R,
733 >,
734 ) -> Self {
735 match err {
736 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
737 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
738 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
739 source: err.into(),
740 }),
741 }
742 }
743}
744impl From<crate::operation::describe_load_balancer_policy_types::DescribeLoadBalancerPolicyTypesError> for Error {
745 fn from(err: crate::operation::describe_load_balancer_policy_types::DescribeLoadBalancerPolicyTypesError) -> Self {
746 match err {
747 crate::operation::describe_load_balancer_policy_types::DescribeLoadBalancerPolicyTypesError::PolicyTypeNotFoundException(inner) => {
748 Error::PolicyTypeNotFoundException(inner)
749 }
750 crate::operation::describe_load_balancer_policy_types::DescribeLoadBalancerPolicyTypesError::Unhandled(inner) => Error::Unhandled(inner),
751 }
752 }
753}
754impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::describe_load_balancers::DescribeLoadBalancersError, R>> for Error
755where
756 R: Send + Sync + std::fmt::Debug + 'static,
757{
758 fn from(
759 err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::describe_load_balancers::DescribeLoadBalancersError, R>,
760 ) -> Self {
761 match err {
762 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
763 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
764 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
765 source: err.into(),
766 }),
767 }
768 }
769}
770impl From<crate::operation::describe_load_balancers::DescribeLoadBalancersError> for Error {
771 fn from(err: crate::operation::describe_load_balancers::DescribeLoadBalancersError) -> Self {
772 match err {
773 crate::operation::describe_load_balancers::DescribeLoadBalancersError::AccessPointNotFoundException(inner) => {
774 Error::AccessPointNotFoundException(inner)
775 }
776 crate::operation::describe_load_balancers::DescribeLoadBalancersError::DependencyThrottleException(inner) => {
777 Error::DependencyThrottleException(inner)
778 }
779 crate::operation::describe_load_balancers::DescribeLoadBalancersError::Unhandled(inner) => Error::Unhandled(inner),
780 }
781 }
782}
783impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::describe_tags::DescribeTagsError, R>> for Error
784where
785 R: Send + Sync + std::fmt::Debug + 'static,
786{
787 fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::describe_tags::DescribeTagsError, R>) -> Self {
788 match err {
789 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
790 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
791 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
792 source: err.into(),
793 }),
794 }
795 }
796}
797impl From<crate::operation::describe_tags::DescribeTagsError> for Error {
798 fn from(err: crate::operation::describe_tags::DescribeTagsError) -> Self {
799 match err {
800 crate::operation::describe_tags::DescribeTagsError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
801 crate::operation::describe_tags::DescribeTagsError::Unhandled(inner) => Error::Unhandled(inner),
802 }
803 }
804}
805impl<R>
806 From<
807 ::aws_smithy_runtime_api::client::result::SdkError<
808 crate::operation::detach_load_balancer_from_subnets::DetachLoadBalancerFromSubnetsError,
809 R,
810 >,
811 > for Error
812where
813 R: Send + Sync + std::fmt::Debug + 'static,
814{
815 fn from(
816 err: ::aws_smithy_runtime_api::client::result::SdkError<
817 crate::operation::detach_load_balancer_from_subnets::DetachLoadBalancerFromSubnetsError,
818 R,
819 >,
820 ) -> Self {
821 match err {
822 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
823 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
824 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
825 source: err.into(),
826 }),
827 }
828 }
829}
830impl From<crate::operation::detach_load_balancer_from_subnets::DetachLoadBalancerFromSubnetsError> for Error {
831 fn from(err: crate::operation::detach_load_balancer_from_subnets::DetachLoadBalancerFromSubnetsError) -> Self {
832 match err {
833 crate::operation::detach_load_balancer_from_subnets::DetachLoadBalancerFromSubnetsError::AccessPointNotFoundException(inner) => {
834 Error::AccessPointNotFoundException(inner)
835 }
836 crate::operation::detach_load_balancer_from_subnets::DetachLoadBalancerFromSubnetsError::InvalidConfigurationRequestException(inner) => {
837 Error::InvalidConfigurationRequestException(inner)
838 }
839 crate::operation::detach_load_balancer_from_subnets::DetachLoadBalancerFromSubnetsError::Unhandled(inner) => Error::Unhandled(inner),
840 }
841 }
842}
843impl<R>
844 From<
845 ::aws_smithy_runtime_api::client::result::SdkError<
846 crate::operation::disable_availability_zones_for_load_balancer::DisableAvailabilityZonesForLoadBalancerError,
847 R,
848 >,
849 > for Error
850where
851 R: Send + Sync + std::fmt::Debug + 'static,
852{
853 fn from(
854 err: ::aws_smithy_runtime_api::client::result::SdkError<
855 crate::operation::disable_availability_zones_for_load_balancer::DisableAvailabilityZonesForLoadBalancerError,
856 R,
857 >,
858 ) -> Self {
859 match err {
860 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
861 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
862 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
863 source: err.into(),
864 }),
865 }
866 }
867}
868impl From<crate::operation::disable_availability_zones_for_load_balancer::DisableAvailabilityZonesForLoadBalancerError> for Error {
869 fn from(err: crate::operation::disable_availability_zones_for_load_balancer::DisableAvailabilityZonesForLoadBalancerError) -> Self {
870 match err {
871 crate::operation::disable_availability_zones_for_load_balancer::DisableAvailabilityZonesForLoadBalancerError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
872 crate::operation::disable_availability_zones_for_load_balancer::DisableAvailabilityZonesForLoadBalancerError::InvalidConfigurationRequestException(inner) => Error::InvalidConfigurationRequestException(inner),
873 crate::operation::disable_availability_zones_for_load_balancer::DisableAvailabilityZonesForLoadBalancerError::Unhandled(inner) => Error::Unhandled(inner),
874 }
875 }
876}
877impl<R>
878 From<
879 ::aws_smithy_runtime_api::client::result::SdkError<
880 crate::operation::enable_availability_zones_for_load_balancer::EnableAvailabilityZonesForLoadBalancerError,
881 R,
882 >,
883 > for Error
884where
885 R: Send + Sync + std::fmt::Debug + 'static,
886{
887 fn from(
888 err: ::aws_smithy_runtime_api::client::result::SdkError<
889 crate::operation::enable_availability_zones_for_load_balancer::EnableAvailabilityZonesForLoadBalancerError,
890 R,
891 >,
892 ) -> Self {
893 match err {
894 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
895 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
896 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
897 source: err.into(),
898 }),
899 }
900 }
901}
902impl From<crate::operation::enable_availability_zones_for_load_balancer::EnableAvailabilityZonesForLoadBalancerError> for Error {
903 fn from(err: crate::operation::enable_availability_zones_for_load_balancer::EnableAvailabilityZonesForLoadBalancerError) -> Self {
904 match err {
905 crate::operation::enable_availability_zones_for_load_balancer::EnableAvailabilityZonesForLoadBalancerError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
906 crate::operation::enable_availability_zones_for_load_balancer::EnableAvailabilityZonesForLoadBalancerError::Unhandled(inner) => Error::Unhandled(inner),
907 }
908 }
909}
910impl<R>
911 From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::modify_load_balancer_attributes::ModifyLoadBalancerAttributesError, R>>
912 for Error
913where
914 R: Send + Sync + std::fmt::Debug + 'static,
915{
916 fn from(
917 err: ::aws_smithy_runtime_api::client::result::SdkError<
918 crate::operation::modify_load_balancer_attributes::ModifyLoadBalancerAttributesError,
919 R,
920 >,
921 ) -> Self {
922 match err {
923 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
924 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
925 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
926 source: err.into(),
927 }),
928 }
929 }
930}
931impl From<crate::operation::modify_load_balancer_attributes::ModifyLoadBalancerAttributesError> for Error {
932 fn from(err: crate::operation::modify_load_balancer_attributes::ModifyLoadBalancerAttributesError) -> Self {
933 match err {
934 crate::operation::modify_load_balancer_attributes::ModifyLoadBalancerAttributesError::AccessPointNotFoundException(inner) => {
935 Error::AccessPointNotFoundException(inner)
936 }
937 crate::operation::modify_load_balancer_attributes::ModifyLoadBalancerAttributesError::InvalidConfigurationRequestException(inner) => {
938 Error::InvalidConfigurationRequestException(inner)
939 }
940 crate::operation::modify_load_balancer_attributes::ModifyLoadBalancerAttributesError::LoadBalancerAttributeNotFoundException(inner) => {
941 Error::LoadBalancerAttributeNotFoundException(inner)
942 }
943 crate::operation::modify_load_balancer_attributes::ModifyLoadBalancerAttributesError::Unhandled(inner) => Error::Unhandled(inner),
944 }
945 }
946}
947impl<R>
948 From<
949 ::aws_smithy_runtime_api::client::result::SdkError<
950 crate::operation::register_instances_with_load_balancer::RegisterInstancesWithLoadBalancerError,
951 R,
952 >,
953 > for Error
954where
955 R: Send + Sync + std::fmt::Debug + 'static,
956{
957 fn from(
958 err: ::aws_smithy_runtime_api::client::result::SdkError<
959 crate::operation::register_instances_with_load_balancer::RegisterInstancesWithLoadBalancerError,
960 R,
961 >,
962 ) -> Self {
963 match err {
964 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
965 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
966 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
967 source: err.into(),
968 }),
969 }
970 }
971}
972impl From<crate::operation::register_instances_with_load_balancer::RegisterInstancesWithLoadBalancerError> for Error {
973 fn from(err: crate::operation::register_instances_with_load_balancer::RegisterInstancesWithLoadBalancerError) -> Self {
974 match err {
975 crate::operation::register_instances_with_load_balancer::RegisterInstancesWithLoadBalancerError::AccessPointNotFoundException(inner) => {
976 Error::AccessPointNotFoundException(inner)
977 }
978 crate::operation::register_instances_with_load_balancer::RegisterInstancesWithLoadBalancerError::InvalidEndPointException(inner) => {
979 Error::InvalidEndPointException(inner)
980 }
981 crate::operation::register_instances_with_load_balancer::RegisterInstancesWithLoadBalancerError::Unhandled(inner) => {
982 Error::Unhandled(inner)
983 }
984 }
985 }
986}
987impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::remove_tags::RemoveTagsError, R>> for Error
988where
989 R: Send + Sync + std::fmt::Debug + 'static,
990{
991 fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::remove_tags::RemoveTagsError, R>) -> Self {
992 match err {
993 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
994 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
995 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
996 source: err.into(),
997 }),
998 }
999 }
1000}
1001impl From<crate::operation::remove_tags::RemoveTagsError> for Error {
1002 fn from(err: crate::operation::remove_tags::RemoveTagsError) -> Self {
1003 match err {
1004 crate::operation::remove_tags::RemoveTagsError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
1005 crate::operation::remove_tags::RemoveTagsError::Unhandled(inner) => Error::Unhandled(inner),
1006 }
1007 }
1008}
1009impl<R>
1010 From<
1011 ::aws_smithy_runtime_api::client::result::SdkError<
1012 crate::operation::set_load_balancer_listener_ssl_certificate::SetLoadBalancerListenerSSLCertificateError,
1013 R,
1014 >,
1015 > for Error
1016where
1017 R: Send + Sync + std::fmt::Debug + 'static,
1018{
1019 fn from(
1020 err: ::aws_smithy_runtime_api::client::result::SdkError<
1021 crate::operation::set_load_balancer_listener_ssl_certificate::SetLoadBalancerListenerSSLCertificateError,
1022 R,
1023 >,
1024 ) -> Self {
1025 match err {
1026 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
1027 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
1028 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
1029 source: err.into(),
1030 }),
1031 }
1032 }
1033}
1034impl From<crate::operation::set_load_balancer_listener_ssl_certificate::SetLoadBalancerListenerSSLCertificateError> for Error {
1035 fn from(err: crate::operation::set_load_balancer_listener_ssl_certificate::SetLoadBalancerListenerSSLCertificateError) -> Self {
1036 match err {
1037 crate::operation::set_load_balancer_listener_ssl_certificate::SetLoadBalancerListenerSSLCertificateError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
1038 crate::operation::set_load_balancer_listener_ssl_certificate::SetLoadBalancerListenerSSLCertificateError::CertificateNotFoundException(inner) => Error::CertificateNotFoundException(inner),
1039 crate::operation::set_load_balancer_listener_ssl_certificate::SetLoadBalancerListenerSSLCertificateError::InvalidConfigurationRequestException(inner) => Error::InvalidConfigurationRequestException(inner),
1040 crate::operation::set_load_balancer_listener_ssl_certificate::SetLoadBalancerListenerSSLCertificateError::ListenerNotFoundException(inner) => Error::ListenerNotFoundException(inner),
1041 crate::operation::set_load_balancer_listener_ssl_certificate::SetLoadBalancerListenerSSLCertificateError::UnsupportedProtocolException(inner) => Error::UnsupportedProtocolException(inner),
1042 crate::operation::set_load_balancer_listener_ssl_certificate::SetLoadBalancerListenerSSLCertificateError::Unhandled(inner) => Error::Unhandled(inner),
1043 }
1044 }
1045}
1046impl<R>
1047 From<
1048 ::aws_smithy_runtime_api::client::result::SdkError<
1049 crate::operation::set_load_balancer_policies_for_backend_server::SetLoadBalancerPoliciesForBackendServerError,
1050 R,
1051 >,
1052 > for Error
1053where
1054 R: Send + Sync + std::fmt::Debug + 'static,
1055{
1056 fn from(
1057 err: ::aws_smithy_runtime_api::client::result::SdkError<
1058 crate::operation::set_load_balancer_policies_for_backend_server::SetLoadBalancerPoliciesForBackendServerError,
1059 R,
1060 >,
1061 ) -> Self {
1062 match err {
1063 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
1064 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
1065 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
1066 source: err.into(),
1067 }),
1068 }
1069 }
1070}
1071impl From<crate::operation::set_load_balancer_policies_for_backend_server::SetLoadBalancerPoliciesForBackendServerError> for Error {
1072 fn from(err: crate::operation::set_load_balancer_policies_for_backend_server::SetLoadBalancerPoliciesForBackendServerError) -> Self {
1073 match err {
1074 crate::operation::set_load_balancer_policies_for_backend_server::SetLoadBalancerPoliciesForBackendServerError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
1075 crate::operation::set_load_balancer_policies_for_backend_server::SetLoadBalancerPoliciesForBackendServerError::InvalidConfigurationRequestException(inner) => Error::InvalidConfigurationRequestException(inner),
1076 crate::operation::set_load_balancer_policies_for_backend_server::SetLoadBalancerPoliciesForBackendServerError::PolicyNotFoundException(inner) => Error::PolicyNotFoundException(inner),
1077 crate::operation::set_load_balancer_policies_for_backend_server::SetLoadBalancerPoliciesForBackendServerError::Unhandled(inner) => Error::Unhandled(inner),
1078 }
1079 }
1080}
1081impl<R>
1082 From<
1083 ::aws_smithy_runtime_api::client::result::SdkError<
1084 crate::operation::set_load_balancer_policies_of_listener::SetLoadBalancerPoliciesOfListenerError,
1085 R,
1086 >,
1087 > for Error
1088where
1089 R: Send + Sync + std::fmt::Debug + 'static,
1090{
1091 fn from(
1092 err: ::aws_smithy_runtime_api::client::result::SdkError<
1093 crate::operation::set_load_balancer_policies_of_listener::SetLoadBalancerPoliciesOfListenerError,
1094 R,
1095 >,
1096 ) -> Self {
1097 match err {
1098 ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
1099 _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
1100 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
1101 source: err.into(),
1102 }),
1103 }
1104 }
1105}
1106impl From<crate::operation::set_load_balancer_policies_of_listener::SetLoadBalancerPoliciesOfListenerError> for Error {
1107 fn from(err: crate::operation::set_load_balancer_policies_of_listener::SetLoadBalancerPoliciesOfListenerError) -> Self {
1108 match err {
1109 crate::operation::set_load_balancer_policies_of_listener::SetLoadBalancerPoliciesOfListenerError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
1110 crate::operation::set_load_balancer_policies_of_listener::SetLoadBalancerPoliciesOfListenerError::InvalidConfigurationRequestException(inner) => Error::InvalidConfigurationRequestException(inner),
1111 crate::operation::set_load_balancer_policies_of_listener::SetLoadBalancerPoliciesOfListenerError::ListenerNotFoundException(inner) => Error::ListenerNotFoundException(inner),
1112 crate::operation::set_load_balancer_policies_of_listener::SetLoadBalancerPoliciesOfListenerError::PolicyNotFoundException(inner) => Error::PolicyNotFoundException(inner),
1113 crate::operation::set_load_balancer_policies_of_listener::SetLoadBalancerPoliciesOfListenerError::Unhandled(inner) => Error::Unhandled(inner),
1114 }
1115 }
1116}
1117impl<O, E> ::std::convert::From<::aws_smithy_runtime_api::client::waiters::error::WaiterError<O, E>> for Error
1118where
1119 O: ::std::fmt::Debug + ::std::marker::Send + ::std::marker::Sync + 'static,
1120 E: ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static,
1121{
1122 fn from(err: ::aws_smithy_runtime_api::client::waiters::error::WaiterError<O, E>) -> Self {
1123 Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
1124 meta: ::std::default::Default::default(),
1125 source: err.into(),
1126 })
1127 }
1128}
1129impl ::std::error::Error for Error {
1130 fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
1131 match self {
1132 Error::AccessPointNotFoundException(inner) => inner.source(),
1133 Error::CertificateNotFoundException(inner) => inner.source(),
1134 Error::DependencyThrottleException(inner) => inner.source(),
1135 Error::DuplicateAccessPointNameException(inner) => inner.source(),
1136 Error::DuplicateListenerException(inner) => inner.source(),
1137 Error::DuplicatePolicyNameException(inner) => inner.source(),
1138 Error::DuplicateTagKeysException(inner) => inner.source(),
1139 Error::InvalidConfigurationRequestException(inner) => inner.source(),
1140 Error::InvalidEndPointException(inner) => inner.source(),
1141 Error::InvalidSchemeException(inner) => inner.source(),
1142 Error::InvalidSecurityGroupException(inner) => inner.source(),
1143 Error::InvalidSubnetException(inner) => inner.source(),
1144 Error::ListenerNotFoundException(inner) => inner.source(),
1145 Error::LoadBalancerAttributeNotFoundException(inner) => inner.source(),
1146 Error::OperationNotPermittedException(inner) => inner.source(),
1147 Error::PolicyNotFoundException(inner) => inner.source(),
1148 Error::PolicyTypeNotFoundException(inner) => inner.source(),
1149 Error::SubnetNotFoundException(inner) => inner.source(),
1150 Error::TooManyAccessPointsException(inner) => inner.source(),
1151 Error::TooManyPoliciesException(inner) => inner.source(),
1152 Error::TooManyTagsException(inner) => inner.source(),
1153 Error::UnsupportedProtocolException(inner) => inner.source(),
1154 Error::Unhandled(inner) => ::std::option::Option::Some(&*inner.source),
1155 }
1156 }
1157}
1158impl ::aws_types::request_id::RequestId for Error {
1159 fn request_id(&self) -> Option<&str> {
1160 match self {
1161 Self::AccessPointNotFoundException(e) => e.request_id(),
1162 Self::CertificateNotFoundException(e) => e.request_id(),
1163 Self::DependencyThrottleException(e) => e.request_id(),
1164 Self::DuplicateAccessPointNameException(e) => e.request_id(),
1165 Self::DuplicateListenerException(e) => e.request_id(),
1166 Self::DuplicatePolicyNameException(e) => e.request_id(),
1167 Self::DuplicateTagKeysException(e) => e.request_id(),
1168 Self::InvalidConfigurationRequestException(e) => e.request_id(),
1169 Self::InvalidEndPointException(e) => e.request_id(),
1170 Self::InvalidSchemeException(e) => e.request_id(),
1171 Self::InvalidSecurityGroupException(e) => e.request_id(),
1172 Self::InvalidSubnetException(e) => e.request_id(),
1173 Self::ListenerNotFoundException(e) => e.request_id(),
1174 Self::LoadBalancerAttributeNotFoundException(e) => e.request_id(),
1175 Self::OperationNotPermittedException(e) => e.request_id(),
1176 Self::PolicyNotFoundException(e) => e.request_id(),
1177 Self::PolicyTypeNotFoundException(e) => e.request_id(),
1178 Self::SubnetNotFoundException(e) => e.request_id(),
1179 Self::TooManyAccessPointsException(e) => e.request_id(),
1180 Self::TooManyPoliciesException(e) => e.request_id(),
1181 Self::TooManyTagsException(e) => e.request_id(),
1182 Self::UnsupportedProtocolException(e) => e.request_id(),
1183 Self::Unhandled(e) => e.meta.request_id(),
1184 }
1185 }
1186}