Skip to main content

aws_sdk_rds/operation/
create_integration.rs

1// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
2/// Orchestration and serialization glue logic for `CreateIntegration`.
3#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
4#[non_exhaustive]
5pub struct CreateIntegration;
6impl CreateIntegration {
7    /// Creates a new `CreateIntegration`
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::create_integration::CreateIntegrationInput,
14    ) -> ::std::result::Result<
15        crate::operation::create_integration::CreateIntegrationOutput,
16        ::aws_smithy_runtime_api::client::result::SdkError<
17            crate::operation::create_integration::CreateIntegrationError,
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::create_integration::CreateIntegrationError>()
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::create_integration::CreateIntegrationOutput>()
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::create_integration::CreateIntegrationInput,
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", "CreateIntegration", 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.CreateIntegration",
59                "rpc.service" = "RDS",
60                "rpc.method" = "CreateIntegration",
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 CreateIntegration {
88    fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
89        let mut cfg = ::aws_smithy_types::config_bag::Layer::new("CreateIntegration");
90
91        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedRequestSerializer::new(
92            CreateIntegrationRequestSerializer,
93        ));
94        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
95            CreateIntegrationResponseDeserializer,
96        ));
97
98        cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
99            crate::config::auth::Params::builder()
100                .operation_name("CreateIntegration")
101                .build()
102                .expect("required fields set"),
103        ));
104
105        cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("CreateIntegration", "RDS"));
106        let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
107        signing_options.double_uri_encode = true;
108        signing_options.content_sha256_header = false;
109        signing_options.normalize_uri_path = true;
110        signing_options.payload_override = None;
111
112        cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
113            signing_options,
114            ..::std::default::Default::default()
115        });
116
117        ::std::option::Option::Some(cfg.freeze())
118    }
119
120    fn runtime_components(
121        &self,
122        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
123    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
124        #[allow(unused_mut)]
125        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("CreateIntegration")
126            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
127                CreateIntegrationTelemetryInputCaptureInterceptor,
128            ))
129            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
130                ::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default(),
131            ))
132            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
133                CreateIntegrationEndpointParamsInterceptor,
134            ))
135            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
136                crate::operation::create_integration::CreateIntegrationError,
137            >::new())
138            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
139                crate::operation::create_integration::CreateIntegrationError,
140            >::new())
141            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
142                crate::operation::create_integration::CreateIntegrationError,
143            >::new());
144
145        ::std::borrow::Cow::Owned(rcb)
146    }
147}
148
149#[derive(Debug)]
150struct CreateIntegrationTelemetryInputCaptureInterceptor;
151
152#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
153impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateIntegrationTelemetryInputCaptureInterceptor {
154    fn name(&self) -> &'static str {
155        "CreateIntegrationTelemetryInputCaptureInterceptor"
156    }
157
158    fn read_before_execution(
159        &self,
160        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
161            '_,
162            ::aws_smithy_runtime_api::client::interceptors::context::Input,
163            ::aws_smithy_runtime_api::client::interceptors::context::Output,
164            ::aws_smithy_runtime_api::client::interceptors::context::Error,
165        >,
166        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
167    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
168        // Nothing to do unless the customer opted in by naming members to record.
169        let ::std::option::Option::Some(requested) = cfg
170            .load::<::aws_smithy_types::telemetry::RequestedTelemetryAttributes>()
171            .filter(|r| !r.is_empty())
172        else {
173            return ::std::result::Result::Ok(());
174        };
175
176        let ::std::option::Option::Some(input) = context.input().downcast_ref::<CreateIntegrationInput>() else {
177            // A mismatched input is not this interceptor's concern; skip quietly.
178            return ::std::result::Result::Ok(());
179        };
180
181        let mut captured = ::aws_smithy_types::telemetry::CapturedTelemetryAttributes::default();
182        if requested.should_capture("SourceArn") {
183            if let ::std::option::Option::Some(value) = input.source_arn.as_deref() {
184                captured.insert("SourceArn", value);
185            }
186        }
187        if requested.should_capture("TargetArn") {
188            if let ::std::option::Option::Some(value) = input.target_arn.as_deref() {
189                captured.insert("TargetArn", value);
190            }
191        }
192        if requested.should_capture("IntegrationName") {
193            if let ::std::option::Option::Some(value) = input.integration_name.as_deref() {
194                captured.insert("IntegrationName", value);
195            }
196        }
197        if requested.should_capture("KMSKeyId") {
198            if let ::std::option::Option::Some(value) = input.kms_key_id.as_deref() {
199                captured.insert("KMSKeyId", value);
200            }
201        }
202        if requested.should_capture("DataFilter") {
203            if let ::std::option::Option::Some(value) = input.data_filter.as_deref() {
204                captured.insert("DataFilter", value);
205            }
206        }
207        if requested.should_capture("Description") {
208            if let ::std::option::Option::Some(value) = input.description.as_deref() {
209                captured.insert("Description", value);
210            }
211        }
212
213        cfg.interceptor_state().store_put(captured);
214        ::std::result::Result::Ok(())
215    }
216}
217#[derive(Debug)]
218struct CreateIntegrationResponseDeserializer;
219impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateIntegrationResponseDeserializer {
220    fn deserialize_nonstreaming_with_config(
221        &self,
222        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
223        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
224    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
225        let (success, status) = (response.status().is_success(), response.status().as_u16());
226        let headers = response.headers();
227        let body = response.body().bytes().expect("body loaded");
228        #[allow(unused_mut)]
229        let mut force_error = false;
230        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
231        let parse_result = if !success && status != 200 || force_error {
232            crate::protocol_serde::shape_create_integration::de_create_integration_http_error(status, headers, body)
233        } else {
234            crate::protocol_serde::shape_create_integration::de_create_integration_http_response(status, headers, body)
235        };
236        crate::protocol_serde::type_erase_result(parse_result)
237    }
238}
239#[derive(Debug)]
240struct CreateIntegrationRequestSerializer;
241impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateIntegrationRequestSerializer {
242    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
243    fn serialize_input(
244        &self,
245        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
246        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
247    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
248        let input = input
249            .downcast::<crate::operation::create_integration::CreateIntegrationInput>()
250            .expect("correct type");
251        let _header_serialization_settings = _cfg
252            .load::<crate::serialization_settings::HeaderSerializationSettings>()
253            .cloned()
254            .unwrap_or_default();
255        let mut request_builder = {
256            #[allow(clippy::uninlined_format_args)]
257            fn uri_base(
258                _input: &crate::operation::create_integration::CreateIntegrationInput,
259                output: &mut ::std::string::String,
260            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
261                use ::std::fmt::Write as _;
262                ::std::write!(output, "/").expect("formatting should succeed");
263                ::std::result::Result::Ok(())
264            }
265            #[allow(clippy::unnecessary_wraps)]
266            fn update_http_builder(
267                input: &crate::operation::create_integration::CreateIntegrationInput,
268                builder: ::http_1x::request::Builder,
269            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
270                let mut uri = ::std::string::String::new();
271                uri_base(input, &mut uri)?;
272                ::std::result::Result::Ok(builder.method("POST").uri(uri))
273            }
274            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
275            builder =
276                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
277            builder
278        };
279        let body = ::aws_smithy_types::body::SdkBody::from(
280            crate::protocol_serde::shape_create_integration_input::ser_create_integration_input_input_input(&input)?,
281        );
282        if let Some(content_length) = body.content_length() {
283            let content_length = content_length.to_string();
284            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
285        }
286        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
287    }
288}
289#[derive(Debug)]
290struct CreateIntegrationEndpointParamsInterceptor;
291
292#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
293impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateIntegrationEndpointParamsInterceptor {
294    fn name(&self) -> &'static str {
295        "CreateIntegrationEndpointParamsInterceptor"
296    }
297
298    fn read_before_execution(
299        &self,
300        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
301            '_,
302            ::aws_smithy_runtime_api::client::interceptors::context::Input,
303            ::aws_smithy_runtime_api::client::interceptors::context::Output,
304            ::aws_smithy_runtime_api::client::interceptors::context::Error,
305        >,
306        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
307    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
308        let _input = context
309            .input()
310            .downcast_ref::<CreateIntegrationInput>()
311            .ok_or("failed to downcast to CreateIntegrationInput")?;
312
313        let params = crate::config::endpoint::Params::builder()
314            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
315            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
316            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
317            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
318            .build()
319            .map_err(|err| {
320                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
321            })?;
322        cfg.interceptor_state()
323            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
324        ::std::result::Result::Ok(())
325    }
326}
327
328// The get_* functions below are generated from JMESPath expressions in the
329// operationContextParams trait. They target the operation's input shape.
330
331/// Error type for the `CreateIntegrationError` operation.
332#[non_exhaustive]
333#[derive(::std::fmt::Debug)]
334pub enum CreateIntegrationError {
335    /// <p><code>DBClusterIdentifier</code> doesn't refer to an existing DB cluster.</p>
336    DbClusterNotFoundFault(crate::types::error::DbClusterNotFoundFault),
337    /// <p><code>DBInstanceIdentifier</code> doesn't refer to an existing DB instance.</p>
338    DbInstanceNotFoundFault(crate::types::error::DbInstanceNotFoundFault),
339    /// <p>The integration you are trying to create already exists.</p>
340    IntegrationAlreadyExistsFault(crate::types::error::IntegrationAlreadyExistsFault),
341    /// <p>A conflicting conditional operation is currently in progress against this resource. Typically occurs when there are multiple requests being made to the same resource at the same time, and these requests conflict with each other.</p>
342    IntegrationConflictOperationFault(crate::types::error::IntegrationConflictOperationFault),
343    /// <p>You can't crate any more zero-ETL integrations because the quota has been reached.</p>
344    IntegrationQuotaExceededFault(crate::types::error::IntegrationQuotaExceededFault),
345    /// <p>An error occurred accessing an Amazon Web Services KMS key.</p>
346    KmsKeyNotAccessibleFault(crate::types::error::KmsKeyNotAccessibleFault),
347    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
348    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
349    variable wildcard pattern and check `.code()`:
350     \
351    &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
352     \
353    See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-CreateIntegrationError) for what information is available for the error.")]
354    Unhandled(crate::error::sealed_unhandled::Unhandled),
355}
356impl CreateIntegrationError {
357    /// Creates the `CreateIntegrationError::Unhandled` variant from any error type.
358    pub fn unhandled(
359        err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
360    ) -> Self {
361        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
362            source: err.into(),
363            meta: ::std::default::Default::default(),
364        })
365    }
366
367    /// Creates the `CreateIntegrationError::Unhandled` variant from an [`ErrorMetadata`](::aws_smithy_types::error::ErrorMetadata).
368    pub fn generic(err: ::aws_smithy_types::error::ErrorMetadata) -> Self {
369        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
370            source: err.clone().into(),
371            meta: err,
372        })
373    }
374    ///
375    /// Returns error metadata, which includes the error code, message,
376    /// request ID, and potentially additional information.
377    ///
378    pub fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
379        match self {
380            Self::DbClusterNotFoundFault(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
381            Self::DbInstanceNotFoundFault(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
382            Self::IntegrationAlreadyExistsFault(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
383            Self::IntegrationConflictOperationFault(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
384            Self::IntegrationQuotaExceededFault(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
385            Self::KmsKeyNotAccessibleFault(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
386            Self::Unhandled(e) => &e.meta,
387        }
388    }
389    /// Returns `true` if the error kind is `CreateIntegrationError::DbClusterNotFoundFault`.
390    pub fn is_db_cluster_not_found_fault(&self) -> bool {
391        matches!(self, Self::DbClusterNotFoundFault(_))
392    }
393    /// Returns `true` if the error kind is `CreateIntegrationError::DbInstanceNotFoundFault`.
394    pub fn is_db_instance_not_found_fault(&self) -> bool {
395        matches!(self, Self::DbInstanceNotFoundFault(_))
396    }
397    /// Returns `true` if the error kind is `CreateIntegrationError::IntegrationAlreadyExistsFault`.
398    pub fn is_integration_already_exists_fault(&self) -> bool {
399        matches!(self, Self::IntegrationAlreadyExistsFault(_))
400    }
401    /// Returns `true` if the error kind is `CreateIntegrationError::IntegrationConflictOperationFault`.
402    pub fn is_integration_conflict_operation_fault(&self) -> bool {
403        matches!(self, Self::IntegrationConflictOperationFault(_))
404    }
405    /// Returns `true` if the error kind is `CreateIntegrationError::IntegrationQuotaExceededFault`.
406    pub fn is_integration_quota_exceeded_fault(&self) -> bool {
407        matches!(self, Self::IntegrationQuotaExceededFault(_))
408    }
409    /// Returns `true` if the error kind is `CreateIntegrationError::KmsKeyNotAccessibleFault`.
410    pub fn is_kms_key_not_accessible_fault(&self) -> bool {
411        matches!(self, Self::KmsKeyNotAccessibleFault(_))
412    }
413}
414impl ::std::error::Error for CreateIntegrationError {
415    fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
416        match self {
417            Self::DbClusterNotFoundFault(_inner) => ::std::option::Option::Some(_inner),
418            Self::DbInstanceNotFoundFault(_inner) => ::std::option::Option::Some(_inner),
419            Self::IntegrationAlreadyExistsFault(_inner) => ::std::option::Option::Some(_inner),
420            Self::IntegrationConflictOperationFault(_inner) => ::std::option::Option::Some(_inner),
421            Self::IntegrationQuotaExceededFault(_inner) => ::std::option::Option::Some(_inner),
422            Self::KmsKeyNotAccessibleFault(_inner) => ::std::option::Option::Some(_inner),
423            Self::Unhandled(_inner) => ::std::option::Option::Some(&*_inner.source),
424        }
425    }
426}
427impl ::std::fmt::Display for CreateIntegrationError {
428    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
429        match self {
430            Self::DbClusterNotFoundFault(_inner) => _inner.fmt(f),
431            Self::DbInstanceNotFoundFault(_inner) => _inner.fmt(f),
432            Self::IntegrationAlreadyExistsFault(_inner) => _inner.fmt(f),
433            Self::IntegrationConflictOperationFault(_inner) => _inner.fmt(f),
434            Self::IntegrationQuotaExceededFault(_inner) => _inner.fmt(f),
435            Self::KmsKeyNotAccessibleFault(_inner) => _inner.fmt(f),
436            Self::Unhandled(_inner) => {
437                if let ::std::option::Option::Some(code) = ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self) {
438                    write!(f, "unhandled error ({code})")
439                } else {
440                    f.write_str("unhandled error")
441                }
442            }
443        }
444    }
445}
446impl ::aws_smithy_types::retry::ProvideErrorKind for CreateIntegrationError {
447    fn code(&self) -> ::std::option::Option<&str> {
448        ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self)
449    }
450    fn retryable_error_kind(&self) -> ::std::option::Option<::aws_smithy_types::retry::ErrorKind> {
451        ::std::option::Option::None
452    }
453}
454impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for CreateIntegrationError {
455    fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
456        match self {
457            Self::DbClusterNotFoundFault(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
458            Self::DbInstanceNotFoundFault(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
459            Self::IntegrationAlreadyExistsFault(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
460            Self::IntegrationConflictOperationFault(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
461            Self::IntegrationQuotaExceededFault(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
462            Self::KmsKeyNotAccessibleFault(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
463            Self::Unhandled(_inner) => &_inner.meta,
464        }
465    }
466}
467impl ::aws_smithy_runtime_api::client::result::CreateUnhandledError for CreateIntegrationError {
468    fn create_unhandled_error(
469        source: ::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>,
470        meta: ::std::option::Option<::aws_smithy_types::error::ErrorMetadata>,
471    ) -> Self {
472        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
473            source,
474            meta: meta.unwrap_or_default(),
475        })
476    }
477}
478impl ::aws_types::request_id::RequestId for crate::operation::create_integration::CreateIntegrationError {
479    fn request_id(&self) -> Option<&str> {
480        self.meta().request_id()
481    }
482}
483
484pub use crate::operation::create_integration::_create_integration_input::CreateIntegrationInput;
485
486pub use crate::operation::create_integration::_create_integration_output::CreateIntegrationOutput;
487
488mod _create_integration_input;
489
490mod _create_integration_output;
491
492/// Builders
493pub mod builders;