Skip to main content

aws_sdk_rds/operation/
register_db_proxy_targets.rs

1// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
2/// Orchestration and serialization glue logic for `RegisterDBProxyTargets`.
3#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
4#[non_exhaustive]
5pub struct RegisterDBProxyTargets;
6impl RegisterDBProxyTargets {
7    /// Creates a new `RegisterDBProxyTargets`
8    pub fn new() -> Self {
9        Self
10    }
11    pub(crate) async fn orchestrate(
12        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
13        input: crate::operation::register_db_proxy_targets::RegisterDbProxyTargetsInput,
14    ) -> ::std::result::Result<
15        crate::operation::register_db_proxy_targets::RegisterDbProxyTargetsOutput,
16        ::aws_smithy_runtime_api::client::result::SdkError<
17            crate::operation::register_db_proxy_targets::RegisterDBProxyTargetsError,
18            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
19        >,
20    > {
21        let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
22            ::aws_smithy_runtime_api::client::interceptors::context::Error,
23            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
24        >| {
25            err.map_service_error(|err| {
26                err.downcast::<crate::operation::register_db_proxy_targets::RegisterDBProxyTargetsError>()
27                    .expect("correct error type")
28            })
29        };
30        let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
31            .await
32            .map_err(map_err)?;
33        let output = context.finalize().map_err(map_err)?;
34        ::std::result::Result::Ok(
35            output
36                .downcast::<crate::operation::register_db_proxy_targets::RegisterDbProxyTargetsOutput>()
37                .expect("correct output type"),
38        )
39    }
40
41    pub(crate) async fn orchestrate_with_stop_point(
42        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
43        input: crate::operation::register_db_proxy_targets::RegisterDbProxyTargetsInput,
44        stop_point: ::aws_smithy_runtime::client::orchestrator::StopPoint,
45    ) -> ::std::result::Result<
46        ::aws_smithy_runtime_api::client::interceptors::context::InterceptorContext,
47        ::aws_smithy_runtime_api::client::result::SdkError<
48            ::aws_smithy_runtime_api::client::interceptors::context::Error,
49            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
50        >,
51    > {
52        let input = ::aws_smithy_runtime_api::client::interceptors::context::Input::erase(input);
53        use ::tracing::Instrument;
54        ::aws_smithy_runtime::client::orchestrator::invoke_with_stop_point("RDS", "RegisterDBProxyTargets", input, runtime_plugins, stop_point)
55            // Create a parent span for the entire operation. Includes a random, internal-only,
56            // seven-digit ID for the operation orchestration so that it can be correlated in the logs.
57            .instrument(::tracing::debug_span!(
58                "RDS.RegisterDBProxyTargets",
59                "rpc.service" = "RDS",
60                "rpc.method" = "RegisterDBProxyTargets",
61                "sdk_invocation_id" = ::fastrand::u32(1_000_000..10_000_000),
62                "rpc.system" = "aws-api",
63            ))
64            .await
65    }
66
67    pub(crate) fn operation_runtime_plugins(
68        client_runtime_plugins: ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
69        client_config: &crate::config::Config,
70        config_override: ::std::option::Option<crate::config::Builder>,
71    ) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {
72        let mut runtime_plugins = client_runtime_plugins.with_operation_plugin(Self::new());
73
74        if let ::std::option::Option::Some(config_override) = config_override {
75            for plugin in config_override.runtime_plugins.iter().cloned() {
76                runtime_plugins = runtime_plugins.with_operation_plugin(plugin);
77            }
78            runtime_plugins = runtime_plugins.with_operation_plugin(crate::config::ConfigOverrideRuntimePlugin::new(
79                config_override,
80                client_config.config.clone(),
81                &client_config.runtime_components,
82            ));
83        }
84        runtime_plugins
85    }
86}
87impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for RegisterDBProxyTargets {
88    fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
89        let mut cfg = ::aws_smithy_types::config_bag::Layer::new("RegisterDBProxyTargets");
90
91        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedRequestSerializer::new(
92            RegisterDBProxyTargetsRequestSerializer,
93        ));
94        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
95            RegisterDBProxyTargetsResponseDeserializer,
96        ));
97
98        cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
99            crate::config::auth::Params::builder()
100                .operation_name("RegisterDBProxyTargets")
101                .build()
102                .expect("required fields set"),
103        ));
104
105        cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
106            "RegisterDBProxyTargets",
107            "RDS",
108        ));
109        let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
110        signing_options.double_uri_encode = true;
111        signing_options.content_sha256_header = false;
112        signing_options.normalize_uri_path = true;
113        signing_options.payload_override = None;
114
115        cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
116            signing_options,
117            ..::std::default::Default::default()
118        });
119
120        ::std::option::Option::Some(cfg.freeze())
121    }
122
123    fn runtime_components(
124        &self,
125        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
126    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
127        #[allow(unused_mut)]
128        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("RegisterDBProxyTargets")
129            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
130                RegisterDBProxyTargetsTelemetryInputCaptureInterceptor,
131            ))
132            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
133                ::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default(),
134            ))
135            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
136                RegisterDBProxyTargetsEndpointParamsInterceptor,
137            ))
138            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
139                crate::operation::register_db_proxy_targets::RegisterDBProxyTargetsError,
140            >::new())
141            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
142                crate::operation::register_db_proxy_targets::RegisterDBProxyTargetsError,
143            >::new())
144            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
145                crate::operation::register_db_proxy_targets::RegisterDBProxyTargetsError,
146            >::new());
147
148        ::std::borrow::Cow::Owned(rcb)
149    }
150}
151
152#[derive(Debug)]
153struct RegisterDBProxyTargetsTelemetryInputCaptureInterceptor;
154
155#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
156impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RegisterDBProxyTargetsTelemetryInputCaptureInterceptor {
157    fn name(&self) -> &'static str {
158        "RegisterDBProxyTargetsTelemetryInputCaptureInterceptor"
159    }
160
161    fn read_before_execution(
162        &self,
163        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
164            '_,
165            ::aws_smithy_runtime_api::client::interceptors::context::Input,
166            ::aws_smithy_runtime_api::client::interceptors::context::Output,
167            ::aws_smithy_runtime_api::client::interceptors::context::Error,
168        >,
169        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
170    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
171        // Nothing to do unless the customer opted in by naming members to record.
172        let ::std::option::Option::Some(requested) = cfg
173            .load::<::aws_smithy_types::telemetry::RequestedTelemetryAttributes>()
174            .filter(|r| !r.is_empty())
175        else {
176            return ::std::result::Result::Ok(());
177        };
178
179        let ::std::option::Option::Some(input) = context.input().downcast_ref::<RegisterDbProxyTargetsInput>() else {
180            // A mismatched input is not this interceptor's concern; skip quietly.
181            return ::std::result::Result::Ok(());
182        };
183
184        let mut captured = ::aws_smithy_types::telemetry::CapturedTelemetryAttributes::default();
185        if requested.should_capture("DBProxyName") {
186            if let ::std::option::Option::Some(value) = input.db_proxy_name.as_deref() {
187                captured.insert("DBProxyName", value);
188            }
189        }
190        if requested.should_capture("TargetGroupName") {
191            if let ::std::option::Option::Some(value) = input.target_group_name.as_deref() {
192                captured.insert("TargetGroupName", value);
193            }
194        }
195
196        cfg.interceptor_state().store_put(captured);
197        ::std::result::Result::Ok(())
198    }
199}
200#[derive(Debug)]
201struct RegisterDBProxyTargetsResponseDeserializer;
202impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for RegisterDBProxyTargetsResponseDeserializer {
203    fn deserialize_nonstreaming_with_config(
204        &self,
205        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
206        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
207    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
208        let (success, status) = (response.status().is_success(), response.status().as_u16());
209        let headers = response.headers();
210        let body = response.body().bytes().expect("body loaded");
211        #[allow(unused_mut)]
212        let mut force_error = false;
213        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
214        let parse_result = if !success && status != 200 || force_error {
215            crate::protocol_serde::shape_register_db_proxy_targets::de_register_db_proxy_targets_http_error(status, headers, body)
216        } else {
217            crate::protocol_serde::shape_register_db_proxy_targets::de_register_db_proxy_targets_http_response(status, headers, body)
218        };
219        crate::protocol_serde::type_erase_result(parse_result)
220    }
221}
222#[derive(Debug)]
223struct RegisterDBProxyTargetsRequestSerializer;
224impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for RegisterDBProxyTargetsRequestSerializer {
225    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
226    fn serialize_input(
227        &self,
228        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
229        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
230    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
231        let input = input
232            .downcast::<crate::operation::register_db_proxy_targets::RegisterDbProxyTargetsInput>()
233            .expect("correct type");
234        let _header_serialization_settings = _cfg
235            .load::<crate::serialization_settings::HeaderSerializationSettings>()
236            .cloned()
237            .unwrap_or_default();
238        let mut request_builder = {
239            #[allow(clippy::uninlined_format_args)]
240            fn uri_base(
241                _input: &crate::operation::register_db_proxy_targets::RegisterDbProxyTargetsInput,
242                output: &mut ::std::string::String,
243            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
244                use ::std::fmt::Write as _;
245                ::std::write!(output, "/").expect("formatting should succeed");
246                ::std::result::Result::Ok(())
247            }
248            #[allow(clippy::unnecessary_wraps)]
249            fn update_http_builder(
250                input: &crate::operation::register_db_proxy_targets::RegisterDbProxyTargetsInput,
251                builder: ::http_1x::request::Builder,
252            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
253                let mut uri = ::std::string::String::new();
254                uri_base(input, &mut uri)?;
255                ::std::result::Result::Ok(builder.method("POST").uri(uri))
256            }
257            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
258            builder =
259                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
260            builder
261        };
262        let body = ::aws_smithy_types::body::SdkBody::from(
263            crate::protocol_serde::shape_register_db_proxy_targets_input::ser_register_db_proxy_targets_input_input_input(&input)?,
264        );
265        if let Some(content_length) = body.content_length() {
266            let content_length = content_length.to_string();
267            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
268        }
269        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
270    }
271}
272#[derive(Debug)]
273struct RegisterDBProxyTargetsEndpointParamsInterceptor;
274
275#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
276impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RegisterDBProxyTargetsEndpointParamsInterceptor {
277    fn name(&self) -> &'static str {
278        "RegisterDBProxyTargetsEndpointParamsInterceptor"
279    }
280
281    fn read_before_execution(
282        &self,
283        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
284            '_,
285            ::aws_smithy_runtime_api::client::interceptors::context::Input,
286            ::aws_smithy_runtime_api::client::interceptors::context::Output,
287            ::aws_smithy_runtime_api::client::interceptors::context::Error,
288        >,
289        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
290    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
291        let _input = context
292            .input()
293            .downcast_ref::<RegisterDbProxyTargetsInput>()
294            .ok_or("failed to downcast to RegisterDbProxyTargetsInput")?;
295
296        let params = crate::config::endpoint::Params::builder()
297            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
298            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
299            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
300            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
301            .build()
302            .map_err(|err| {
303                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
304            })?;
305        cfg.interceptor_state()
306            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
307        ::std::result::Result::Ok(())
308    }
309}
310
311// The get_* functions below are generated from JMESPath expressions in the
312// operationContextParams trait. They target the operation's input shape.
313
314/// Error type for the `RegisterDBProxyTargetsError` operation.
315#[non_exhaustive]
316#[derive(::std::fmt::Debug)]
317pub enum RegisterDBProxyTargetsError {
318    /// <p><code>DBClusterIdentifier</code> doesn't refer to an existing DB cluster.</p>
319    DbClusterNotFoundFault(crate::types::error::DbClusterNotFoundFault),
320    /// <p><code>DBInstanceIdentifier</code> doesn't refer to an existing DB instance.</p>
321    DbInstanceNotFoundFault(crate::types::error::DbInstanceNotFoundFault),
322    /// <p>The specified proxy name doesn't correspond to a proxy owned by your Amazon Web Services account in the specified Amazon Web Services Region.</p>
323    DbProxyNotFoundFault(crate::types::error::DbProxyNotFoundFault),
324    /// <p>The proxy is already associated with the specified RDS DB instance or Aurora DB cluster.</p>
325    DbProxyTargetAlreadyRegisteredFault(crate::types::error::DbProxyTargetAlreadyRegisteredFault),
326    /// <p>The specified target group isn't available for a proxy owned by your Amazon Web Services account in the specified Amazon Web Services Region.</p>
327    DbProxyTargetGroupNotFoundFault(crate::types::error::DbProxyTargetGroupNotFoundFault),
328    /// <p>The requested operation can't be performed because there aren't enough available IP addresses in the proxy's subnets. Add more CIDR blocks to the VPC or remove IP address that aren't required from the subnets.</p>
329    InsufficientAvailableIPsInSubnetFault(crate::types::error::InsufficientAvailableIPsInSubnetFault),
330    /// <p>The requested operation can't be performed while the cluster is in this state.</p>
331    InvalidDbClusterStateFault(crate::types::error::InvalidDbClusterStateFault),
332    /// <p>The DB instance isn't in a valid state.</p>
333    InvalidDbInstanceStateFault(crate::types::error::InvalidDbInstanceStateFault),
334    /// <p>The requested operation can't be performed while the proxy is in this state.</p>
335    InvalidDbProxyStateFault(crate::types::error::InvalidDbProxyStateFault),
336    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
337    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
338    variable wildcard pattern and check `.code()`:
339     \
340    &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
341     \
342    See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-RegisterDBProxyTargetsError) for what information is available for the error.")]
343    Unhandled(crate::error::sealed_unhandled::Unhandled),
344}
345impl RegisterDBProxyTargetsError {
346    /// Creates the `RegisterDBProxyTargetsError::Unhandled` variant from any error type.
347    pub fn unhandled(
348        err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
349    ) -> Self {
350        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
351            source: err.into(),
352            meta: ::std::default::Default::default(),
353        })
354    }
355
356    /// Creates the `RegisterDBProxyTargetsError::Unhandled` variant from an [`ErrorMetadata`](::aws_smithy_types::error::ErrorMetadata).
357    pub fn generic(err: ::aws_smithy_types::error::ErrorMetadata) -> Self {
358        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
359            source: err.clone().into(),
360            meta: err,
361        })
362    }
363    ///
364    /// Returns error metadata, which includes the error code, message,
365    /// request ID, and potentially additional information.
366    ///
367    pub fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
368        match self {
369            Self::DbClusterNotFoundFault(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
370            Self::DbInstanceNotFoundFault(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
371            Self::DbProxyNotFoundFault(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
372            Self::DbProxyTargetAlreadyRegisteredFault(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
373            Self::DbProxyTargetGroupNotFoundFault(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
374            Self::InsufficientAvailableIPsInSubnetFault(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
375            Self::InvalidDbClusterStateFault(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
376            Self::InvalidDbInstanceStateFault(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
377            Self::InvalidDbProxyStateFault(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
378            Self::Unhandled(e) => &e.meta,
379        }
380    }
381    /// Returns `true` if the error kind is `RegisterDBProxyTargetsError::DbClusterNotFoundFault`.
382    pub fn is_db_cluster_not_found_fault(&self) -> bool {
383        matches!(self, Self::DbClusterNotFoundFault(_))
384    }
385    /// Returns `true` if the error kind is `RegisterDBProxyTargetsError::DbInstanceNotFoundFault`.
386    pub fn is_db_instance_not_found_fault(&self) -> bool {
387        matches!(self, Self::DbInstanceNotFoundFault(_))
388    }
389    /// Returns `true` if the error kind is `RegisterDBProxyTargetsError::DbProxyNotFoundFault`.
390    pub fn is_db_proxy_not_found_fault(&self) -> bool {
391        matches!(self, Self::DbProxyNotFoundFault(_))
392    }
393    /// Returns `true` if the error kind is `RegisterDBProxyTargetsError::DbProxyTargetAlreadyRegisteredFault`.
394    pub fn is_db_proxy_target_already_registered_fault(&self) -> bool {
395        matches!(self, Self::DbProxyTargetAlreadyRegisteredFault(_))
396    }
397    /// Returns `true` if the error kind is `RegisterDBProxyTargetsError::DbProxyTargetGroupNotFoundFault`.
398    pub fn is_db_proxy_target_group_not_found_fault(&self) -> bool {
399        matches!(self, Self::DbProxyTargetGroupNotFoundFault(_))
400    }
401    /// Returns `true` if the error kind is `RegisterDBProxyTargetsError::InsufficientAvailableIPsInSubnetFault`.
402    pub fn is_insufficient_available_ips_in_subnet_fault(&self) -> bool {
403        matches!(self, Self::InsufficientAvailableIPsInSubnetFault(_))
404    }
405    /// Returns `true` if the error kind is `RegisterDBProxyTargetsError::InvalidDbClusterStateFault`.
406    pub fn is_invalid_db_cluster_state_fault(&self) -> bool {
407        matches!(self, Self::InvalidDbClusterStateFault(_))
408    }
409    /// Returns `true` if the error kind is `RegisterDBProxyTargetsError::InvalidDbInstanceStateFault`.
410    pub fn is_invalid_db_instance_state_fault(&self) -> bool {
411        matches!(self, Self::InvalidDbInstanceStateFault(_))
412    }
413    /// Returns `true` if the error kind is `RegisterDBProxyTargetsError::InvalidDbProxyStateFault`.
414    pub fn is_invalid_db_proxy_state_fault(&self) -> bool {
415        matches!(self, Self::InvalidDbProxyStateFault(_))
416    }
417}
418impl ::std::error::Error for RegisterDBProxyTargetsError {
419    fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
420        match self {
421            Self::DbClusterNotFoundFault(_inner) => ::std::option::Option::Some(_inner),
422            Self::DbInstanceNotFoundFault(_inner) => ::std::option::Option::Some(_inner),
423            Self::DbProxyNotFoundFault(_inner) => ::std::option::Option::Some(_inner),
424            Self::DbProxyTargetAlreadyRegisteredFault(_inner) => ::std::option::Option::Some(_inner),
425            Self::DbProxyTargetGroupNotFoundFault(_inner) => ::std::option::Option::Some(_inner),
426            Self::InsufficientAvailableIPsInSubnetFault(_inner) => ::std::option::Option::Some(_inner),
427            Self::InvalidDbClusterStateFault(_inner) => ::std::option::Option::Some(_inner),
428            Self::InvalidDbInstanceStateFault(_inner) => ::std::option::Option::Some(_inner),
429            Self::InvalidDbProxyStateFault(_inner) => ::std::option::Option::Some(_inner),
430            Self::Unhandled(_inner) => ::std::option::Option::Some(&*_inner.source),
431        }
432    }
433}
434impl ::std::fmt::Display for RegisterDBProxyTargetsError {
435    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
436        match self {
437            Self::DbClusterNotFoundFault(_inner) => _inner.fmt(f),
438            Self::DbInstanceNotFoundFault(_inner) => _inner.fmt(f),
439            Self::DbProxyNotFoundFault(_inner) => _inner.fmt(f),
440            Self::DbProxyTargetAlreadyRegisteredFault(_inner) => _inner.fmt(f),
441            Self::DbProxyTargetGroupNotFoundFault(_inner) => _inner.fmt(f),
442            Self::InsufficientAvailableIPsInSubnetFault(_inner) => _inner.fmt(f),
443            Self::InvalidDbClusterStateFault(_inner) => _inner.fmt(f),
444            Self::InvalidDbInstanceStateFault(_inner) => _inner.fmt(f),
445            Self::InvalidDbProxyStateFault(_inner) => _inner.fmt(f),
446            Self::Unhandled(_inner) => {
447                if let ::std::option::Option::Some(code) = ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self) {
448                    write!(f, "unhandled error ({code})")
449                } else {
450                    f.write_str("unhandled error")
451                }
452            }
453        }
454    }
455}
456impl ::aws_smithy_types::retry::ProvideErrorKind for RegisterDBProxyTargetsError {
457    fn code(&self) -> ::std::option::Option<&str> {
458        ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self)
459    }
460    fn retryable_error_kind(&self) -> ::std::option::Option<::aws_smithy_types::retry::ErrorKind> {
461        ::std::option::Option::None
462    }
463}
464impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for RegisterDBProxyTargetsError {
465    fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
466        match self {
467            Self::DbClusterNotFoundFault(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
468            Self::DbInstanceNotFoundFault(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
469            Self::DbProxyNotFoundFault(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
470            Self::DbProxyTargetAlreadyRegisteredFault(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
471            Self::DbProxyTargetGroupNotFoundFault(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
472            Self::InsufficientAvailableIPsInSubnetFault(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
473            Self::InvalidDbClusterStateFault(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
474            Self::InvalidDbInstanceStateFault(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
475            Self::InvalidDbProxyStateFault(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
476            Self::Unhandled(_inner) => &_inner.meta,
477        }
478    }
479}
480impl ::aws_smithy_runtime_api::client::result::CreateUnhandledError for RegisterDBProxyTargetsError {
481    fn create_unhandled_error(
482        source: ::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>,
483        meta: ::std::option::Option<::aws_smithy_types::error::ErrorMetadata>,
484    ) -> Self {
485        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
486            source,
487            meta: meta.unwrap_or_default(),
488        })
489    }
490}
491impl ::aws_types::request_id::RequestId for crate::operation::register_db_proxy_targets::RegisterDBProxyTargetsError {
492    fn request_id(&self) -> Option<&str> {
493        self.meta().request_id()
494    }
495}
496
497pub use crate::operation::register_db_proxy_targets::_register_db_proxy_targets_input::RegisterDbProxyTargetsInput;
498
499pub use crate::operation::register_db_proxy_targets::_register_db_proxy_targets_output::RegisterDbProxyTargetsOutput;
500
501mod _register_db_proxy_targets_input;
502
503mod _register_db_proxy_targets_output;
504
505/// Builders
506pub mod builders;