#[derive(Debug)]
pub(crate) struct Handle<
C = aws_smithy_client::erase::DynConnector,
M = crate::middleware::DefaultMiddleware,
R = aws_smithy_client::retry::Standard,
> {
client: aws_smithy_client::Client<C, M, R>,
conf: crate::Config,
}
#[derive(std::fmt::Debug)]
pub struct Client<
C = aws_smithy_client::erase::DynConnector,
M = crate::middleware::DefaultMiddleware,
R = aws_smithy_client::retry::Standard,
> {
handle: std::sync::Arc<Handle<C, M, R>>,
}
impl<C, M, R> std::clone::Clone for Client<C, M, R> {
fn clone(&self) -> Self {
Self {
handle: self.handle.clone(),
}
}
}
#[doc(inline)]
pub use aws_smithy_client::Builder;
impl<C, M, R> From<aws_smithy_client::Client<C, M, R>> for Client<C, M, R> {
fn from(client: aws_smithy_client::Client<C, M, R>) -> Self {
Self::with_config(client, crate::Config::builder().build())
}
}
impl<C, M, R> Client<C, M, R> {
pub fn with_config(client: aws_smithy_client::Client<C, M, R>, conf: crate::Config) -> Self {
Self {
handle: std::sync::Arc::new(Handle { client, conf }),
}
}
pub fn conf(&self) -> &crate::Config {
&self.handle.conf
}
}
impl<C, M, R> Client<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
pub fn get_ice_server_config(&self) -> fluent_builders::GetIceServerConfig<C, M, R> {
fluent_builders::GetIceServerConfig::new(self.handle.clone())
}
pub fn send_alexa_offer_to_master(&self) -> fluent_builders::SendAlexaOfferToMaster<C, M, R> {
fluent_builders::SendAlexaOfferToMaster::new(self.handle.clone())
}
}
pub mod fluent_builders {
#[derive(std::fmt::Debug)]
pub struct GetIceServerConfig<
C = aws_smithy_client::erase::DynConnector,
M = crate::middleware::DefaultMiddleware,
R = aws_smithy_client::retry::Standard,
> {
handle: std::sync::Arc<super::Handle<C, M, R>>,
inner: crate::input::get_ice_server_config_input::Builder,
}
impl<C, M, R> GetIceServerConfig<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
Self {
handle,
inner: Default::default(),
}
}
pub async fn send(
self,
) -> std::result::Result<
crate::output::GetIceServerConfigOutput,
aws_smithy_http::result::SdkError<crate::error::GetIceServerConfigError>,
>
where
R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
crate::input::GetIceServerConfigInputOperationOutputAlias,
crate::output::GetIceServerConfigOutput,
crate::error::GetIceServerConfigError,
crate::input::GetIceServerConfigInputOperationRetryAlias,
>,
{
let input = self.inner.build().map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
let op = input
.make_operation(&self.handle.conf)
.await
.map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
self.handle.client.call(op).await
}
pub fn channel_arn(mut self, inp: impl Into<std::string::String>) -> Self {
self.inner = self.inner.channel_arn(inp);
self
}
pub fn set_channel_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.inner = self.inner.set_channel_arn(input);
self
}
pub fn client_id(mut self, inp: impl Into<std::string::String>) -> Self {
self.inner = self.inner.client_id(inp);
self
}
pub fn set_client_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.inner = self.inner.set_client_id(input);
self
}
pub fn service(mut self, inp: crate::model::Service) -> Self {
self.inner = self.inner.service(inp);
self
}
pub fn set_service(mut self, input: std::option::Option<crate::model::Service>) -> Self {
self.inner = self.inner.set_service(input);
self
}
pub fn username(mut self, inp: impl Into<std::string::String>) -> Self {
self.inner = self.inner.username(inp);
self
}
pub fn set_username(mut self, input: std::option::Option<std::string::String>) -> Self {
self.inner = self.inner.set_username(input);
self
}
}
#[derive(std::fmt::Debug)]
pub struct SendAlexaOfferToMaster<
C = aws_smithy_client::erase::DynConnector,
M = crate::middleware::DefaultMiddleware,
R = aws_smithy_client::retry::Standard,
> {
handle: std::sync::Arc<super::Handle<C, M, R>>,
inner: crate::input::send_alexa_offer_to_master_input::Builder,
}
impl<C, M, R> SendAlexaOfferToMaster<C, M, R>
where
C: aws_smithy_client::bounds::SmithyConnector,
M: aws_smithy_client::bounds::SmithyMiddleware<C>,
R: aws_smithy_client::retry::NewRequestPolicy,
{
pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
Self {
handle,
inner: Default::default(),
}
}
pub async fn send(
self,
) -> std::result::Result<
crate::output::SendAlexaOfferToMasterOutput,
aws_smithy_http::result::SdkError<crate::error::SendAlexaOfferToMasterError>,
>
where
R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
crate::input::SendAlexaOfferToMasterInputOperationOutputAlias,
crate::output::SendAlexaOfferToMasterOutput,
crate::error::SendAlexaOfferToMasterError,
crate::input::SendAlexaOfferToMasterInputOperationRetryAlias,
>,
{
let input = self.inner.build().map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
let op = input
.make_operation(&self.handle.conf)
.await
.map_err(|err| {
aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
})?;
self.handle.client.call(op).await
}
pub fn channel_arn(mut self, inp: impl Into<std::string::String>) -> Self {
self.inner = self.inner.channel_arn(inp);
self
}
pub fn set_channel_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.inner = self.inner.set_channel_arn(input);
self
}
pub fn sender_client_id(mut self, inp: impl Into<std::string::String>) -> Self {
self.inner = self.inner.sender_client_id(inp);
self
}
pub fn set_sender_client_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.inner = self.inner.set_sender_client_id(input);
self
}
pub fn message_payload(mut self, inp: impl Into<std::string::String>) -> Self {
self.inner = self.inner.message_payload(inp);
self
}
pub fn set_message_payload(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.inner = self.inner.set_message_payload(input);
self
}
}
}
impl<C> Client<C, crate::middleware::DefaultMiddleware, aws_smithy_client::retry::Standard> {
pub fn from_conf_conn(conf: crate::Config, conn: C) -> Self {
let retry_config = conf.retry_config.as_ref().cloned().unwrap_or_default();
let timeout_config = conf.timeout_config.as_ref().cloned().unwrap_or_default();
let sleep_impl = conf.sleep_impl.clone();
let mut builder = aws_smithy_client::Builder::new()
.connector(conn)
.middleware(crate::middleware::DefaultMiddleware::new());
builder.set_retry_config(retry_config.into());
builder.set_timeout_config(timeout_config);
if let Some(sleep_impl) = sleep_impl {
builder.set_sleep_impl(Some(sleep_impl));
}
let client = builder.build();
Self {
handle: std::sync::Arc::new(Handle { client, conf }),
}
}
}
impl
Client<
aws_smithy_client::erase::DynConnector,
crate::middleware::DefaultMiddleware,
aws_smithy_client::retry::Standard,
>
{
#[cfg(any(feature = "rustls", feature = "native-tls"))]
pub fn new(config: &aws_types::config::Config) -> Self {
Self::from_conf(config.into())
}
#[cfg(any(feature = "rustls", feature = "native-tls"))]
pub fn from_conf(conf: crate::Config) -> Self {
let retry_config = conf.retry_config.as_ref().cloned().unwrap_or_default();
let timeout_config = conf.timeout_config.as_ref().cloned().unwrap_or_default();
let sleep_impl = conf.sleep_impl.clone();
let mut builder = aws_smithy_client::Builder::dyn_https()
.middleware(crate::middleware::DefaultMiddleware::new());
builder.set_retry_config(retry_config.into());
builder.set_timeout_config(timeout_config);
if let Some(sleep_impl) = sleep_impl {
builder.set_sleep_impl(Some(sleep_impl));
}
let client = builder.build();
Self {
handle: std::sync::Arc::new(Handle { client, conf }),
}
}
}