aws_sdk_connect/
lib.rs

1#![allow(deprecated)]
2#![allow(unknown_lints)]
3#![allow(clippy::module_inception)]
4#![allow(clippy::upper_case_acronyms)]
5#![allow(clippy::large_enum_variant)]
6#![allow(clippy::wrong_self_convention)]
7#![allow(clippy::should_implement_trait)]
8#![allow(clippy::disallowed_names)]
9#![allow(clippy::vec_init_then_push)]
10#![allow(clippy::type_complexity)]
11#![allow(clippy::needless_return)]
12#![allow(clippy::derive_partial_eq_without_eq)]
13#![allow(clippy::result_large_err)]
14#![allow(clippy::unnecessary_map_on_constructor)]
15#![allow(rustdoc::bare_urls)]
16#![allow(rustdoc::redundant_explicit_links)]
17#![allow(rustdoc::invalid_html_tags)]
18#![forbid(unsafe_code)]
19#![warn(missing_docs)]
20#![cfg_attr(docsrs, feature(doc_auto_cfg))]
21//!   - [Amazon Connect actions](https://docs.aws.amazon.com/connect/latest/APIReference/API_Operations_Amazon_Connect_Service.html)
22//!   - [Amazon Connect data types](https://docs.aws.amazon.com/connect/latest/APIReference/API_Types_Amazon_Connect_Service.html)
23//!
24//! Amazon Connect is a cloud-based contact center solution that you use to set up and manage a customer contact center and provide reliable customer engagement at any scale.
25//!
26//! Amazon Connect provides metrics and real-time reporting that enable you to optimize contact routing. You can also resolve customer issues more efficiently by getting customers in touch with the appropriate agents.
27//!
28//! There are limits to the number of Amazon Connect resources that you can create. There are also limits to the number of requests that you can make per second. For more information, see [Amazon Connect Service Quotas](https://docs.aws.amazon.com/connect/latest/adminguide/amazon-connect-service-limits.html) in the _Amazon Connect Administrator Guide_.
29//!
30//! You can use an endpoint to connect programmatically to an Amazon Web Services service. For a list of Amazon Connect endpoints, see [Amazon Connect Endpoints](https://docs.aws.amazon.com/general/latest/gr/connect_region.html).
31//!
32//! ## Getting Started
33//!
34//! > Examples are available for many services and operations, check out the
35//! > [examples folder in GitHub](https://github.com/awslabs/aws-sdk-rust/tree/main/examples).
36//!
37//! The SDK provides one crate per AWS service. You must add [Tokio](https://crates.io/crates/tokio)
38//! as a dependency within your Rust project to execute asynchronous code. To add `aws-sdk-connect` to
39//! your project, add the following to your **Cargo.toml** file:
40//!
41//! ```toml
42//! [dependencies]
43//! aws-config = { version = "1.1.7", features = ["behavior-version-latest"] }
44//! aws-sdk-connect = "1.113.0"
45//! tokio = { version = "1", features = ["full"] }
46//! ```
47//!
48//! Then in code, a client can be created with the following:
49//!
50//! ```rust,no_run
51//! use aws_sdk_connect as connect;
52//!
53//! #[::tokio::main]
54//! async fn main() -> Result<(), connect::Error> {
55//!     let config = aws_config::load_from_env().await;
56//!     let client = aws_sdk_connect::Client::new(&config);
57//!
58//!     // ... make some calls with the client
59//!
60//!     Ok(())
61//! }
62//! ```
63//!
64//! See the [client documentation](https://docs.rs/aws-sdk-connect/latest/aws_sdk_connect/client/struct.Client.html)
65//! for information on what calls can be made, and the inputs and outputs for each of those calls.
66//!
67//! ## Using the SDK
68//!
69//! Until the SDK is released, we will be adding information about using the SDK to the
70//! [Developer Guide](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/welcome.html). Feel free to suggest
71//! additional sections for the guide by opening an issue and describing what you are trying to do.
72//!
73//! ## Getting Help
74//!
75//! * [GitHub discussions](https://github.com/awslabs/aws-sdk-rust/discussions) - For ideas, RFCs & general questions
76//! * [GitHub issues](https://github.com/awslabs/aws-sdk-rust/issues/new/choose) - For bug reports & feature requests
77//! * [Generated Docs (latest version)](https://awslabs.github.io/aws-sdk-rust/)
78//! * [Usage examples](https://github.com/awslabs/aws-sdk-rust/tree/main/examples)
79//!
80//!
81//! # Crate Organization
82//!
83//! The entry point for most customers will be [`Client`], which exposes one method for each API
84//! offered by Amazon Connect Service. The return value of each of these methods is a "fluent builder",
85//! where the different inputs for that API are added by builder-style function call chaining,
86//! followed by calling `send()` to get a [`Future`](std::future::Future) that will result in
87//! either a successful output or a [`SdkError`](crate::error::SdkError).
88//!
89//! Some of these API inputs may be structs or enums to provide more complex structured information.
90//! These structs and enums live in [`types`](crate::types). There are some simpler types for
91//! representing data such as date times or binary blobs that live in [`primitives`](crate::primitives).
92//!
93//! All types required to configure a client via the [`Config`](crate::Config) struct live
94//! in [`config`](crate::config).
95//!
96//! The [`operation`](crate::operation) module has a submodule for every API, and in each submodule
97//! is the input, output, and error type for that API, as well as builders to construct each of those.
98//!
99//! There is a top-level [`Error`](crate::Error) type that encompasses all the errors that the
100//! client can return. Any other error type can be converted to this `Error` type via the
101//! [`From`](std::convert::From) trait.
102//!
103//! The other modules within this crate are not required for normal usage.
104
105// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
106pub use error_meta::Error;
107
108#[doc(inline)]
109pub use config::Config;
110
111/// Client for calling Amazon Connect Service.
112/// ## Constructing a `Client`
113///
114/// A [`Config`] is required to construct a client. For most use cases, the [`aws-config`]
115/// crate should be used to automatically resolve this config using
116/// [`aws_config::load_from_env()`], since this will resolve an [`SdkConfig`] which can be shared
117/// across multiple different AWS SDK clients. This config resolution process can be customized
118/// by calling [`aws_config::from_env()`] instead, which returns a [`ConfigLoader`] that uses
119/// the [builder pattern] to customize the default config.
120///
121/// In the simplest case, creating a client looks as follows:
122/// ```rust,no_run
123/// # async fn wrapper() {
124/// let config = aws_config::load_from_env().await;
125/// let client = aws_sdk_connect::Client::new(&config);
126/// # }
127/// ```
128///
129/// Occasionally, SDKs may have additional service-specific values that can be set on the [`Config`] that
130/// is absent from [`SdkConfig`], or slightly different settings for a specific client may be desired.
131/// The [`Builder`](crate::config::Builder) struct implements `From<&SdkConfig>`, so setting these specific settings can be
132/// done as follows:
133///
134/// ```rust,no_run
135/// # async fn wrapper() {
136/// let sdk_config = ::aws_config::load_from_env().await;
137/// let config = aws_sdk_connect::config::Builder::from(&sdk_config)
138/// # /*
139///     .some_service_specific_setting("value")
140/// # */
141///     .build();
142/// # }
143/// ```
144///
145/// See the [`aws-config` docs] and [`Config`] for more information on customizing configuration.
146///
147/// _Note:_ Client construction is expensive due to connection thread pool initialization, and should
148/// be done once at application start-up.
149///
150/// [`Config`]: crate::Config
151/// [`ConfigLoader`]: https://docs.rs/aws-config/*/aws_config/struct.ConfigLoader.html
152/// [`SdkConfig`]: https://docs.rs/aws-config/*/aws_config/struct.SdkConfig.html
153/// [`aws-config` docs]: https://docs.rs/aws-config/*
154/// [`aws-config`]: https://crates.io/crates/aws-config
155/// [`aws_config::from_env()`]: https://docs.rs/aws-config/*/aws_config/fn.from_env.html
156/// [`aws_config::load_from_env()`]: https://docs.rs/aws-config/*/aws_config/fn.load_from_env.html
157/// [builder pattern]: https://rust-lang.github.io/api-guidelines/type-safety.html#builders-enable-construction-of-complex-values-c-builder
158/// # Using the `Client`
159///
160/// A client has a function for every operation that can be performed by the service.
161/// For example, the [`ActivateEvaluationForm`](crate::operation::activate_evaluation_form) operation has
162/// a [`Client::activate_evaluation_form`], function which returns a builder for that operation.
163/// The fluent builder ultimately has a `send()` function that returns an async future that
164/// returns a result, as illustrated below:
165///
166/// ```rust,ignore
167/// let result = client.activate_evaluation_form()
168///     .instance_id("example")
169///     .send()
170///     .await;
171/// ```
172///
173/// The underlying HTTP requests that get made by this can be modified with the `customize_operation`
174/// function on the fluent builder. See the [`customize`](crate::client::customize) module for more
175/// information.
176pub mod client;
177
178/// Configuration for Amazon Connect Service.
179pub mod config;
180
181/// Common errors and error handling utilities.
182pub mod error;
183
184mod error_meta;
185
186/// Information about this crate.
187pub mod meta;
188
189/// All operations that this crate can perform.
190pub mod operation;
191
192/// Primitives such as `Blob` or `DateTime` used by other types.
193pub mod primitives;
194
195/// Data structures used by operation inputs/outputs.
196pub mod types;
197
198mod auth_plugin;
199
200pub(crate) mod client_idempotency_token;
201
202mod idempotency_token;
203
204pub(crate) mod protocol_serde;
205
206mod sdk_feature_tracker;
207
208mod serialization_settings;
209
210mod endpoint_lib;
211
212mod lens;
213
214mod serde_util;
215
216mod json_errors;
217
218#[doc(inline)]
219pub use client::Client;