use std::fmt::Write;
pub mod approve_skill_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) skill_id: std::option::Option<std::string::String>,
}
impl Builder {
pub fn skill_id(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_id = Some(input.into());
self
}
pub fn set_skill_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.skill_id = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::ApproveSkillInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::ApproveSkillInput {
skill_id: self.skill_id,
})
}
}
}
#[doc(hidden)]
pub type ApproveSkillInputOperationOutputAlias = crate::operation::ApproveSkill;
#[doc(hidden)]
pub type ApproveSkillInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl ApproveSkillInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ApproveSkill,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::ApproveSkillInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ApproveSkillInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::ApproveSkillInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.ApproveSkill",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_approve_skill(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ApproveSkill::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ApproveSkill",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::approve_skill_input::Builder {
crate::input::approve_skill_input::Builder::default()
}
}
pub mod associate_contact_with_address_book_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) contact_arn: std::option::Option<std::string::String>,
pub(crate) address_book_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn contact_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.contact_arn = Some(input.into());
self
}
pub fn set_contact_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.contact_arn = input;
self
}
pub fn address_book_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.address_book_arn = Some(input.into());
self
}
pub fn set_address_book_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.address_book_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::AssociateContactWithAddressBookInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::AssociateContactWithAddressBookInput {
contact_arn: self.contact_arn,
address_book_arn: self.address_book_arn,
})
}
}
}
#[doc(hidden)]
pub type AssociateContactWithAddressBookInputOperationOutputAlias =
crate::operation::AssociateContactWithAddressBook;
#[doc(hidden)]
pub type AssociateContactWithAddressBookInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl AssociateContactWithAddressBookInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::AssociateContactWithAddressBook,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::AssociateContactWithAddressBookInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::AssociateContactWithAddressBookInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::AssociateContactWithAddressBookInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.AssociateContactWithAddressBook",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_associate_contact_with_address_book(&self)?
;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::AssociateContactWithAddressBook::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"AssociateContactWithAddressBook",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::associate_contact_with_address_book_input::Builder {
crate::input::associate_contact_with_address_book_input::Builder::default()
}
}
pub mod associate_device_with_network_profile_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) device_arn: std::option::Option<std::string::String>,
pub(crate) network_profile_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn device_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.device_arn = Some(input.into());
self
}
pub fn set_device_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.device_arn = input;
self
}
pub fn network_profile_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.network_profile_arn = Some(input.into());
self
}
pub fn set_network_profile_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.network_profile_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::AssociateDeviceWithNetworkProfileInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::AssociateDeviceWithNetworkProfileInput {
device_arn: self.device_arn,
network_profile_arn: self.network_profile_arn,
})
}
}
}
#[doc(hidden)]
pub type AssociateDeviceWithNetworkProfileInputOperationOutputAlias =
crate::operation::AssociateDeviceWithNetworkProfile;
#[doc(hidden)]
pub type AssociateDeviceWithNetworkProfileInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl AssociateDeviceWithNetworkProfileInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::AssociateDeviceWithNetworkProfile,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::AssociateDeviceWithNetworkProfileInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::AssociateDeviceWithNetworkProfileInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::AssociateDeviceWithNetworkProfileInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.AssociateDeviceWithNetworkProfile",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_associate_device_with_network_profile(&self)?
;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::AssociateDeviceWithNetworkProfile::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"AssociateDeviceWithNetworkProfile",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::associate_device_with_network_profile_input::Builder {
crate::input::associate_device_with_network_profile_input::Builder::default()
}
}
pub mod associate_device_with_room_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) device_arn: std::option::Option<std::string::String>,
pub(crate) room_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn device_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.device_arn = Some(input.into());
self
}
pub fn set_device_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.device_arn = input;
self
}
pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.room_arn = Some(input.into());
self
}
pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::AssociateDeviceWithRoomInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::AssociateDeviceWithRoomInput {
device_arn: self.device_arn,
room_arn: self.room_arn,
})
}
}
}
#[doc(hidden)]
pub type AssociateDeviceWithRoomInputOperationOutputAlias =
crate::operation::AssociateDeviceWithRoom;
#[doc(hidden)]
pub type AssociateDeviceWithRoomInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl AssociateDeviceWithRoomInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::AssociateDeviceWithRoom,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::AssociateDeviceWithRoomInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::AssociateDeviceWithRoomInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::AssociateDeviceWithRoomInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.AssociateDeviceWithRoom",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_associate_device_with_room(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::AssociateDeviceWithRoom::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"AssociateDeviceWithRoom",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::associate_device_with_room_input::Builder {
crate::input::associate_device_with_room_input::Builder::default()
}
}
pub mod associate_skill_group_with_room_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) skill_group_arn: std::option::Option<std::string::String>,
pub(crate) room_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn skill_group_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_group_arn = Some(input.into());
self
}
pub fn set_skill_group_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.skill_group_arn = input;
self
}
pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.room_arn = Some(input.into());
self
}
pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::AssociateSkillGroupWithRoomInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::AssociateSkillGroupWithRoomInput {
skill_group_arn: self.skill_group_arn,
room_arn: self.room_arn,
})
}
}
}
#[doc(hidden)]
pub type AssociateSkillGroupWithRoomInputOperationOutputAlias =
crate::operation::AssociateSkillGroupWithRoom;
#[doc(hidden)]
pub type AssociateSkillGroupWithRoomInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl AssociateSkillGroupWithRoomInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::AssociateSkillGroupWithRoom,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::AssociateSkillGroupWithRoomInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::AssociateSkillGroupWithRoomInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::AssociateSkillGroupWithRoomInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.AssociateSkillGroupWithRoom",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_associate_skill_group_with_room(&self)?
;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::AssociateSkillGroupWithRoom::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"AssociateSkillGroupWithRoom",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::associate_skill_group_with_room_input::Builder {
crate::input::associate_skill_group_with_room_input::Builder::default()
}
}
pub mod associate_skill_with_skill_group_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) skill_group_arn: std::option::Option<std::string::String>,
pub(crate) skill_id: std::option::Option<std::string::String>,
}
impl Builder {
pub fn skill_group_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_group_arn = Some(input.into());
self
}
pub fn set_skill_group_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.skill_group_arn = input;
self
}
pub fn skill_id(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_id = Some(input.into());
self
}
pub fn set_skill_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.skill_id = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::AssociateSkillWithSkillGroupInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::AssociateSkillWithSkillGroupInput {
skill_group_arn: self.skill_group_arn,
skill_id: self.skill_id,
})
}
}
}
#[doc(hidden)]
pub type AssociateSkillWithSkillGroupInputOperationOutputAlias =
crate::operation::AssociateSkillWithSkillGroup;
#[doc(hidden)]
pub type AssociateSkillWithSkillGroupInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl AssociateSkillWithSkillGroupInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::AssociateSkillWithSkillGroup,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::AssociateSkillWithSkillGroupInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::AssociateSkillWithSkillGroupInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::AssociateSkillWithSkillGroupInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.AssociateSkillWithSkillGroup",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_associate_skill_with_skill_group(&self)?
;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::AssociateSkillWithSkillGroup::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"AssociateSkillWithSkillGroup",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::associate_skill_with_skill_group_input::Builder {
crate::input::associate_skill_with_skill_group_input::Builder::default()
}
}
pub mod associate_skill_with_users_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) skill_id: std::option::Option<std::string::String>,
}
impl Builder {
pub fn skill_id(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_id = Some(input.into());
self
}
pub fn set_skill_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.skill_id = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::AssociateSkillWithUsersInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::AssociateSkillWithUsersInput {
skill_id: self.skill_id,
})
}
}
}
#[doc(hidden)]
pub type AssociateSkillWithUsersInputOperationOutputAlias =
crate::operation::AssociateSkillWithUsers;
#[doc(hidden)]
pub type AssociateSkillWithUsersInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl AssociateSkillWithUsersInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::AssociateSkillWithUsers,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::AssociateSkillWithUsersInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::AssociateSkillWithUsersInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::AssociateSkillWithUsersInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.AssociateSkillWithUsers",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_associate_skill_with_users(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::AssociateSkillWithUsers::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"AssociateSkillWithUsers",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::associate_skill_with_users_input::Builder {
crate::input::associate_skill_with_users_input::Builder::default()
}
}
pub mod create_address_book_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) client_request_token: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn client_request_token(mut self, input: impl Into<std::string::String>) -> Self {
self.client_request_token = Some(input.into());
self
}
pub fn set_client_request_token(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.client_request_token = input;
self
}
pub fn tags(mut self, input: impl Into<crate::model::Tag>) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input.into());
self.tags = Some(v);
self
}
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::CreateAddressBookInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::CreateAddressBookInput {
name: self.name,
description: self.description,
client_request_token: self.client_request_token,
tags: self.tags,
})
}
}
}
#[doc(hidden)]
pub type CreateAddressBookInputOperationOutputAlias = crate::operation::CreateAddressBook;
#[doc(hidden)]
pub type CreateAddressBookInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl CreateAddressBookInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
mut self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateAddressBook,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::CreateAddressBookInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateAddressBookInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::CreateAddressBookInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.CreateAddressBook",
);
Ok(builder)
}
if self.client_request_token.is_none() {
self.client_request_token = Some(_config.make_token.make_idempotency_token());
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_create_address_book(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateAddressBook::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateAddressBook",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::create_address_book_input::Builder {
crate::input::create_address_book_input::Builder::default()
}
}
pub mod create_business_report_schedule_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) schedule_name: std::option::Option<std::string::String>,
pub(crate) s3_bucket_name: std::option::Option<std::string::String>,
pub(crate) s3_key_prefix: std::option::Option<std::string::String>,
pub(crate) format: std::option::Option<crate::model::BusinessReportFormat>,
pub(crate) content_range: std::option::Option<crate::model::BusinessReportContentRange>,
pub(crate) recurrence: std::option::Option<crate::model::BusinessReportRecurrence>,
pub(crate) client_request_token: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
pub fn schedule_name(mut self, input: impl Into<std::string::String>) -> Self {
self.schedule_name = Some(input.into());
self
}
pub fn set_schedule_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.schedule_name = input;
self
}
pub fn s3_bucket_name(mut self, input: impl Into<std::string::String>) -> Self {
self.s3_bucket_name = Some(input.into());
self
}
pub fn set_s3_bucket_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.s3_bucket_name = input;
self
}
pub fn s3_key_prefix(mut self, input: impl Into<std::string::String>) -> Self {
self.s3_key_prefix = Some(input.into());
self
}
pub fn set_s3_key_prefix(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.s3_key_prefix = input;
self
}
pub fn format(mut self, input: crate::model::BusinessReportFormat) -> Self {
self.format = Some(input);
self
}
pub fn set_format(
mut self,
input: std::option::Option<crate::model::BusinessReportFormat>,
) -> Self {
self.format = input;
self
}
pub fn content_range(mut self, input: crate::model::BusinessReportContentRange) -> Self {
self.content_range = Some(input);
self
}
pub fn set_content_range(
mut self,
input: std::option::Option<crate::model::BusinessReportContentRange>,
) -> Self {
self.content_range = input;
self
}
pub fn recurrence(mut self, input: crate::model::BusinessReportRecurrence) -> Self {
self.recurrence = Some(input);
self
}
pub fn set_recurrence(
mut self,
input: std::option::Option<crate::model::BusinessReportRecurrence>,
) -> Self {
self.recurrence = input;
self
}
pub fn client_request_token(mut self, input: impl Into<std::string::String>) -> Self {
self.client_request_token = Some(input.into());
self
}
pub fn set_client_request_token(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.client_request_token = input;
self
}
pub fn tags(mut self, input: impl Into<crate::model::Tag>) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input.into());
self.tags = Some(v);
self
}
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::CreateBusinessReportScheduleInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::CreateBusinessReportScheduleInput {
schedule_name: self.schedule_name,
s3_bucket_name: self.s3_bucket_name,
s3_key_prefix: self.s3_key_prefix,
format: self.format,
content_range: self.content_range,
recurrence: self.recurrence,
client_request_token: self.client_request_token,
tags: self.tags,
})
}
}
}
#[doc(hidden)]
pub type CreateBusinessReportScheduleInputOperationOutputAlias =
crate::operation::CreateBusinessReportSchedule;
#[doc(hidden)]
pub type CreateBusinessReportScheduleInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl CreateBusinessReportScheduleInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
mut self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateBusinessReportSchedule,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::CreateBusinessReportScheduleInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateBusinessReportScheduleInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::CreateBusinessReportScheduleInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.CreateBusinessReportSchedule",
);
Ok(builder)
}
if self.client_request_token.is_none() {
self.client_request_token = Some(_config.make_token.make_idempotency_token());
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_create_business_report_schedule(&self)?
;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateBusinessReportSchedule::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateBusinessReportSchedule",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::create_business_report_schedule_input::Builder {
crate::input::create_business_report_schedule_input::Builder::default()
}
}
pub mod create_conference_provider_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) conference_provider_name: std::option::Option<std::string::String>,
pub(crate) conference_provider_type:
std::option::Option<crate::model::ConferenceProviderType>,
pub(crate) ip_dial_in: std::option::Option<crate::model::IpDialIn>,
pub(crate) pstn_dial_in: std::option::Option<crate::model::PstnDialIn>,
pub(crate) meeting_setting: std::option::Option<crate::model::MeetingSetting>,
pub(crate) client_request_token: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
pub fn conference_provider_name(mut self, input: impl Into<std::string::String>) -> Self {
self.conference_provider_name = Some(input.into());
self
}
pub fn set_conference_provider_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.conference_provider_name = input;
self
}
pub fn conference_provider_type(
mut self,
input: crate::model::ConferenceProviderType,
) -> Self {
self.conference_provider_type = Some(input);
self
}
pub fn set_conference_provider_type(
mut self,
input: std::option::Option<crate::model::ConferenceProviderType>,
) -> Self {
self.conference_provider_type = input;
self
}
pub fn ip_dial_in(mut self, input: crate::model::IpDialIn) -> Self {
self.ip_dial_in = Some(input);
self
}
pub fn set_ip_dial_in(
mut self,
input: std::option::Option<crate::model::IpDialIn>,
) -> Self {
self.ip_dial_in = input;
self
}
pub fn pstn_dial_in(mut self, input: crate::model::PstnDialIn) -> Self {
self.pstn_dial_in = Some(input);
self
}
pub fn set_pstn_dial_in(
mut self,
input: std::option::Option<crate::model::PstnDialIn>,
) -> Self {
self.pstn_dial_in = input;
self
}
pub fn meeting_setting(mut self, input: crate::model::MeetingSetting) -> Self {
self.meeting_setting = Some(input);
self
}
pub fn set_meeting_setting(
mut self,
input: std::option::Option<crate::model::MeetingSetting>,
) -> Self {
self.meeting_setting = input;
self
}
pub fn client_request_token(mut self, input: impl Into<std::string::String>) -> Self {
self.client_request_token = Some(input.into());
self
}
pub fn set_client_request_token(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.client_request_token = input;
self
}
pub fn tags(mut self, input: impl Into<crate::model::Tag>) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input.into());
self.tags = Some(v);
self
}
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::CreateConferenceProviderInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::CreateConferenceProviderInput {
conference_provider_name: self.conference_provider_name,
conference_provider_type: self.conference_provider_type,
ip_dial_in: self.ip_dial_in,
pstn_dial_in: self.pstn_dial_in,
meeting_setting: self.meeting_setting,
client_request_token: self.client_request_token,
tags: self.tags,
})
}
}
}
#[doc(hidden)]
pub type CreateConferenceProviderInputOperationOutputAlias =
crate::operation::CreateConferenceProvider;
#[doc(hidden)]
pub type CreateConferenceProviderInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl CreateConferenceProviderInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
mut self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateConferenceProvider,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::CreateConferenceProviderInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateConferenceProviderInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::CreateConferenceProviderInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.CreateConferenceProvider",
);
Ok(builder)
}
if self.client_request_token.is_none() {
self.client_request_token = Some(_config.make_token.make_idempotency_token());
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_create_conference_provider(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateConferenceProvider::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateConferenceProvider",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::create_conference_provider_input::Builder {
crate::input::create_conference_provider_input::Builder::default()
}
}
pub mod create_contact_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) display_name: std::option::Option<std::string::String>,
pub(crate) first_name: std::option::Option<std::string::String>,
pub(crate) last_name: std::option::Option<std::string::String>,
pub(crate) phone_number: std::option::Option<std::string::String>,
pub(crate) phone_numbers: std::option::Option<std::vec::Vec<crate::model::PhoneNumber>>,
pub(crate) sip_addresses: std::option::Option<std::vec::Vec<crate::model::SipAddress>>,
pub(crate) client_request_token: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
pub fn display_name(mut self, input: impl Into<std::string::String>) -> Self {
self.display_name = Some(input.into());
self
}
pub fn set_display_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.display_name = input;
self
}
pub fn first_name(mut self, input: impl Into<std::string::String>) -> Self {
self.first_name = Some(input.into());
self
}
pub fn set_first_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.first_name = input;
self
}
pub fn last_name(mut self, input: impl Into<std::string::String>) -> Self {
self.last_name = Some(input.into());
self
}
pub fn set_last_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.last_name = input;
self
}
pub fn phone_number(mut self, input: impl Into<std::string::String>) -> Self {
self.phone_number = Some(input.into());
self
}
pub fn set_phone_number(mut self, input: std::option::Option<std::string::String>) -> Self {
self.phone_number = input;
self
}
pub fn phone_numbers(mut self, input: impl Into<crate::model::PhoneNumber>) -> Self {
let mut v = self.phone_numbers.unwrap_or_default();
v.push(input.into());
self.phone_numbers = Some(v);
self
}
pub fn set_phone_numbers(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::PhoneNumber>>,
) -> Self {
self.phone_numbers = input;
self
}
pub fn sip_addresses(mut self, input: impl Into<crate::model::SipAddress>) -> Self {
let mut v = self.sip_addresses.unwrap_or_default();
v.push(input.into());
self.sip_addresses = Some(v);
self
}
pub fn set_sip_addresses(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::SipAddress>>,
) -> Self {
self.sip_addresses = input;
self
}
pub fn client_request_token(mut self, input: impl Into<std::string::String>) -> Self {
self.client_request_token = Some(input.into());
self
}
pub fn set_client_request_token(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.client_request_token = input;
self
}
pub fn tags(mut self, input: impl Into<crate::model::Tag>) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input.into());
self.tags = Some(v);
self
}
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::CreateContactInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::CreateContactInput {
display_name: self.display_name,
first_name: self.first_name,
last_name: self.last_name,
phone_number: self.phone_number,
phone_numbers: self.phone_numbers,
sip_addresses: self.sip_addresses,
client_request_token: self.client_request_token,
tags: self.tags,
})
}
}
}
#[doc(hidden)]
pub type CreateContactInputOperationOutputAlias = crate::operation::CreateContact;
#[doc(hidden)]
pub type CreateContactInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl CreateContactInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
mut self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateContact,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::CreateContactInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateContactInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::CreateContactInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.CreateContact",
);
Ok(builder)
}
if self.client_request_token.is_none() {
self.client_request_token = Some(_config.make_token.make_idempotency_token());
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_create_contact(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateContact::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateContact",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::create_contact_input::Builder {
crate::input::create_contact_input::Builder::default()
}
}
pub mod create_gateway_group_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) client_request_token: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn client_request_token(mut self, input: impl Into<std::string::String>) -> Self {
self.client_request_token = Some(input.into());
self
}
pub fn set_client_request_token(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.client_request_token = input;
self
}
pub fn tags(mut self, input: impl Into<crate::model::Tag>) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input.into());
self.tags = Some(v);
self
}
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::CreateGatewayGroupInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::CreateGatewayGroupInput {
name: self.name,
description: self.description,
client_request_token: self.client_request_token,
tags: self.tags,
})
}
}
}
#[doc(hidden)]
pub type CreateGatewayGroupInputOperationOutputAlias = crate::operation::CreateGatewayGroup;
#[doc(hidden)]
pub type CreateGatewayGroupInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl CreateGatewayGroupInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
mut self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateGatewayGroup,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::CreateGatewayGroupInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateGatewayGroupInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::CreateGatewayGroupInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.CreateGatewayGroup",
);
Ok(builder)
}
if self.client_request_token.is_none() {
self.client_request_token = Some(_config.make_token.make_idempotency_token());
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_create_gateway_group(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateGatewayGroup::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateGatewayGroup",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::create_gateway_group_input::Builder {
crate::input::create_gateway_group_input::Builder::default()
}
}
pub mod create_network_profile_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) network_profile_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) ssid: std::option::Option<std::string::String>,
pub(crate) security_type: std::option::Option<crate::model::NetworkSecurityType>,
pub(crate) eap_method: std::option::Option<crate::model::NetworkEapMethod>,
pub(crate) current_password: std::option::Option<std::string::String>,
pub(crate) next_password: std::option::Option<std::string::String>,
pub(crate) certificate_authority_arn: std::option::Option<std::string::String>,
pub(crate) trust_anchors: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) client_request_token: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
pub fn network_profile_name(mut self, input: impl Into<std::string::String>) -> Self {
self.network_profile_name = Some(input.into());
self
}
pub fn set_network_profile_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.network_profile_name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn ssid(mut self, input: impl Into<std::string::String>) -> Self {
self.ssid = Some(input.into());
self
}
pub fn set_ssid(mut self, input: std::option::Option<std::string::String>) -> Self {
self.ssid = input;
self
}
pub fn security_type(mut self, input: crate::model::NetworkSecurityType) -> Self {
self.security_type = Some(input);
self
}
pub fn set_security_type(
mut self,
input: std::option::Option<crate::model::NetworkSecurityType>,
) -> Self {
self.security_type = input;
self
}
pub fn eap_method(mut self, input: crate::model::NetworkEapMethod) -> Self {
self.eap_method = Some(input);
self
}
pub fn set_eap_method(
mut self,
input: std::option::Option<crate::model::NetworkEapMethod>,
) -> Self {
self.eap_method = input;
self
}
pub fn current_password(mut self, input: impl Into<std::string::String>) -> Self {
self.current_password = Some(input.into());
self
}
pub fn set_current_password(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.current_password = input;
self
}
pub fn next_password(mut self, input: impl Into<std::string::String>) -> Self {
self.next_password = Some(input.into());
self
}
pub fn set_next_password(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.next_password = input;
self
}
pub fn certificate_authority_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.certificate_authority_arn = Some(input.into());
self
}
pub fn set_certificate_authority_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.certificate_authority_arn = input;
self
}
pub fn trust_anchors(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.trust_anchors.unwrap_or_default();
v.push(input.into());
self.trust_anchors = Some(v);
self
}
pub fn set_trust_anchors(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.trust_anchors = input;
self
}
pub fn client_request_token(mut self, input: impl Into<std::string::String>) -> Self {
self.client_request_token = Some(input.into());
self
}
pub fn set_client_request_token(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.client_request_token = input;
self
}
pub fn tags(mut self, input: impl Into<crate::model::Tag>) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input.into());
self.tags = Some(v);
self
}
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::CreateNetworkProfileInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::CreateNetworkProfileInput {
network_profile_name: self.network_profile_name,
description: self.description,
ssid: self.ssid,
security_type: self.security_type,
eap_method: self.eap_method,
current_password: self.current_password,
next_password: self.next_password,
certificate_authority_arn: self.certificate_authority_arn,
trust_anchors: self.trust_anchors,
client_request_token: self.client_request_token,
tags: self.tags,
})
}
}
}
#[doc(hidden)]
pub type CreateNetworkProfileInputOperationOutputAlias = crate::operation::CreateNetworkProfile;
#[doc(hidden)]
pub type CreateNetworkProfileInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl CreateNetworkProfileInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
mut self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateNetworkProfile,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::CreateNetworkProfileInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateNetworkProfileInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::CreateNetworkProfileInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.CreateNetworkProfile",
);
Ok(builder)
}
if self.client_request_token.is_none() {
self.client_request_token = Some(_config.make_token.make_idempotency_token());
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_create_network_profile(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateNetworkProfile::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateNetworkProfile",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::create_network_profile_input::Builder {
crate::input::create_network_profile_input::Builder::default()
}
}
pub mod create_profile_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) profile_name: std::option::Option<std::string::String>,
pub(crate) timezone: std::option::Option<std::string::String>,
pub(crate) address: std::option::Option<std::string::String>,
pub(crate) distance_unit: std::option::Option<crate::model::DistanceUnit>,
pub(crate) temperature_unit: std::option::Option<crate::model::TemperatureUnit>,
pub(crate) wake_word: std::option::Option<crate::model::WakeWord>,
pub(crate) locale: std::option::Option<std::string::String>,
pub(crate) client_request_token: std::option::Option<std::string::String>,
pub(crate) setup_mode_disabled: std::option::Option<bool>,
pub(crate) max_volume_limit: std::option::Option<i32>,
pub(crate) pstn_enabled: std::option::Option<bool>,
pub(crate) data_retention_opt_in: std::option::Option<bool>,
pub(crate) meeting_room_configuration:
std::option::Option<crate::model::CreateMeetingRoomConfiguration>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
pub fn profile_name(mut self, input: impl Into<std::string::String>) -> Self {
self.profile_name = Some(input.into());
self
}
pub fn set_profile_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.profile_name = input;
self
}
pub fn timezone(mut self, input: impl Into<std::string::String>) -> Self {
self.timezone = Some(input.into());
self
}
pub fn set_timezone(mut self, input: std::option::Option<std::string::String>) -> Self {
self.timezone = input;
self
}
pub fn address(mut self, input: impl Into<std::string::String>) -> Self {
self.address = Some(input.into());
self
}
pub fn set_address(mut self, input: std::option::Option<std::string::String>) -> Self {
self.address = input;
self
}
pub fn distance_unit(mut self, input: crate::model::DistanceUnit) -> Self {
self.distance_unit = Some(input);
self
}
pub fn set_distance_unit(
mut self,
input: std::option::Option<crate::model::DistanceUnit>,
) -> Self {
self.distance_unit = input;
self
}
pub fn temperature_unit(mut self, input: crate::model::TemperatureUnit) -> Self {
self.temperature_unit = Some(input);
self
}
pub fn set_temperature_unit(
mut self,
input: std::option::Option<crate::model::TemperatureUnit>,
) -> Self {
self.temperature_unit = input;
self
}
pub fn wake_word(mut self, input: crate::model::WakeWord) -> Self {
self.wake_word = Some(input);
self
}
pub fn set_wake_word(mut self, input: std::option::Option<crate::model::WakeWord>) -> Self {
self.wake_word = input;
self
}
pub fn locale(mut self, input: impl Into<std::string::String>) -> Self {
self.locale = Some(input.into());
self
}
pub fn set_locale(mut self, input: std::option::Option<std::string::String>) -> Self {
self.locale = input;
self
}
pub fn client_request_token(mut self, input: impl Into<std::string::String>) -> Self {
self.client_request_token = Some(input.into());
self
}
pub fn set_client_request_token(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.client_request_token = input;
self
}
pub fn setup_mode_disabled(mut self, input: bool) -> Self {
self.setup_mode_disabled = Some(input);
self
}
pub fn set_setup_mode_disabled(mut self, input: std::option::Option<bool>) -> Self {
self.setup_mode_disabled = input;
self
}
pub fn max_volume_limit(mut self, input: i32) -> Self {
self.max_volume_limit = Some(input);
self
}
pub fn set_max_volume_limit(mut self, input: std::option::Option<i32>) -> Self {
self.max_volume_limit = input;
self
}
pub fn pstn_enabled(mut self, input: bool) -> Self {
self.pstn_enabled = Some(input);
self
}
pub fn set_pstn_enabled(mut self, input: std::option::Option<bool>) -> Self {
self.pstn_enabled = input;
self
}
pub fn data_retention_opt_in(mut self, input: bool) -> Self {
self.data_retention_opt_in = Some(input);
self
}
pub fn set_data_retention_opt_in(mut self, input: std::option::Option<bool>) -> Self {
self.data_retention_opt_in = input;
self
}
pub fn meeting_room_configuration(
mut self,
input: crate::model::CreateMeetingRoomConfiguration,
) -> Self {
self.meeting_room_configuration = Some(input);
self
}
pub fn set_meeting_room_configuration(
mut self,
input: std::option::Option<crate::model::CreateMeetingRoomConfiguration>,
) -> Self {
self.meeting_room_configuration = input;
self
}
pub fn tags(mut self, input: impl Into<crate::model::Tag>) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input.into());
self.tags = Some(v);
self
}
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::CreateProfileInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::CreateProfileInput {
profile_name: self.profile_name,
timezone: self.timezone,
address: self.address,
distance_unit: self.distance_unit,
temperature_unit: self.temperature_unit,
wake_word: self.wake_word,
locale: self.locale,
client_request_token: self.client_request_token,
setup_mode_disabled: self.setup_mode_disabled,
max_volume_limit: self.max_volume_limit,
pstn_enabled: self.pstn_enabled,
data_retention_opt_in: self.data_retention_opt_in,
meeting_room_configuration: self.meeting_room_configuration,
tags: self.tags,
})
}
}
}
#[doc(hidden)]
pub type CreateProfileInputOperationOutputAlias = crate::operation::CreateProfile;
#[doc(hidden)]
pub type CreateProfileInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl CreateProfileInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
mut self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateProfile,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::CreateProfileInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateProfileInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::CreateProfileInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.CreateProfile",
);
Ok(builder)
}
if self.client_request_token.is_none() {
self.client_request_token = Some(_config.make_token.make_idempotency_token());
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_create_profile(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateProfile::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateProfile",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::create_profile_input::Builder {
crate::input::create_profile_input::Builder::default()
}
}
pub mod create_room_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) room_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) profile_arn: std::option::Option<std::string::String>,
pub(crate) provider_calendar_id: std::option::Option<std::string::String>,
pub(crate) client_request_token: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
pub fn room_name(mut self, input: impl Into<std::string::String>) -> Self {
self.room_name = Some(input.into());
self
}
pub fn set_room_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn profile_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.profile_arn = Some(input.into());
self
}
pub fn set_profile_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.profile_arn = input;
self
}
pub fn provider_calendar_id(mut self, input: impl Into<std::string::String>) -> Self {
self.provider_calendar_id = Some(input.into());
self
}
pub fn set_provider_calendar_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.provider_calendar_id = input;
self
}
pub fn client_request_token(mut self, input: impl Into<std::string::String>) -> Self {
self.client_request_token = Some(input.into());
self
}
pub fn set_client_request_token(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.client_request_token = input;
self
}
pub fn tags(mut self, input: impl Into<crate::model::Tag>) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input.into());
self.tags = Some(v);
self
}
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::CreateRoomInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::CreateRoomInput {
room_name: self.room_name,
description: self.description,
profile_arn: self.profile_arn,
provider_calendar_id: self.provider_calendar_id,
client_request_token: self.client_request_token,
tags: self.tags,
})
}
}
}
#[doc(hidden)]
pub type CreateRoomInputOperationOutputAlias = crate::operation::CreateRoom;
#[doc(hidden)]
pub type CreateRoomInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl CreateRoomInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
mut self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateRoom,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::CreateRoomInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateRoomInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::CreateRoomInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.CreateRoom",
);
Ok(builder)
}
if self.client_request_token.is_none() {
self.client_request_token = Some(_config.make_token.make_idempotency_token());
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_create_room(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateRoom::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateRoom",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::create_room_input::Builder {
crate::input::create_room_input::Builder::default()
}
}
pub mod create_skill_group_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) skill_group_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) client_request_token: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
pub fn skill_group_name(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_group_name = Some(input.into());
self
}
pub fn set_skill_group_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.skill_group_name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn client_request_token(mut self, input: impl Into<std::string::String>) -> Self {
self.client_request_token = Some(input.into());
self
}
pub fn set_client_request_token(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.client_request_token = input;
self
}
pub fn tags(mut self, input: impl Into<crate::model::Tag>) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input.into());
self.tags = Some(v);
self
}
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::CreateSkillGroupInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::CreateSkillGroupInput {
skill_group_name: self.skill_group_name,
description: self.description,
client_request_token: self.client_request_token,
tags: self.tags,
})
}
}
}
#[doc(hidden)]
pub type CreateSkillGroupInputOperationOutputAlias = crate::operation::CreateSkillGroup;
#[doc(hidden)]
pub type CreateSkillGroupInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl CreateSkillGroupInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
mut self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateSkillGroup,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::CreateSkillGroupInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateSkillGroupInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::CreateSkillGroupInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.CreateSkillGroup",
);
Ok(builder)
}
if self.client_request_token.is_none() {
self.client_request_token = Some(_config.make_token.make_idempotency_token());
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_create_skill_group(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateSkillGroup::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateSkillGroup",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::create_skill_group_input::Builder {
crate::input::create_skill_group_input::Builder::default()
}
}
pub mod create_user_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) user_id: std::option::Option<std::string::String>,
pub(crate) first_name: std::option::Option<std::string::String>,
pub(crate) last_name: std::option::Option<std::string::String>,
pub(crate) email: std::option::Option<std::string::String>,
pub(crate) client_request_token: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
pub fn user_id(mut self, input: impl Into<std::string::String>) -> Self {
self.user_id = Some(input.into());
self
}
pub fn set_user_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.user_id = input;
self
}
pub fn first_name(mut self, input: impl Into<std::string::String>) -> Self {
self.first_name = Some(input.into());
self
}
pub fn set_first_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.first_name = input;
self
}
pub fn last_name(mut self, input: impl Into<std::string::String>) -> Self {
self.last_name = Some(input.into());
self
}
pub fn set_last_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.last_name = input;
self
}
pub fn email(mut self, input: impl Into<std::string::String>) -> Self {
self.email = Some(input.into());
self
}
pub fn set_email(mut self, input: std::option::Option<std::string::String>) -> Self {
self.email = input;
self
}
pub fn client_request_token(mut self, input: impl Into<std::string::String>) -> Self {
self.client_request_token = Some(input.into());
self
}
pub fn set_client_request_token(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.client_request_token = input;
self
}
pub fn tags(mut self, input: impl Into<crate::model::Tag>) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input.into());
self.tags = Some(v);
self
}
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::CreateUserInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::CreateUserInput {
user_id: self.user_id,
first_name: self.first_name,
last_name: self.last_name,
email: self.email,
client_request_token: self.client_request_token,
tags: self.tags,
})
}
}
}
#[doc(hidden)]
pub type CreateUserInputOperationOutputAlias = crate::operation::CreateUser;
#[doc(hidden)]
pub type CreateUserInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl CreateUserInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
mut self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateUser,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::CreateUserInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateUserInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::CreateUserInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.CreateUser",
);
Ok(builder)
}
if self.client_request_token.is_none() {
self.client_request_token = Some(_config.make_token.make_idempotency_token());
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_create_user(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateUser::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateUser",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::create_user_input::Builder {
crate::input::create_user_input::Builder::default()
}
}
pub mod delete_address_book_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) address_book_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn address_book_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.address_book_arn = Some(input.into());
self
}
pub fn set_address_book_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.address_book_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::DeleteAddressBookInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::DeleteAddressBookInput {
address_book_arn: self.address_book_arn,
})
}
}
}
#[doc(hidden)]
pub type DeleteAddressBookInputOperationOutputAlias = crate::operation::DeleteAddressBook;
#[doc(hidden)]
pub type DeleteAddressBookInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DeleteAddressBookInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteAddressBook,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::DeleteAddressBookInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteAddressBookInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::DeleteAddressBookInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.DeleteAddressBook",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_delete_address_book(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteAddressBook::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteAddressBook",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::delete_address_book_input::Builder {
crate::input::delete_address_book_input::Builder::default()
}
}
pub mod delete_business_report_schedule_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) schedule_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn schedule_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.schedule_arn = Some(input.into());
self
}
pub fn set_schedule_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.schedule_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::DeleteBusinessReportScheduleInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::DeleteBusinessReportScheduleInput {
schedule_arn: self.schedule_arn,
})
}
}
}
#[doc(hidden)]
pub type DeleteBusinessReportScheduleInputOperationOutputAlias =
crate::operation::DeleteBusinessReportSchedule;
#[doc(hidden)]
pub type DeleteBusinessReportScheduleInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DeleteBusinessReportScheduleInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteBusinessReportSchedule,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::DeleteBusinessReportScheduleInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteBusinessReportScheduleInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::DeleteBusinessReportScheduleInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.DeleteBusinessReportSchedule",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_delete_business_report_schedule(&self)?
;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteBusinessReportSchedule::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteBusinessReportSchedule",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::delete_business_report_schedule_input::Builder {
crate::input::delete_business_report_schedule_input::Builder::default()
}
}
pub mod delete_conference_provider_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) conference_provider_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn conference_provider_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.conference_provider_arn = Some(input.into());
self
}
pub fn set_conference_provider_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.conference_provider_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::DeleteConferenceProviderInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::DeleteConferenceProviderInput {
conference_provider_arn: self.conference_provider_arn,
})
}
}
}
#[doc(hidden)]
pub type DeleteConferenceProviderInputOperationOutputAlias =
crate::operation::DeleteConferenceProvider;
#[doc(hidden)]
pub type DeleteConferenceProviderInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DeleteConferenceProviderInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteConferenceProvider,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::DeleteConferenceProviderInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteConferenceProviderInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::DeleteConferenceProviderInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.DeleteConferenceProvider",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_delete_conference_provider(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteConferenceProvider::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteConferenceProvider",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::delete_conference_provider_input::Builder {
crate::input::delete_conference_provider_input::Builder::default()
}
}
pub mod delete_contact_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) contact_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn contact_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.contact_arn = Some(input.into());
self
}
pub fn set_contact_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.contact_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::DeleteContactInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::DeleteContactInput {
contact_arn: self.contact_arn,
})
}
}
}
#[doc(hidden)]
pub type DeleteContactInputOperationOutputAlias = crate::operation::DeleteContact;
#[doc(hidden)]
pub type DeleteContactInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DeleteContactInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteContact,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::DeleteContactInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteContactInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::DeleteContactInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.DeleteContact",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_delete_contact(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteContact::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteContact",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::delete_contact_input::Builder {
crate::input::delete_contact_input::Builder::default()
}
}
pub mod delete_device_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) device_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn device_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.device_arn = Some(input.into());
self
}
pub fn set_device_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.device_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::DeleteDeviceInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::DeleteDeviceInput {
device_arn: self.device_arn,
})
}
}
}
#[doc(hidden)]
pub type DeleteDeviceInputOperationOutputAlias = crate::operation::DeleteDevice;
#[doc(hidden)]
pub type DeleteDeviceInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DeleteDeviceInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteDevice,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::DeleteDeviceInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteDeviceInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::DeleteDeviceInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.DeleteDevice",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_delete_device(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteDevice::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteDevice",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::delete_device_input::Builder {
crate::input::delete_device_input::Builder::default()
}
}
pub mod delete_device_usage_data_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) device_arn: std::option::Option<std::string::String>,
pub(crate) device_usage_type: std::option::Option<crate::model::DeviceUsageType>,
}
impl Builder {
pub fn device_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.device_arn = Some(input.into());
self
}
pub fn set_device_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.device_arn = input;
self
}
pub fn device_usage_type(mut self, input: crate::model::DeviceUsageType) -> Self {
self.device_usage_type = Some(input);
self
}
pub fn set_device_usage_type(
mut self,
input: std::option::Option<crate::model::DeviceUsageType>,
) -> Self {
self.device_usage_type = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::DeleteDeviceUsageDataInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::DeleteDeviceUsageDataInput {
device_arn: self.device_arn,
device_usage_type: self.device_usage_type,
})
}
}
}
#[doc(hidden)]
pub type DeleteDeviceUsageDataInputOperationOutputAlias = crate::operation::DeleteDeviceUsageData;
#[doc(hidden)]
pub type DeleteDeviceUsageDataInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DeleteDeviceUsageDataInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteDeviceUsageData,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::DeleteDeviceUsageDataInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteDeviceUsageDataInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::DeleteDeviceUsageDataInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.DeleteDeviceUsageData",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_delete_device_usage_data(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteDeviceUsageData::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteDeviceUsageData",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::delete_device_usage_data_input::Builder {
crate::input::delete_device_usage_data_input::Builder::default()
}
}
pub mod delete_gateway_group_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) gateway_group_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn gateway_group_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.gateway_group_arn = Some(input.into());
self
}
pub fn set_gateway_group_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.gateway_group_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::DeleteGatewayGroupInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::DeleteGatewayGroupInput {
gateway_group_arn: self.gateway_group_arn,
})
}
}
}
#[doc(hidden)]
pub type DeleteGatewayGroupInputOperationOutputAlias = crate::operation::DeleteGatewayGroup;
#[doc(hidden)]
pub type DeleteGatewayGroupInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DeleteGatewayGroupInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteGatewayGroup,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::DeleteGatewayGroupInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteGatewayGroupInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::DeleteGatewayGroupInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.DeleteGatewayGroup",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_delete_gateway_group(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteGatewayGroup::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteGatewayGroup",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::delete_gateway_group_input::Builder {
crate::input::delete_gateway_group_input::Builder::default()
}
}
pub mod delete_network_profile_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) network_profile_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn network_profile_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.network_profile_arn = Some(input.into());
self
}
pub fn set_network_profile_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.network_profile_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::DeleteNetworkProfileInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::DeleteNetworkProfileInput {
network_profile_arn: self.network_profile_arn,
})
}
}
}
#[doc(hidden)]
pub type DeleteNetworkProfileInputOperationOutputAlias = crate::operation::DeleteNetworkProfile;
#[doc(hidden)]
pub type DeleteNetworkProfileInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DeleteNetworkProfileInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteNetworkProfile,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::DeleteNetworkProfileInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteNetworkProfileInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::DeleteNetworkProfileInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.DeleteNetworkProfile",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_delete_network_profile(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteNetworkProfile::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteNetworkProfile",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::delete_network_profile_input::Builder {
crate::input::delete_network_profile_input::Builder::default()
}
}
pub mod delete_profile_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) profile_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn profile_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.profile_arn = Some(input.into());
self
}
pub fn set_profile_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.profile_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::DeleteProfileInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::DeleteProfileInput {
profile_arn: self.profile_arn,
})
}
}
}
#[doc(hidden)]
pub type DeleteProfileInputOperationOutputAlias = crate::operation::DeleteProfile;
#[doc(hidden)]
pub type DeleteProfileInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DeleteProfileInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteProfile,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::DeleteProfileInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteProfileInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::DeleteProfileInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.DeleteProfile",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_delete_profile(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteProfile::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteProfile",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::delete_profile_input::Builder {
crate::input::delete_profile_input::Builder::default()
}
}
pub mod delete_room_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) room_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.room_arn = Some(input.into());
self
}
pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::DeleteRoomInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::DeleteRoomInput {
room_arn: self.room_arn,
})
}
}
}
#[doc(hidden)]
pub type DeleteRoomInputOperationOutputAlias = crate::operation::DeleteRoom;
#[doc(hidden)]
pub type DeleteRoomInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DeleteRoomInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteRoom,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::DeleteRoomInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteRoomInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::DeleteRoomInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.DeleteRoom",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_delete_room(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteRoom::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteRoom",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::delete_room_input::Builder {
crate::input::delete_room_input::Builder::default()
}
}
pub mod delete_room_skill_parameter_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) room_arn: std::option::Option<std::string::String>,
pub(crate) skill_id: std::option::Option<std::string::String>,
pub(crate) parameter_key: std::option::Option<std::string::String>,
}
impl Builder {
pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.room_arn = Some(input.into());
self
}
pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_arn = input;
self
}
pub fn skill_id(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_id = Some(input.into());
self
}
pub fn set_skill_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.skill_id = input;
self
}
pub fn parameter_key(mut self, input: impl Into<std::string::String>) -> Self {
self.parameter_key = Some(input.into());
self
}
pub fn set_parameter_key(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.parameter_key = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::DeleteRoomSkillParameterInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::DeleteRoomSkillParameterInput {
room_arn: self.room_arn,
skill_id: self.skill_id,
parameter_key: self.parameter_key,
})
}
}
}
#[doc(hidden)]
pub type DeleteRoomSkillParameterInputOperationOutputAlias =
crate::operation::DeleteRoomSkillParameter;
#[doc(hidden)]
pub type DeleteRoomSkillParameterInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DeleteRoomSkillParameterInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteRoomSkillParameter,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::DeleteRoomSkillParameterInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteRoomSkillParameterInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::DeleteRoomSkillParameterInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.DeleteRoomSkillParameter",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_delete_room_skill_parameter(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteRoomSkillParameter::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteRoomSkillParameter",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::delete_room_skill_parameter_input::Builder {
crate::input::delete_room_skill_parameter_input::Builder::default()
}
}
pub mod delete_skill_authorization_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) skill_id: std::option::Option<std::string::String>,
pub(crate) room_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn skill_id(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_id = Some(input.into());
self
}
pub fn set_skill_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.skill_id = input;
self
}
pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.room_arn = Some(input.into());
self
}
pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::DeleteSkillAuthorizationInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::DeleteSkillAuthorizationInput {
skill_id: self.skill_id,
room_arn: self.room_arn,
})
}
}
}
#[doc(hidden)]
pub type DeleteSkillAuthorizationInputOperationOutputAlias =
crate::operation::DeleteSkillAuthorization;
#[doc(hidden)]
pub type DeleteSkillAuthorizationInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DeleteSkillAuthorizationInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteSkillAuthorization,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::DeleteSkillAuthorizationInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteSkillAuthorizationInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::DeleteSkillAuthorizationInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.DeleteSkillAuthorization",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_delete_skill_authorization(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteSkillAuthorization::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteSkillAuthorization",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::delete_skill_authorization_input::Builder {
crate::input::delete_skill_authorization_input::Builder::default()
}
}
pub mod delete_skill_group_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) skill_group_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn skill_group_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_group_arn = Some(input.into());
self
}
pub fn set_skill_group_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.skill_group_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::DeleteSkillGroupInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::DeleteSkillGroupInput {
skill_group_arn: self.skill_group_arn,
})
}
}
}
#[doc(hidden)]
pub type DeleteSkillGroupInputOperationOutputAlias = crate::operation::DeleteSkillGroup;
#[doc(hidden)]
pub type DeleteSkillGroupInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DeleteSkillGroupInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteSkillGroup,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::DeleteSkillGroupInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteSkillGroupInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::DeleteSkillGroupInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.DeleteSkillGroup",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_delete_skill_group(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteSkillGroup::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteSkillGroup",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::delete_skill_group_input::Builder {
crate::input::delete_skill_group_input::Builder::default()
}
}
pub mod delete_user_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) user_arn: std::option::Option<std::string::String>,
pub(crate) enrollment_id: std::option::Option<std::string::String>,
}
impl Builder {
pub fn user_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.user_arn = Some(input.into());
self
}
pub fn set_user_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.user_arn = input;
self
}
pub fn enrollment_id(mut self, input: impl Into<std::string::String>) -> Self {
self.enrollment_id = Some(input.into());
self
}
pub fn set_enrollment_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.enrollment_id = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::DeleteUserInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::DeleteUserInput {
user_arn: self.user_arn,
enrollment_id: self.enrollment_id,
})
}
}
}
#[doc(hidden)]
pub type DeleteUserInputOperationOutputAlias = crate::operation::DeleteUser;
#[doc(hidden)]
pub type DeleteUserInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DeleteUserInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteUser,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::DeleteUserInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteUserInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::DeleteUserInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.DeleteUser",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_delete_user(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteUser::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteUser",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::delete_user_input::Builder {
crate::input::delete_user_input::Builder::default()
}
}
pub mod disassociate_contact_from_address_book_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) contact_arn: std::option::Option<std::string::String>,
pub(crate) address_book_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn contact_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.contact_arn = Some(input.into());
self
}
pub fn set_contact_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.contact_arn = input;
self
}
pub fn address_book_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.address_book_arn = Some(input.into());
self
}
pub fn set_address_book_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.address_book_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::DisassociateContactFromAddressBookInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::DisassociateContactFromAddressBookInput {
contact_arn: self.contact_arn,
address_book_arn: self.address_book_arn,
})
}
}
}
#[doc(hidden)]
pub type DisassociateContactFromAddressBookInputOperationOutputAlias =
crate::operation::DisassociateContactFromAddressBook;
#[doc(hidden)]
pub type DisassociateContactFromAddressBookInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DisassociateContactFromAddressBookInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DisassociateContactFromAddressBook,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::DisassociateContactFromAddressBookInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DisassociateContactFromAddressBookInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::DisassociateContactFromAddressBookInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.DisassociateContactFromAddressBook",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_disassociate_contact_from_address_book(&self)?
;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DisassociateContactFromAddressBook::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DisassociateContactFromAddressBook",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::disassociate_contact_from_address_book_input::Builder {
crate::input::disassociate_contact_from_address_book_input::Builder::default()
}
}
pub mod disassociate_device_from_room_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) device_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn device_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.device_arn = Some(input.into());
self
}
pub fn set_device_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.device_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::DisassociateDeviceFromRoomInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::DisassociateDeviceFromRoomInput {
device_arn: self.device_arn,
})
}
}
}
#[doc(hidden)]
pub type DisassociateDeviceFromRoomInputOperationOutputAlias =
crate::operation::DisassociateDeviceFromRoom;
#[doc(hidden)]
pub type DisassociateDeviceFromRoomInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DisassociateDeviceFromRoomInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DisassociateDeviceFromRoom,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::DisassociateDeviceFromRoomInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DisassociateDeviceFromRoomInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::DisassociateDeviceFromRoomInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.DisassociateDeviceFromRoom",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_disassociate_device_from_room(&self)?
;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DisassociateDeviceFromRoom::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DisassociateDeviceFromRoom",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::disassociate_device_from_room_input::Builder {
crate::input::disassociate_device_from_room_input::Builder::default()
}
}
pub mod disassociate_skill_from_skill_group_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) skill_group_arn: std::option::Option<std::string::String>,
pub(crate) skill_id: std::option::Option<std::string::String>,
}
impl Builder {
pub fn skill_group_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_group_arn = Some(input.into());
self
}
pub fn set_skill_group_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.skill_group_arn = input;
self
}
pub fn skill_id(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_id = Some(input.into());
self
}
pub fn set_skill_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.skill_id = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::DisassociateSkillFromSkillGroupInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::DisassociateSkillFromSkillGroupInput {
skill_group_arn: self.skill_group_arn,
skill_id: self.skill_id,
})
}
}
}
#[doc(hidden)]
pub type DisassociateSkillFromSkillGroupInputOperationOutputAlias =
crate::operation::DisassociateSkillFromSkillGroup;
#[doc(hidden)]
pub type DisassociateSkillFromSkillGroupInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DisassociateSkillFromSkillGroupInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DisassociateSkillFromSkillGroup,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::DisassociateSkillFromSkillGroupInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DisassociateSkillFromSkillGroupInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::DisassociateSkillFromSkillGroupInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.DisassociateSkillFromSkillGroup",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_disassociate_skill_from_skill_group(&self)?
;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DisassociateSkillFromSkillGroup::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DisassociateSkillFromSkillGroup",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::disassociate_skill_from_skill_group_input::Builder {
crate::input::disassociate_skill_from_skill_group_input::Builder::default()
}
}
pub mod disassociate_skill_from_users_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) skill_id: std::option::Option<std::string::String>,
}
impl Builder {
pub fn skill_id(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_id = Some(input.into());
self
}
pub fn set_skill_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.skill_id = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::DisassociateSkillFromUsersInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::DisassociateSkillFromUsersInput {
skill_id: self.skill_id,
})
}
}
}
#[doc(hidden)]
pub type DisassociateSkillFromUsersInputOperationOutputAlias =
crate::operation::DisassociateSkillFromUsers;
#[doc(hidden)]
pub type DisassociateSkillFromUsersInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DisassociateSkillFromUsersInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DisassociateSkillFromUsers,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::DisassociateSkillFromUsersInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DisassociateSkillFromUsersInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::DisassociateSkillFromUsersInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.DisassociateSkillFromUsers",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_disassociate_skill_from_users(&self)?
;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DisassociateSkillFromUsers::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DisassociateSkillFromUsers",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::disassociate_skill_from_users_input::Builder {
crate::input::disassociate_skill_from_users_input::Builder::default()
}
}
pub mod disassociate_skill_group_from_room_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) skill_group_arn: std::option::Option<std::string::String>,
pub(crate) room_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn skill_group_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_group_arn = Some(input.into());
self
}
pub fn set_skill_group_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.skill_group_arn = input;
self
}
pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.room_arn = Some(input.into());
self
}
pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::DisassociateSkillGroupFromRoomInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::DisassociateSkillGroupFromRoomInput {
skill_group_arn: self.skill_group_arn,
room_arn: self.room_arn,
})
}
}
}
#[doc(hidden)]
pub type DisassociateSkillGroupFromRoomInputOperationOutputAlias =
crate::operation::DisassociateSkillGroupFromRoom;
#[doc(hidden)]
pub type DisassociateSkillGroupFromRoomInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl DisassociateSkillGroupFromRoomInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DisassociateSkillGroupFromRoom,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::DisassociateSkillGroupFromRoomInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DisassociateSkillGroupFromRoomInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::DisassociateSkillGroupFromRoomInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.DisassociateSkillGroupFromRoom",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_disassociate_skill_group_from_room(&self)?
;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DisassociateSkillGroupFromRoom::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DisassociateSkillGroupFromRoom",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::disassociate_skill_group_from_room_input::Builder {
crate::input::disassociate_skill_group_from_room_input::Builder::default()
}
}
pub mod forget_smart_home_appliances_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) room_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.room_arn = Some(input.into());
self
}
pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::ForgetSmartHomeAppliancesInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::ForgetSmartHomeAppliancesInput {
room_arn: self.room_arn,
})
}
}
}
#[doc(hidden)]
pub type ForgetSmartHomeAppliancesInputOperationOutputAlias =
crate::operation::ForgetSmartHomeAppliances;
#[doc(hidden)]
pub type ForgetSmartHomeAppliancesInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl ForgetSmartHomeAppliancesInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ForgetSmartHomeAppliances,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::ForgetSmartHomeAppliancesInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ForgetSmartHomeAppliancesInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::ForgetSmartHomeAppliancesInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.ForgetSmartHomeAppliances",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_forget_smart_home_appliances(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ForgetSmartHomeAppliances::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ForgetSmartHomeAppliances",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::forget_smart_home_appliances_input::Builder {
crate::input::forget_smart_home_appliances_input::Builder::default()
}
}
pub mod get_address_book_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) address_book_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn address_book_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.address_book_arn = Some(input.into());
self
}
pub fn set_address_book_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.address_book_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::GetAddressBookInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::GetAddressBookInput {
address_book_arn: self.address_book_arn,
})
}
}
}
#[doc(hidden)]
pub type GetAddressBookInputOperationOutputAlias = crate::operation::GetAddressBook;
#[doc(hidden)]
pub type GetAddressBookInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl GetAddressBookInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetAddressBook,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::GetAddressBookInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetAddressBookInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::GetAddressBookInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.GetAddressBook",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_get_address_book(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetAddressBook::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetAddressBook",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::get_address_book_input::Builder {
crate::input::get_address_book_input::Builder::default()
}
}
pub mod get_conference_preference_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(
self,
) -> std::result::Result<
crate::input::GetConferencePreferenceInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::GetConferencePreferenceInput {})
}
}
}
#[doc(hidden)]
pub type GetConferencePreferenceInputOperationOutputAlias =
crate::operation::GetConferencePreference;
#[doc(hidden)]
pub type GetConferencePreferenceInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl GetConferencePreferenceInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetConferencePreference,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::GetConferencePreferenceInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetConferencePreferenceInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::GetConferencePreferenceInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.GetConferencePreference",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_get_conference_preference(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetConferencePreference::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetConferencePreference",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::get_conference_preference_input::Builder {
crate::input::get_conference_preference_input::Builder::default()
}
}
pub mod get_conference_provider_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) conference_provider_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn conference_provider_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.conference_provider_arn = Some(input.into());
self
}
pub fn set_conference_provider_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.conference_provider_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::GetConferenceProviderInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::GetConferenceProviderInput {
conference_provider_arn: self.conference_provider_arn,
})
}
}
}
#[doc(hidden)]
pub type GetConferenceProviderInputOperationOutputAlias = crate::operation::GetConferenceProvider;
#[doc(hidden)]
pub type GetConferenceProviderInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl GetConferenceProviderInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetConferenceProvider,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::GetConferenceProviderInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetConferenceProviderInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::GetConferenceProviderInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.GetConferenceProvider",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_get_conference_provider(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetConferenceProvider::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetConferenceProvider",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::get_conference_provider_input::Builder {
crate::input::get_conference_provider_input::Builder::default()
}
}
pub mod get_contact_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) contact_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn contact_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.contact_arn = Some(input.into());
self
}
pub fn set_contact_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.contact_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::GetContactInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::GetContactInput {
contact_arn: self.contact_arn,
})
}
}
}
#[doc(hidden)]
pub type GetContactInputOperationOutputAlias = crate::operation::GetContact;
#[doc(hidden)]
pub type GetContactInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl GetContactInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetContact,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::GetContactInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetContactInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::GetContactInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.GetContact",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_get_contact(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetContact::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetContact",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::get_contact_input::Builder {
crate::input::get_contact_input::Builder::default()
}
}
pub mod get_device_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) device_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn device_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.device_arn = Some(input.into());
self
}
pub fn set_device_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.device_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<crate::input::GetDeviceInput, aws_smithy_http::operation::BuildError>
{
Ok(crate::input::GetDeviceInput {
device_arn: self.device_arn,
})
}
}
}
#[doc(hidden)]
pub type GetDeviceInputOperationOutputAlias = crate::operation::GetDevice;
#[doc(hidden)]
pub type GetDeviceInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl GetDeviceInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetDevice,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::GetDeviceInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetDeviceInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::GetDeviceInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.GetDevice",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_get_device(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op =
aws_smithy_http::operation::Operation::new(request, crate::operation::GetDevice::new())
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetDevice",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::get_device_input::Builder {
crate::input::get_device_input::Builder::default()
}
}
pub mod get_gateway_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) gateway_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn gateway_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.gateway_arn = Some(input.into());
self
}
pub fn set_gateway_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.gateway_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::GetGatewayInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::GetGatewayInput {
gateway_arn: self.gateway_arn,
})
}
}
}
#[doc(hidden)]
pub type GetGatewayInputOperationOutputAlias = crate::operation::GetGateway;
#[doc(hidden)]
pub type GetGatewayInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl GetGatewayInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetGateway,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::GetGatewayInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetGatewayInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::GetGatewayInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.GetGateway",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_get_gateway(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetGateway::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetGateway",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::get_gateway_input::Builder {
crate::input::get_gateway_input::Builder::default()
}
}
pub mod get_gateway_group_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) gateway_group_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn gateway_group_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.gateway_group_arn = Some(input.into());
self
}
pub fn set_gateway_group_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.gateway_group_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::GetGatewayGroupInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::GetGatewayGroupInput {
gateway_group_arn: self.gateway_group_arn,
})
}
}
}
#[doc(hidden)]
pub type GetGatewayGroupInputOperationOutputAlias = crate::operation::GetGatewayGroup;
#[doc(hidden)]
pub type GetGatewayGroupInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl GetGatewayGroupInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetGatewayGroup,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::GetGatewayGroupInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetGatewayGroupInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::GetGatewayGroupInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.GetGatewayGroup",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_get_gateway_group(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetGatewayGroup::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetGatewayGroup",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::get_gateway_group_input::Builder {
crate::input::get_gateway_group_input::Builder::default()
}
}
pub mod get_invitation_configuration_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(
self,
) -> std::result::Result<
crate::input::GetInvitationConfigurationInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::GetInvitationConfigurationInput {})
}
}
}
#[doc(hidden)]
pub type GetInvitationConfigurationInputOperationOutputAlias =
crate::operation::GetInvitationConfiguration;
#[doc(hidden)]
pub type GetInvitationConfigurationInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl GetInvitationConfigurationInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetInvitationConfiguration,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::GetInvitationConfigurationInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetInvitationConfigurationInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::GetInvitationConfigurationInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.GetInvitationConfiguration",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_get_invitation_configuration(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetInvitationConfiguration::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetInvitationConfiguration",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::get_invitation_configuration_input::Builder {
crate::input::get_invitation_configuration_input::Builder::default()
}
}
pub mod get_network_profile_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) network_profile_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn network_profile_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.network_profile_arn = Some(input.into());
self
}
pub fn set_network_profile_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.network_profile_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::GetNetworkProfileInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::GetNetworkProfileInput {
network_profile_arn: self.network_profile_arn,
})
}
}
}
#[doc(hidden)]
pub type GetNetworkProfileInputOperationOutputAlias = crate::operation::GetNetworkProfile;
#[doc(hidden)]
pub type GetNetworkProfileInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl GetNetworkProfileInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetNetworkProfile,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::GetNetworkProfileInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetNetworkProfileInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::GetNetworkProfileInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.GetNetworkProfile",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_get_network_profile(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetNetworkProfile::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetNetworkProfile",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::get_network_profile_input::Builder {
crate::input::get_network_profile_input::Builder::default()
}
}
pub mod get_profile_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) profile_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn profile_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.profile_arn = Some(input.into());
self
}
pub fn set_profile_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.profile_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::GetProfileInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::GetProfileInput {
profile_arn: self.profile_arn,
})
}
}
}
#[doc(hidden)]
pub type GetProfileInputOperationOutputAlias = crate::operation::GetProfile;
#[doc(hidden)]
pub type GetProfileInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl GetProfileInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetProfile,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::GetProfileInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetProfileInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::GetProfileInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.GetProfile",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_get_profile(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetProfile::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetProfile",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::get_profile_input::Builder {
crate::input::get_profile_input::Builder::default()
}
}
pub mod get_room_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) room_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.room_arn = Some(input.into());
self
}
pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<crate::input::GetRoomInput, aws_smithy_http::operation::BuildError>
{
Ok(crate::input::GetRoomInput {
room_arn: self.room_arn,
})
}
}
}
#[doc(hidden)]
pub type GetRoomInputOperationOutputAlias = crate::operation::GetRoom;
#[doc(hidden)]
pub type GetRoomInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl GetRoomInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetRoom,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::GetRoomInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetRoomInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::GetRoomInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.GetRoom",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_get_room(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op =
aws_smithy_http::operation::Operation::new(request, crate::operation::GetRoom::new())
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetRoom",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::get_room_input::Builder {
crate::input::get_room_input::Builder::default()
}
}
pub mod get_room_skill_parameter_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) room_arn: std::option::Option<std::string::String>,
pub(crate) skill_id: std::option::Option<std::string::String>,
pub(crate) parameter_key: std::option::Option<std::string::String>,
}
impl Builder {
pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.room_arn = Some(input.into());
self
}
pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_arn = input;
self
}
pub fn skill_id(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_id = Some(input.into());
self
}
pub fn set_skill_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.skill_id = input;
self
}
pub fn parameter_key(mut self, input: impl Into<std::string::String>) -> Self {
self.parameter_key = Some(input.into());
self
}
pub fn set_parameter_key(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.parameter_key = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::GetRoomSkillParameterInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::GetRoomSkillParameterInput {
room_arn: self.room_arn,
skill_id: self.skill_id,
parameter_key: self.parameter_key,
})
}
}
}
#[doc(hidden)]
pub type GetRoomSkillParameterInputOperationOutputAlias = crate::operation::GetRoomSkillParameter;
#[doc(hidden)]
pub type GetRoomSkillParameterInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl GetRoomSkillParameterInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetRoomSkillParameter,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::GetRoomSkillParameterInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetRoomSkillParameterInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::GetRoomSkillParameterInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.GetRoomSkillParameter",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_get_room_skill_parameter(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetRoomSkillParameter::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetRoomSkillParameter",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::get_room_skill_parameter_input::Builder {
crate::input::get_room_skill_parameter_input::Builder::default()
}
}
pub mod get_skill_group_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) skill_group_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn skill_group_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_group_arn = Some(input.into());
self
}
pub fn set_skill_group_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.skill_group_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::GetSkillGroupInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::GetSkillGroupInput {
skill_group_arn: self.skill_group_arn,
})
}
}
}
#[doc(hidden)]
pub type GetSkillGroupInputOperationOutputAlias = crate::operation::GetSkillGroup;
#[doc(hidden)]
pub type GetSkillGroupInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl GetSkillGroupInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetSkillGroup,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::GetSkillGroupInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetSkillGroupInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::GetSkillGroupInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.GetSkillGroup",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_get_skill_group(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetSkillGroup::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetSkillGroup",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::get_skill_group_input::Builder {
crate::input::get_skill_group_input::Builder::default()
}
}
pub mod list_business_report_schedules_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::ListBusinessReportSchedulesInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::ListBusinessReportSchedulesInput {
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
#[doc(hidden)]
pub type ListBusinessReportSchedulesInputOperationOutputAlias =
crate::operation::ListBusinessReportSchedules;
#[doc(hidden)]
pub type ListBusinessReportSchedulesInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl ListBusinessReportSchedulesInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListBusinessReportSchedules,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::ListBusinessReportSchedulesInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListBusinessReportSchedulesInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::ListBusinessReportSchedulesInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.ListBusinessReportSchedules",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_list_business_report_schedules(&self)?
;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListBusinessReportSchedules::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListBusinessReportSchedules",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::list_business_report_schedules_input::Builder {
crate::input::list_business_report_schedules_input::Builder::default()
}
}
pub mod list_conference_providers_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::ListConferenceProvidersInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::ListConferenceProvidersInput {
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
#[doc(hidden)]
pub type ListConferenceProvidersInputOperationOutputAlias =
crate::operation::ListConferenceProviders;
#[doc(hidden)]
pub type ListConferenceProvidersInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl ListConferenceProvidersInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListConferenceProviders,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::ListConferenceProvidersInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListConferenceProvidersInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::ListConferenceProvidersInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.ListConferenceProviders",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_list_conference_providers(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListConferenceProviders::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListConferenceProviders",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::list_conference_providers_input::Builder {
crate::input::list_conference_providers_input::Builder::default()
}
}
pub mod list_device_events_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) device_arn: std::option::Option<std::string::String>,
pub(crate) event_type: std::option::Option<crate::model::DeviceEventType>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
pub fn device_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.device_arn = Some(input.into());
self
}
pub fn set_device_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.device_arn = input;
self
}
pub fn event_type(mut self, input: crate::model::DeviceEventType) -> Self {
self.event_type = Some(input);
self
}
pub fn set_event_type(
mut self,
input: std::option::Option<crate::model::DeviceEventType>,
) -> Self {
self.event_type = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::ListDeviceEventsInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::ListDeviceEventsInput {
device_arn: self.device_arn,
event_type: self.event_type,
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
#[doc(hidden)]
pub type ListDeviceEventsInputOperationOutputAlias = crate::operation::ListDeviceEvents;
#[doc(hidden)]
pub type ListDeviceEventsInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl ListDeviceEventsInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListDeviceEvents,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::ListDeviceEventsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListDeviceEventsInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::ListDeviceEventsInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.ListDeviceEvents",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_list_device_events(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListDeviceEvents::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListDeviceEvents",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::list_device_events_input::Builder {
crate::input::list_device_events_input::Builder::default()
}
}
pub mod list_gateway_groups_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::ListGatewayGroupsInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::ListGatewayGroupsInput {
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
#[doc(hidden)]
pub type ListGatewayGroupsInputOperationOutputAlias = crate::operation::ListGatewayGroups;
#[doc(hidden)]
pub type ListGatewayGroupsInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl ListGatewayGroupsInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListGatewayGroups,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::ListGatewayGroupsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListGatewayGroupsInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::ListGatewayGroupsInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.ListGatewayGroups",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_list_gateway_groups(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListGatewayGroups::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListGatewayGroups",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::list_gateway_groups_input::Builder {
crate::input::list_gateway_groups_input::Builder::default()
}
}
pub mod list_gateways_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) gateway_group_arn: std::option::Option<std::string::String>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
pub fn gateway_group_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.gateway_group_arn = Some(input.into());
self
}
pub fn set_gateway_group_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.gateway_group_arn = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::ListGatewaysInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::ListGatewaysInput {
gateway_group_arn: self.gateway_group_arn,
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
#[doc(hidden)]
pub type ListGatewaysInputOperationOutputAlias = crate::operation::ListGateways;
#[doc(hidden)]
pub type ListGatewaysInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl ListGatewaysInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListGateways,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::ListGatewaysInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListGatewaysInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::ListGatewaysInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.ListGateways",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_list_gateways(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListGateways::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListGateways",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::list_gateways_input::Builder {
crate::input::list_gateways_input::Builder::default()
}
}
pub mod list_skills_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) skill_group_arn: std::option::Option<std::string::String>,
pub(crate) enablement_type: std::option::Option<crate::model::EnablementTypeFilter>,
pub(crate) skill_type: std::option::Option<crate::model::SkillTypeFilter>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
pub fn skill_group_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_group_arn = Some(input.into());
self
}
pub fn set_skill_group_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.skill_group_arn = input;
self
}
pub fn enablement_type(mut self, input: crate::model::EnablementTypeFilter) -> Self {
self.enablement_type = Some(input);
self
}
pub fn set_enablement_type(
mut self,
input: std::option::Option<crate::model::EnablementTypeFilter>,
) -> Self {
self.enablement_type = input;
self
}
pub fn skill_type(mut self, input: crate::model::SkillTypeFilter) -> Self {
self.skill_type = Some(input);
self
}
pub fn set_skill_type(
mut self,
input: std::option::Option<crate::model::SkillTypeFilter>,
) -> Self {
self.skill_type = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::ListSkillsInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::ListSkillsInput {
skill_group_arn: self.skill_group_arn,
enablement_type: self.enablement_type,
skill_type: self.skill_type,
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
#[doc(hidden)]
pub type ListSkillsInputOperationOutputAlias = crate::operation::ListSkills;
#[doc(hidden)]
pub type ListSkillsInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl ListSkillsInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListSkills,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::ListSkillsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListSkillsInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::ListSkillsInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.ListSkills",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_list_skills(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListSkills::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListSkills",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::list_skills_input::Builder {
crate::input::list_skills_input::Builder::default()
}
}
pub mod list_skills_store_categories_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::ListSkillsStoreCategoriesInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::ListSkillsStoreCategoriesInput {
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
#[doc(hidden)]
pub type ListSkillsStoreCategoriesInputOperationOutputAlias =
crate::operation::ListSkillsStoreCategories;
#[doc(hidden)]
pub type ListSkillsStoreCategoriesInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl ListSkillsStoreCategoriesInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListSkillsStoreCategories,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::ListSkillsStoreCategoriesInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListSkillsStoreCategoriesInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::ListSkillsStoreCategoriesInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.ListSkillsStoreCategories",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_list_skills_store_categories(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListSkillsStoreCategories::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListSkillsStoreCategories",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::list_skills_store_categories_input::Builder {
crate::input::list_skills_store_categories_input::Builder::default()
}
}
pub mod list_skills_store_skills_by_category_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) category_id: std::option::Option<i64>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
pub fn category_id(mut self, input: i64) -> Self {
self.category_id = Some(input);
self
}
pub fn set_category_id(mut self, input: std::option::Option<i64>) -> Self {
self.category_id = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::ListSkillsStoreSkillsByCategoryInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::ListSkillsStoreSkillsByCategoryInput {
category_id: self.category_id,
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
#[doc(hidden)]
pub type ListSkillsStoreSkillsByCategoryInputOperationOutputAlias =
crate::operation::ListSkillsStoreSkillsByCategory;
#[doc(hidden)]
pub type ListSkillsStoreSkillsByCategoryInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl ListSkillsStoreSkillsByCategoryInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListSkillsStoreSkillsByCategory,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::ListSkillsStoreSkillsByCategoryInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListSkillsStoreSkillsByCategoryInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::ListSkillsStoreSkillsByCategoryInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.ListSkillsStoreSkillsByCategory",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_list_skills_store_skills_by_category(&self)?
;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListSkillsStoreSkillsByCategory::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListSkillsStoreSkillsByCategory",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::list_skills_store_skills_by_category_input::Builder {
crate::input::list_skills_store_skills_by_category_input::Builder::default()
}
}
pub mod list_smart_home_appliances_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) room_arn: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.room_arn = Some(input.into());
self
}
pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_arn = input;
self
}
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::ListSmartHomeAppliancesInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::ListSmartHomeAppliancesInput {
room_arn: self.room_arn,
max_results: self.max_results,
next_token: self.next_token,
})
}
}
}
#[doc(hidden)]
pub type ListSmartHomeAppliancesInputOperationOutputAlias =
crate::operation::ListSmartHomeAppliances;
#[doc(hidden)]
pub type ListSmartHomeAppliancesInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl ListSmartHomeAppliancesInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListSmartHomeAppliances,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::ListSmartHomeAppliancesInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListSmartHomeAppliancesInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::ListSmartHomeAppliancesInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.ListSmartHomeAppliances",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_list_smart_home_appliances(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListSmartHomeAppliances::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListSmartHomeAppliances",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::list_smart_home_appliances_input::Builder {
crate::input::list_smart_home_appliances_input::Builder::default()
}
}
pub mod list_tags_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) arn: std::option::Option<std::string::String>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
self.arn = Some(input.into());
self
}
pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.arn = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
pub fn build(
self,
) -> std::result::Result<crate::input::ListTagsInput, aws_smithy_http::operation::BuildError>
{
Ok(crate::input::ListTagsInput {
arn: self.arn,
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
#[doc(hidden)]
pub type ListTagsInputOperationOutputAlias = crate::operation::ListTags;
#[doc(hidden)]
pub type ListTagsInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl ListTagsInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListTags,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::ListTagsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListTagsInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::ListTagsInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.ListTags",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_list_tags(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op =
aws_smithy_http::operation::Operation::new(request, crate::operation::ListTags::new())
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListTags",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::list_tags_input::Builder {
crate::input::list_tags_input::Builder::default()
}
}
pub mod put_conference_preference_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) conference_preference: std::option::Option<crate::model::ConferencePreference>,
}
impl Builder {
pub fn conference_preference(mut self, input: crate::model::ConferencePreference) -> Self {
self.conference_preference = Some(input);
self
}
pub fn set_conference_preference(
mut self,
input: std::option::Option<crate::model::ConferencePreference>,
) -> Self {
self.conference_preference = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::PutConferencePreferenceInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::PutConferencePreferenceInput {
conference_preference: self.conference_preference,
})
}
}
}
#[doc(hidden)]
pub type PutConferencePreferenceInputOperationOutputAlias =
crate::operation::PutConferencePreference;
#[doc(hidden)]
pub type PutConferencePreferenceInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl PutConferencePreferenceInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::PutConferencePreference,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::PutConferencePreferenceInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::PutConferencePreferenceInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::PutConferencePreferenceInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.PutConferencePreference",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_put_conference_preference(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::PutConferencePreference::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"PutConferencePreference",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::put_conference_preference_input::Builder {
crate::input::put_conference_preference_input::Builder::default()
}
}
pub mod put_invitation_configuration_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) organization_name: std::option::Option<std::string::String>,
pub(crate) contact_email: std::option::Option<std::string::String>,
pub(crate) private_skill_ids: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
pub fn organization_name(mut self, input: impl Into<std::string::String>) -> Self {
self.organization_name = Some(input.into());
self
}
pub fn set_organization_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.organization_name = input;
self
}
pub fn contact_email(mut self, input: impl Into<std::string::String>) -> Self {
self.contact_email = Some(input.into());
self
}
pub fn set_contact_email(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.contact_email = input;
self
}
pub fn private_skill_ids(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.private_skill_ids.unwrap_or_default();
v.push(input.into());
self.private_skill_ids = Some(v);
self
}
pub fn set_private_skill_ids(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.private_skill_ids = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::PutInvitationConfigurationInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::PutInvitationConfigurationInput {
organization_name: self.organization_name,
contact_email: self.contact_email,
private_skill_ids: self.private_skill_ids,
})
}
}
}
#[doc(hidden)]
pub type PutInvitationConfigurationInputOperationOutputAlias =
crate::operation::PutInvitationConfiguration;
#[doc(hidden)]
pub type PutInvitationConfigurationInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl PutInvitationConfigurationInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::PutInvitationConfiguration,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::PutInvitationConfigurationInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::PutInvitationConfigurationInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::PutInvitationConfigurationInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.PutInvitationConfiguration",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_put_invitation_configuration(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::PutInvitationConfiguration::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"PutInvitationConfiguration",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::put_invitation_configuration_input::Builder {
crate::input::put_invitation_configuration_input::Builder::default()
}
}
pub mod put_room_skill_parameter_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) room_arn: std::option::Option<std::string::String>,
pub(crate) skill_id: std::option::Option<std::string::String>,
pub(crate) room_skill_parameter: std::option::Option<crate::model::RoomSkillParameter>,
}
impl Builder {
pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.room_arn = Some(input.into());
self
}
pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_arn = input;
self
}
pub fn skill_id(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_id = Some(input.into());
self
}
pub fn set_skill_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.skill_id = input;
self
}
pub fn room_skill_parameter(mut self, input: crate::model::RoomSkillParameter) -> Self {
self.room_skill_parameter = Some(input);
self
}
pub fn set_room_skill_parameter(
mut self,
input: std::option::Option<crate::model::RoomSkillParameter>,
) -> Self {
self.room_skill_parameter = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::PutRoomSkillParameterInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::PutRoomSkillParameterInput {
room_arn: self.room_arn,
skill_id: self.skill_id,
room_skill_parameter: self.room_skill_parameter,
})
}
}
}
#[doc(hidden)]
pub type PutRoomSkillParameterInputOperationOutputAlias = crate::operation::PutRoomSkillParameter;
#[doc(hidden)]
pub type PutRoomSkillParameterInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl PutRoomSkillParameterInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::PutRoomSkillParameter,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::PutRoomSkillParameterInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::PutRoomSkillParameterInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::PutRoomSkillParameterInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.PutRoomSkillParameter",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_put_room_skill_parameter(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::PutRoomSkillParameter::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"PutRoomSkillParameter",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::put_room_skill_parameter_input::Builder {
crate::input::put_room_skill_parameter_input::Builder::default()
}
}
pub mod put_skill_authorization_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) authorization_result: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
pub(crate) skill_id: std::option::Option<std::string::String>,
pub(crate) room_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn authorization_result(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.authorization_result.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.authorization_result = Some(hash_map);
self
}
pub fn set_authorization_result(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.authorization_result = input;
self
}
pub fn skill_id(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_id = Some(input.into());
self
}
pub fn set_skill_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.skill_id = input;
self
}
pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.room_arn = Some(input.into());
self
}
pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::PutSkillAuthorizationInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::PutSkillAuthorizationInput {
authorization_result: self.authorization_result,
skill_id: self.skill_id,
room_arn: self.room_arn,
})
}
}
}
#[doc(hidden)]
pub type PutSkillAuthorizationInputOperationOutputAlias = crate::operation::PutSkillAuthorization;
#[doc(hidden)]
pub type PutSkillAuthorizationInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl PutSkillAuthorizationInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::PutSkillAuthorization,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::PutSkillAuthorizationInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::PutSkillAuthorizationInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::PutSkillAuthorizationInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.PutSkillAuthorization",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_put_skill_authorization(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::PutSkillAuthorization::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"PutSkillAuthorization",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::put_skill_authorization_input::Builder {
crate::input::put_skill_authorization_input::Builder::default()
}
}
pub mod register_avs_device_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) client_id: std::option::Option<std::string::String>,
pub(crate) user_code: std::option::Option<std::string::String>,
pub(crate) product_id: std::option::Option<std::string::String>,
pub(crate) device_serial_number: std::option::Option<std::string::String>,
pub(crate) amazon_id: std::option::Option<std::string::String>,
pub(crate) room_arn: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
pub fn client_id(mut self, input: impl Into<std::string::String>) -> Self {
self.client_id = Some(input.into());
self
}
pub fn set_client_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.client_id = input;
self
}
pub fn user_code(mut self, input: impl Into<std::string::String>) -> Self {
self.user_code = Some(input.into());
self
}
pub fn set_user_code(mut self, input: std::option::Option<std::string::String>) -> Self {
self.user_code = input;
self
}
pub fn product_id(mut self, input: impl Into<std::string::String>) -> Self {
self.product_id = Some(input.into());
self
}
pub fn set_product_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.product_id = input;
self
}
pub fn device_serial_number(mut self, input: impl Into<std::string::String>) -> Self {
self.device_serial_number = Some(input.into());
self
}
pub fn set_device_serial_number(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.device_serial_number = input;
self
}
pub fn amazon_id(mut self, input: impl Into<std::string::String>) -> Self {
self.amazon_id = Some(input.into());
self
}
pub fn set_amazon_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.amazon_id = input;
self
}
pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.room_arn = Some(input.into());
self
}
pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_arn = input;
self
}
pub fn tags(mut self, input: impl Into<crate::model::Tag>) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input.into());
self.tags = Some(v);
self
}
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::RegisterAvsDeviceInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::RegisterAvsDeviceInput {
client_id: self.client_id,
user_code: self.user_code,
product_id: self.product_id,
device_serial_number: self.device_serial_number,
amazon_id: self.amazon_id,
room_arn: self.room_arn,
tags: self.tags,
})
}
}
}
#[doc(hidden)]
pub type RegisterAvsDeviceInputOperationOutputAlias = crate::operation::RegisterAVSDevice;
#[doc(hidden)]
pub type RegisterAvsDeviceInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl RegisterAvsDeviceInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::RegisterAVSDevice,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::RegisterAvsDeviceInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::RegisterAvsDeviceInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::RegisterAvsDeviceInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.RegisterAVSDevice",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_register_avs_device(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::RegisterAVSDevice::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"RegisterAVSDevice",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::register_avs_device_input::Builder {
crate::input::register_avs_device_input::Builder::default()
}
}
pub mod reject_skill_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) skill_id: std::option::Option<std::string::String>,
}
impl Builder {
pub fn skill_id(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_id = Some(input.into());
self
}
pub fn set_skill_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.skill_id = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::RejectSkillInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::RejectSkillInput {
skill_id: self.skill_id,
})
}
}
}
#[doc(hidden)]
pub type RejectSkillInputOperationOutputAlias = crate::operation::RejectSkill;
#[doc(hidden)]
pub type RejectSkillInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl RejectSkillInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::RejectSkill,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::RejectSkillInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::RejectSkillInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::RejectSkillInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.RejectSkill",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_reject_skill(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::RejectSkill::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"RejectSkill",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::reject_skill_input::Builder {
crate::input::reject_skill_input::Builder::default()
}
}
pub mod resolve_room_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) user_id: std::option::Option<std::string::String>,
pub(crate) skill_id: std::option::Option<std::string::String>,
}
impl Builder {
pub fn user_id(mut self, input: impl Into<std::string::String>) -> Self {
self.user_id = Some(input.into());
self
}
pub fn set_user_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.user_id = input;
self
}
pub fn skill_id(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_id = Some(input.into());
self
}
pub fn set_skill_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.skill_id = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::ResolveRoomInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::ResolveRoomInput {
user_id: self.user_id,
skill_id: self.skill_id,
})
}
}
}
#[doc(hidden)]
pub type ResolveRoomInputOperationOutputAlias = crate::operation::ResolveRoom;
#[doc(hidden)]
pub type ResolveRoomInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl ResolveRoomInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ResolveRoom,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::ResolveRoomInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ResolveRoomInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::ResolveRoomInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.ResolveRoom",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_resolve_room(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ResolveRoom::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ResolveRoom",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::resolve_room_input::Builder {
crate::input::resolve_room_input::Builder::default()
}
}
pub mod revoke_invitation_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) user_arn: std::option::Option<std::string::String>,
pub(crate) enrollment_id: std::option::Option<std::string::String>,
}
impl Builder {
pub fn user_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.user_arn = Some(input.into());
self
}
pub fn set_user_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.user_arn = input;
self
}
pub fn enrollment_id(mut self, input: impl Into<std::string::String>) -> Self {
self.enrollment_id = Some(input.into());
self
}
pub fn set_enrollment_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.enrollment_id = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::RevokeInvitationInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::RevokeInvitationInput {
user_arn: self.user_arn,
enrollment_id: self.enrollment_id,
})
}
}
}
#[doc(hidden)]
pub type RevokeInvitationInputOperationOutputAlias = crate::operation::RevokeInvitation;
#[doc(hidden)]
pub type RevokeInvitationInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl RevokeInvitationInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::RevokeInvitation,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::RevokeInvitationInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::RevokeInvitationInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::RevokeInvitationInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.RevokeInvitation",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_revoke_invitation(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::RevokeInvitation::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"RevokeInvitation",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::revoke_invitation_input::Builder {
crate::input::revoke_invitation_input::Builder::default()
}
}
pub mod search_address_books_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) filters: std::option::Option<std::vec::Vec<crate::model::Filter>>,
pub(crate) sort_criteria: std::option::Option<std::vec::Vec<crate::model::Sort>>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
pub fn filters(mut self, input: impl Into<crate::model::Filter>) -> Self {
let mut v = self.filters.unwrap_or_default();
v.push(input.into());
self.filters = Some(v);
self
}
pub fn set_filters(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Filter>>,
) -> Self {
self.filters = input;
self
}
pub fn sort_criteria(mut self, input: impl Into<crate::model::Sort>) -> Self {
let mut v = self.sort_criteria.unwrap_or_default();
v.push(input.into());
self.sort_criteria = Some(v);
self
}
pub fn set_sort_criteria(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Sort>>,
) -> Self {
self.sort_criteria = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::SearchAddressBooksInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::SearchAddressBooksInput {
filters: self.filters,
sort_criteria: self.sort_criteria,
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
#[doc(hidden)]
pub type SearchAddressBooksInputOperationOutputAlias = crate::operation::SearchAddressBooks;
#[doc(hidden)]
pub type SearchAddressBooksInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl SearchAddressBooksInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::SearchAddressBooks,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::SearchAddressBooksInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::SearchAddressBooksInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::SearchAddressBooksInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.SearchAddressBooks",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_search_address_books(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::SearchAddressBooks::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"SearchAddressBooks",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::search_address_books_input::Builder {
crate::input::search_address_books_input::Builder::default()
}
}
pub mod search_contacts_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) filters: std::option::Option<std::vec::Vec<crate::model::Filter>>,
pub(crate) sort_criteria: std::option::Option<std::vec::Vec<crate::model::Sort>>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
pub fn filters(mut self, input: impl Into<crate::model::Filter>) -> Self {
let mut v = self.filters.unwrap_or_default();
v.push(input.into());
self.filters = Some(v);
self
}
pub fn set_filters(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Filter>>,
) -> Self {
self.filters = input;
self
}
pub fn sort_criteria(mut self, input: impl Into<crate::model::Sort>) -> Self {
let mut v = self.sort_criteria.unwrap_or_default();
v.push(input.into());
self.sort_criteria = Some(v);
self
}
pub fn set_sort_criteria(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Sort>>,
) -> Self {
self.sort_criteria = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::SearchContactsInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::SearchContactsInput {
filters: self.filters,
sort_criteria: self.sort_criteria,
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
#[doc(hidden)]
pub type SearchContactsInputOperationOutputAlias = crate::operation::SearchContacts;
#[doc(hidden)]
pub type SearchContactsInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl SearchContactsInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::SearchContacts,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::SearchContactsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::SearchContactsInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::SearchContactsInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.SearchContacts",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_search_contacts(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::SearchContacts::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"SearchContacts",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::search_contacts_input::Builder {
crate::input::search_contacts_input::Builder::default()
}
}
pub mod search_devices_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) filters: std::option::Option<std::vec::Vec<crate::model::Filter>>,
pub(crate) sort_criteria: std::option::Option<std::vec::Vec<crate::model::Sort>>,
}
impl Builder {
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
pub fn filters(mut self, input: impl Into<crate::model::Filter>) -> Self {
let mut v = self.filters.unwrap_or_default();
v.push(input.into());
self.filters = Some(v);
self
}
pub fn set_filters(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Filter>>,
) -> Self {
self.filters = input;
self
}
pub fn sort_criteria(mut self, input: impl Into<crate::model::Sort>) -> Self {
let mut v = self.sort_criteria.unwrap_or_default();
v.push(input.into());
self.sort_criteria = Some(v);
self
}
pub fn set_sort_criteria(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Sort>>,
) -> Self {
self.sort_criteria = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::SearchDevicesInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::SearchDevicesInput {
next_token: self.next_token,
max_results: self.max_results,
filters: self.filters,
sort_criteria: self.sort_criteria,
})
}
}
}
#[doc(hidden)]
pub type SearchDevicesInputOperationOutputAlias = crate::operation::SearchDevices;
#[doc(hidden)]
pub type SearchDevicesInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl SearchDevicesInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::SearchDevices,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::SearchDevicesInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::SearchDevicesInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::SearchDevicesInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.SearchDevices",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_search_devices(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::SearchDevices::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"SearchDevices",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::search_devices_input::Builder {
crate::input::search_devices_input::Builder::default()
}
}
pub mod search_network_profiles_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) filters: std::option::Option<std::vec::Vec<crate::model::Filter>>,
pub(crate) sort_criteria: std::option::Option<std::vec::Vec<crate::model::Sort>>,
}
impl Builder {
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
pub fn filters(mut self, input: impl Into<crate::model::Filter>) -> Self {
let mut v = self.filters.unwrap_or_default();
v.push(input.into());
self.filters = Some(v);
self
}
pub fn set_filters(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Filter>>,
) -> Self {
self.filters = input;
self
}
pub fn sort_criteria(mut self, input: impl Into<crate::model::Sort>) -> Self {
let mut v = self.sort_criteria.unwrap_or_default();
v.push(input.into());
self.sort_criteria = Some(v);
self
}
pub fn set_sort_criteria(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Sort>>,
) -> Self {
self.sort_criteria = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::SearchNetworkProfilesInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::SearchNetworkProfilesInput {
next_token: self.next_token,
max_results: self.max_results,
filters: self.filters,
sort_criteria: self.sort_criteria,
})
}
}
}
#[doc(hidden)]
pub type SearchNetworkProfilesInputOperationOutputAlias = crate::operation::SearchNetworkProfiles;
#[doc(hidden)]
pub type SearchNetworkProfilesInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl SearchNetworkProfilesInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::SearchNetworkProfiles,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::SearchNetworkProfilesInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::SearchNetworkProfilesInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::SearchNetworkProfilesInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.SearchNetworkProfiles",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_search_network_profiles(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::SearchNetworkProfiles::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"SearchNetworkProfiles",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::search_network_profiles_input::Builder {
crate::input::search_network_profiles_input::Builder::default()
}
}
pub mod search_profiles_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) filters: std::option::Option<std::vec::Vec<crate::model::Filter>>,
pub(crate) sort_criteria: std::option::Option<std::vec::Vec<crate::model::Sort>>,
}
impl Builder {
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
pub fn filters(mut self, input: impl Into<crate::model::Filter>) -> Self {
let mut v = self.filters.unwrap_or_default();
v.push(input.into());
self.filters = Some(v);
self
}
pub fn set_filters(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Filter>>,
) -> Self {
self.filters = input;
self
}
pub fn sort_criteria(mut self, input: impl Into<crate::model::Sort>) -> Self {
let mut v = self.sort_criteria.unwrap_or_default();
v.push(input.into());
self.sort_criteria = Some(v);
self
}
pub fn set_sort_criteria(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Sort>>,
) -> Self {
self.sort_criteria = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::SearchProfilesInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::SearchProfilesInput {
next_token: self.next_token,
max_results: self.max_results,
filters: self.filters,
sort_criteria: self.sort_criteria,
})
}
}
}
#[doc(hidden)]
pub type SearchProfilesInputOperationOutputAlias = crate::operation::SearchProfiles;
#[doc(hidden)]
pub type SearchProfilesInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl SearchProfilesInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::SearchProfiles,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::SearchProfilesInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::SearchProfilesInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::SearchProfilesInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.SearchProfiles",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_search_profiles(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::SearchProfiles::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"SearchProfiles",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::search_profiles_input::Builder {
crate::input::search_profiles_input::Builder::default()
}
}
pub mod search_rooms_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) filters: std::option::Option<std::vec::Vec<crate::model::Filter>>,
pub(crate) sort_criteria: std::option::Option<std::vec::Vec<crate::model::Sort>>,
}
impl Builder {
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
pub fn filters(mut self, input: impl Into<crate::model::Filter>) -> Self {
let mut v = self.filters.unwrap_or_default();
v.push(input.into());
self.filters = Some(v);
self
}
pub fn set_filters(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Filter>>,
) -> Self {
self.filters = input;
self
}
pub fn sort_criteria(mut self, input: impl Into<crate::model::Sort>) -> Self {
let mut v = self.sort_criteria.unwrap_or_default();
v.push(input.into());
self.sort_criteria = Some(v);
self
}
pub fn set_sort_criteria(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Sort>>,
) -> Self {
self.sort_criteria = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::SearchRoomsInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::SearchRoomsInput {
next_token: self.next_token,
max_results: self.max_results,
filters: self.filters,
sort_criteria: self.sort_criteria,
})
}
}
}
#[doc(hidden)]
pub type SearchRoomsInputOperationOutputAlias = crate::operation::SearchRooms;
#[doc(hidden)]
pub type SearchRoomsInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl SearchRoomsInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::SearchRooms,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::SearchRoomsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::SearchRoomsInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::SearchRoomsInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.SearchRooms",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_search_rooms(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::SearchRooms::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"SearchRooms",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::search_rooms_input::Builder {
crate::input::search_rooms_input::Builder::default()
}
}
pub mod search_skill_groups_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) filters: std::option::Option<std::vec::Vec<crate::model::Filter>>,
pub(crate) sort_criteria: std::option::Option<std::vec::Vec<crate::model::Sort>>,
}
impl Builder {
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
pub fn filters(mut self, input: impl Into<crate::model::Filter>) -> Self {
let mut v = self.filters.unwrap_or_default();
v.push(input.into());
self.filters = Some(v);
self
}
pub fn set_filters(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Filter>>,
) -> Self {
self.filters = input;
self
}
pub fn sort_criteria(mut self, input: impl Into<crate::model::Sort>) -> Self {
let mut v = self.sort_criteria.unwrap_or_default();
v.push(input.into());
self.sort_criteria = Some(v);
self
}
pub fn set_sort_criteria(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Sort>>,
) -> Self {
self.sort_criteria = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::SearchSkillGroupsInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::SearchSkillGroupsInput {
next_token: self.next_token,
max_results: self.max_results,
filters: self.filters,
sort_criteria: self.sort_criteria,
})
}
}
}
#[doc(hidden)]
pub type SearchSkillGroupsInputOperationOutputAlias = crate::operation::SearchSkillGroups;
#[doc(hidden)]
pub type SearchSkillGroupsInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl SearchSkillGroupsInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::SearchSkillGroups,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::SearchSkillGroupsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::SearchSkillGroupsInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::SearchSkillGroupsInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.SearchSkillGroups",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_search_skill_groups(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::SearchSkillGroups::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"SearchSkillGroups",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::search_skill_groups_input::Builder {
crate::input::search_skill_groups_input::Builder::default()
}
}
pub mod search_users_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) filters: std::option::Option<std::vec::Vec<crate::model::Filter>>,
pub(crate) sort_criteria: std::option::Option<std::vec::Vec<crate::model::Sort>>,
}
impl Builder {
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
pub fn filters(mut self, input: impl Into<crate::model::Filter>) -> Self {
let mut v = self.filters.unwrap_or_default();
v.push(input.into());
self.filters = Some(v);
self
}
pub fn set_filters(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Filter>>,
) -> Self {
self.filters = input;
self
}
pub fn sort_criteria(mut self, input: impl Into<crate::model::Sort>) -> Self {
let mut v = self.sort_criteria.unwrap_or_default();
v.push(input.into());
self.sort_criteria = Some(v);
self
}
pub fn set_sort_criteria(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Sort>>,
) -> Self {
self.sort_criteria = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::SearchUsersInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::SearchUsersInput {
next_token: self.next_token,
max_results: self.max_results,
filters: self.filters,
sort_criteria: self.sort_criteria,
})
}
}
}
#[doc(hidden)]
pub type SearchUsersInputOperationOutputAlias = crate::operation::SearchUsers;
#[doc(hidden)]
pub type SearchUsersInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl SearchUsersInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::SearchUsers,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::SearchUsersInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::SearchUsersInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::SearchUsersInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.SearchUsers",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_search_users(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::SearchUsers::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"SearchUsers",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::search_users_input::Builder {
crate::input::search_users_input::Builder::default()
}
}
pub mod send_announcement_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) room_filters: std::option::Option<std::vec::Vec<crate::model::Filter>>,
pub(crate) content: std::option::Option<crate::model::Content>,
pub(crate) time_to_live_in_seconds: std::option::Option<i32>,
pub(crate) client_request_token: std::option::Option<std::string::String>,
}
impl Builder {
pub fn room_filters(mut self, input: impl Into<crate::model::Filter>) -> Self {
let mut v = self.room_filters.unwrap_or_default();
v.push(input.into());
self.room_filters = Some(v);
self
}
pub fn set_room_filters(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Filter>>,
) -> Self {
self.room_filters = input;
self
}
pub fn content(mut self, input: crate::model::Content) -> Self {
self.content = Some(input);
self
}
pub fn set_content(mut self, input: std::option::Option<crate::model::Content>) -> Self {
self.content = input;
self
}
pub fn time_to_live_in_seconds(mut self, input: i32) -> Self {
self.time_to_live_in_seconds = Some(input);
self
}
pub fn set_time_to_live_in_seconds(mut self, input: std::option::Option<i32>) -> Self {
self.time_to_live_in_seconds = input;
self
}
pub fn client_request_token(mut self, input: impl Into<std::string::String>) -> Self {
self.client_request_token = Some(input.into());
self
}
pub fn set_client_request_token(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.client_request_token = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::SendAnnouncementInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::SendAnnouncementInput {
room_filters: self.room_filters,
content: self.content,
time_to_live_in_seconds: self.time_to_live_in_seconds,
client_request_token: self.client_request_token,
})
}
}
}
#[doc(hidden)]
pub type SendAnnouncementInputOperationOutputAlias = crate::operation::SendAnnouncement;
#[doc(hidden)]
pub type SendAnnouncementInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl SendAnnouncementInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
mut self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::SendAnnouncement,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::SendAnnouncementInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::SendAnnouncementInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::SendAnnouncementInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.SendAnnouncement",
);
Ok(builder)
}
if self.client_request_token.is_none() {
self.client_request_token = Some(_config.make_token.make_idempotency_token());
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_send_announcement(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::SendAnnouncement::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"SendAnnouncement",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::send_announcement_input::Builder {
crate::input::send_announcement_input::Builder::default()
}
}
pub mod send_invitation_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) user_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn user_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.user_arn = Some(input.into());
self
}
pub fn set_user_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.user_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::SendInvitationInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::SendInvitationInput {
user_arn: self.user_arn,
})
}
}
}
#[doc(hidden)]
pub type SendInvitationInputOperationOutputAlias = crate::operation::SendInvitation;
#[doc(hidden)]
pub type SendInvitationInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl SendInvitationInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::SendInvitation,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::SendInvitationInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::SendInvitationInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::SendInvitationInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.SendInvitation",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_send_invitation(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::SendInvitation::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"SendInvitation",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::send_invitation_input::Builder {
crate::input::send_invitation_input::Builder::default()
}
}
pub mod start_device_sync_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) room_arn: std::option::Option<std::string::String>,
pub(crate) device_arn: std::option::Option<std::string::String>,
pub(crate) features: std::option::Option<std::vec::Vec<crate::model::Feature>>,
}
impl Builder {
pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.room_arn = Some(input.into());
self
}
pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_arn = input;
self
}
pub fn device_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.device_arn = Some(input.into());
self
}
pub fn set_device_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.device_arn = input;
self
}
pub fn features(mut self, input: impl Into<crate::model::Feature>) -> Self {
let mut v = self.features.unwrap_or_default();
v.push(input.into());
self.features = Some(v);
self
}
pub fn set_features(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Feature>>,
) -> Self {
self.features = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::StartDeviceSyncInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::StartDeviceSyncInput {
room_arn: self.room_arn,
device_arn: self.device_arn,
features: self.features,
})
}
}
}
#[doc(hidden)]
pub type StartDeviceSyncInputOperationOutputAlias = crate::operation::StartDeviceSync;
#[doc(hidden)]
pub type StartDeviceSyncInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl StartDeviceSyncInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::StartDeviceSync,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::StartDeviceSyncInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StartDeviceSyncInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::StartDeviceSyncInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.StartDeviceSync",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_start_device_sync(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StartDeviceSync::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StartDeviceSync",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::start_device_sync_input::Builder {
crate::input::start_device_sync_input::Builder::default()
}
}
pub mod start_smart_home_appliance_discovery_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) room_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.room_arn = Some(input.into());
self
}
pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::StartSmartHomeApplianceDiscoveryInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::StartSmartHomeApplianceDiscoveryInput {
room_arn: self.room_arn,
})
}
}
}
#[doc(hidden)]
pub type StartSmartHomeApplianceDiscoveryInputOperationOutputAlias =
crate::operation::StartSmartHomeApplianceDiscovery;
#[doc(hidden)]
pub type StartSmartHomeApplianceDiscoveryInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl StartSmartHomeApplianceDiscoveryInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::StartSmartHomeApplianceDiscovery,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::StartSmartHomeApplianceDiscoveryInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StartSmartHomeApplianceDiscoveryInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::StartSmartHomeApplianceDiscoveryInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.StartSmartHomeApplianceDiscovery",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_start_smart_home_appliance_discovery(&self)?
;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StartSmartHomeApplianceDiscovery::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StartSmartHomeApplianceDiscovery",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::start_smart_home_appliance_discovery_input::Builder {
crate::input::start_smart_home_appliance_discovery_input::Builder::default()
}
}
pub mod tag_resource_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) arn: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
self.arn = Some(input.into());
self
}
pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.arn = input;
self
}
pub fn tags(mut self, input: impl Into<crate::model::Tag>) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input.into());
self.tags = Some(v);
self
}
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::TagResourceInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::TagResourceInput {
arn: self.arn,
tags: self.tags,
})
}
}
}
#[doc(hidden)]
pub type TagResourceInputOperationOutputAlias = crate::operation::TagResource;
#[doc(hidden)]
pub type TagResourceInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl TagResourceInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::TagResource,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::TagResourceInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::TagResourceInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::TagResourceInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.TagResource",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_tag_resource(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::TagResource::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"TagResource",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::tag_resource_input::Builder {
crate::input::tag_resource_input::Builder::default()
}
}
pub mod untag_resource_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) arn: std::option::Option<std::string::String>,
pub(crate) tag_keys: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
self.arn = Some(input.into());
self
}
pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.arn = input;
self
}
pub fn tag_keys(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.tag_keys.unwrap_or_default();
v.push(input.into());
self.tag_keys = Some(v);
self
}
pub fn set_tag_keys(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.tag_keys = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::UntagResourceInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::UntagResourceInput {
arn: self.arn,
tag_keys: self.tag_keys,
})
}
}
}
#[doc(hidden)]
pub type UntagResourceInputOperationOutputAlias = crate::operation::UntagResource;
#[doc(hidden)]
pub type UntagResourceInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl UntagResourceInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UntagResource,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::UntagResourceInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UntagResourceInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::UntagResourceInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.UntagResource",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_untag_resource(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UntagResource::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UntagResource",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::untag_resource_input::Builder {
crate::input::untag_resource_input::Builder::default()
}
}
pub mod update_address_book_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) address_book_arn: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
}
impl Builder {
pub fn address_book_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.address_book_arn = Some(input.into());
self
}
pub fn set_address_book_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.address_book_arn = input;
self
}
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::UpdateAddressBookInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::UpdateAddressBookInput {
address_book_arn: self.address_book_arn,
name: self.name,
description: self.description,
})
}
}
}
#[doc(hidden)]
pub type UpdateAddressBookInputOperationOutputAlias = crate::operation::UpdateAddressBook;
#[doc(hidden)]
pub type UpdateAddressBookInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl UpdateAddressBookInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateAddressBook,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::UpdateAddressBookInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateAddressBookInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::UpdateAddressBookInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.UpdateAddressBook",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_update_address_book(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateAddressBook::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateAddressBook",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::update_address_book_input::Builder {
crate::input::update_address_book_input::Builder::default()
}
}
pub mod update_business_report_schedule_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) schedule_arn: std::option::Option<std::string::String>,
pub(crate) s3_bucket_name: std::option::Option<std::string::String>,
pub(crate) s3_key_prefix: std::option::Option<std::string::String>,
pub(crate) format: std::option::Option<crate::model::BusinessReportFormat>,
pub(crate) schedule_name: std::option::Option<std::string::String>,
pub(crate) recurrence: std::option::Option<crate::model::BusinessReportRecurrence>,
}
impl Builder {
pub fn schedule_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.schedule_arn = Some(input.into());
self
}
pub fn set_schedule_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.schedule_arn = input;
self
}
pub fn s3_bucket_name(mut self, input: impl Into<std::string::String>) -> Self {
self.s3_bucket_name = Some(input.into());
self
}
pub fn set_s3_bucket_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.s3_bucket_name = input;
self
}
pub fn s3_key_prefix(mut self, input: impl Into<std::string::String>) -> Self {
self.s3_key_prefix = Some(input.into());
self
}
pub fn set_s3_key_prefix(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.s3_key_prefix = input;
self
}
pub fn format(mut self, input: crate::model::BusinessReportFormat) -> Self {
self.format = Some(input);
self
}
pub fn set_format(
mut self,
input: std::option::Option<crate::model::BusinessReportFormat>,
) -> Self {
self.format = input;
self
}
pub fn schedule_name(mut self, input: impl Into<std::string::String>) -> Self {
self.schedule_name = Some(input.into());
self
}
pub fn set_schedule_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.schedule_name = input;
self
}
pub fn recurrence(mut self, input: crate::model::BusinessReportRecurrence) -> Self {
self.recurrence = Some(input);
self
}
pub fn set_recurrence(
mut self,
input: std::option::Option<crate::model::BusinessReportRecurrence>,
) -> Self {
self.recurrence = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::UpdateBusinessReportScheduleInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::UpdateBusinessReportScheduleInput {
schedule_arn: self.schedule_arn,
s3_bucket_name: self.s3_bucket_name,
s3_key_prefix: self.s3_key_prefix,
format: self.format,
schedule_name: self.schedule_name,
recurrence: self.recurrence,
})
}
}
}
#[doc(hidden)]
pub type UpdateBusinessReportScheduleInputOperationOutputAlias =
crate::operation::UpdateBusinessReportSchedule;
#[doc(hidden)]
pub type UpdateBusinessReportScheduleInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl UpdateBusinessReportScheduleInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateBusinessReportSchedule,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::UpdateBusinessReportScheduleInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateBusinessReportScheduleInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::UpdateBusinessReportScheduleInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.UpdateBusinessReportSchedule",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_update_business_report_schedule(&self)?
;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateBusinessReportSchedule::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateBusinessReportSchedule",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::update_business_report_schedule_input::Builder {
crate::input::update_business_report_schedule_input::Builder::default()
}
}
pub mod update_conference_provider_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) conference_provider_arn: std::option::Option<std::string::String>,
pub(crate) conference_provider_type:
std::option::Option<crate::model::ConferenceProviderType>,
pub(crate) ip_dial_in: std::option::Option<crate::model::IpDialIn>,
pub(crate) pstn_dial_in: std::option::Option<crate::model::PstnDialIn>,
pub(crate) meeting_setting: std::option::Option<crate::model::MeetingSetting>,
}
impl Builder {
pub fn conference_provider_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.conference_provider_arn = Some(input.into());
self
}
pub fn set_conference_provider_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.conference_provider_arn = input;
self
}
pub fn conference_provider_type(
mut self,
input: crate::model::ConferenceProviderType,
) -> Self {
self.conference_provider_type = Some(input);
self
}
pub fn set_conference_provider_type(
mut self,
input: std::option::Option<crate::model::ConferenceProviderType>,
) -> Self {
self.conference_provider_type = input;
self
}
pub fn ip_dial_in(mut self, input: crate::model::IpDialIn) -> Self {
self.ip_dial_in = Some(input);
self
}
pub fn set_ip_dial_in(
mut self,
input: std::option::Option<crate::model::IpDialIn>,
) -> Self {
self.ip_dial_in = input;
self
}
pub fn pstn_dial_in(mut self, input: crate::model::PstnDialIn) -> Self {
self.pstn_dial_in = Some(input);
self
}
pub fn set_pstn_dial_in(
mut self,
input: std::option::Option<crate::model::PstnDialIn>,
) -> Self {
self.pstn_dial_in = input;
self
}
pub fn meeting_setting(mut self, input: crate::model::MeetingSetting) -> Self {
self.meeting_setting = Some(input);
self
}
pub fn set_meeting_setting(
mut self,
input: std::option::Option<crate::model::MeetingSetting>,
) -> Self {
self.meeting_setting = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::UpdateConferenceProviderInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::UpdateConferenceProviderInput {
conference_provider_arn: self.conference_provider_arn,
conference_provider_type: self.conference_provider_type,
ip_dial_in: self.ip_dial_in,
pstn_dial_in: self.pstn_dial_in,
meeting_setting: self.meeting_setting,
})
}
}
}
#[doc(hidden)]
pub type UpdateConferenceProviderInputOperationOutputAlias =
crate::operation::UpdateConferenceProvider;
#[doc(hidden)]
pub type UpdateConferenceProviderInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl UpdateConferenceProviderInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateConferenceProvider,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::UpdateConferenceProviderInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateConferenceProviderInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::UpdateConferenceProviderInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.UpdateConferenceProvider",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_update_conference_provider(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateConferenceProvider::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateConferenceProvider",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::update_conference_provider_input::Builder {
crate::input::update_conference_provider_input::Builder::default()
}
}
pub mod update_contact_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) contact_arn: std::option::Option<std::string::String>,
pub(crate) display_name: std::option::Option<std::string::String>,
pub(crate) first_name: std::option::Option<std::string::String>,
pub(crate) last_name: std::option::Option<std::string::String>,
pub(crate) phone_number: std::option::Option<std::string::String>,
pub(crate) phone_numbers: std::option::Option<std::vec::Vec<crate::model::PhoneNumber>>,
pub(crate) sip_addresses: std::option::Option<std::vec::Vec<crate::model::SipAddress>>,
}
impl Builder {
pub fn contact_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.contact_arn = Some(input.into());
self
}
pub fn set_contact_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.contact_arn = input;
self
}
pub fn display_name(mut self, input: impl Into<std::string::String>) -> Self {
self.display_name = Some(input.into());
self
}
pub fn set_display_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.display_name = input;
self
}
pub fn first_name(mut self, input: impl Into<std::string::String>) -> Self {
self.first_name = Some(input.into());
self
}
pub fn set_first_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.first_name = input;
self
}
pub fn last_name(mut self, input: impl Into<std::string::String>) -> Self {
self.last_name = Some(input.into());
self
}
pub fn set_last_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.last_name = input;
self
}
pub fn phone_number(mut self, input: impl Into<std::string::String>) -> Self {
self.phone_number = Some(input.into());
self
}
pub fn set_phone_number(mut self, input: std::option::Option<std::string::String>) -> Self {
self.phone_number = input;
self
}
pub fn phone_numbers(mut self, input: impl Into<crate::model::PhoneNumber>) -> Self {
let mut v = self.phone_numbers.unwrap_or_default();
v.push(input.into());
self.phone_numbers = Some(v);
self
}
pub fn set_phone_numbers(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::PhoneNumber>>,
) -> Self {
self.phone_numbers = input;
self
}
pub fn sip_addresses(mut self, input: impl Into<crate::model::SipAddress>) -> Self {
let mut v = self.sip_addresses.unwrap_or_default();
v.push(input.into());
self.sip_addresses = Some(v);
self
}
pub fn set_sip_addresses(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::SipAddress>>,
) -> Self {
self.sip_addresses = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::UpdateContactInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::UpdateContactInput {
contact_arn: self.contact_arn,
display_name: self.display_name,
first_name: self.first_name,
last_name: self.last_name,
phone_number: self.phone_number,
phone_numbers: self.phone_numbers,
sip_addresses: self.sip_addresses,
})
}
}
}
#[doc(hidden)]
pub type UpdateContactInputOperationOutputAlias = crate::operation::UpdateContact;
#[doc(hidden)]
pub type UpdateContactInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl UpdateContactInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateContact,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::UpdateContactInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateContactInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::UpdateContactInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.UpdateContact",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_update_contact(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateContact::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateContact",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::update_contact_input::Builder {
crate::input::update_contact_input::Builder::default()
}
}
pub mod update_device_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) device_arn: std::option::Option<std::string::String>,
pub(crate) device_name: std::option::Option<std::string::String>,
}
impl Builder {
pub fn device_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.device_arn = Some(input.into());
self
}
pub fn set_device_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.device_arn = input;
self
}
pub fn device_name(mut self, input: impl Into<std::string::String>) -> Self {
self.device_name = Some(input.into());
self
}
pub fn set_device_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.device_name = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::UpdateDeviceInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::UpdateDeviceInput {
device_arn: self.device_arn,
device_name: self.device_name,
})
}
}
}
#[doc(hidden)]
pub type UpdateDeviceInputOperationOutputAlias = crate::operation::UpdateDevice;
#[doc(hidden)]
pub type UpdateDeviceInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl UpdateDeviceInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateDevice,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::UpdateDeviceInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateDeviceInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::UpdateDeviceInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.UpdateDevice",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_update_device(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateDevice::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateDevice",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::update_device_input::Builder {
crate::input::update_device_input::Builder::default()
}
}
pub mod update_gateway_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) gateway_arn: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) software_version: std::option::Option<std::string::String>,
}
impl Builder {
pub fn gateway_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.gateway_arn = Some(input.into());
self
}
pub fn set_gateway_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.gateway_arn = input;
self
}
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn software_version(mut self, input: impl Into<std::string::String>) -> Self {
self.software_version = Some(input.into());
self
}
pub fn set_software_version(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.software_version = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::UpdateGatewayInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::UpdateGatewayInput {
gateway_arn: self.gateway_arn,
name: self.name,
description: self.description,
software_version: self.software_version,
})
}
}
}
#[doc(hidden)]
pub type UpdateGatewayInputOperationOutputAlias = crate::operation::UpdateGateway;
#[doc(hidden)]
pub type UpdateGatewayInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl UpdateGatewayInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateGateway,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::UpdateGatewayInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateGatewayInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::UpdateGatewayInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.UpdateGateway",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_update_gateway(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateGateway::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateGateway",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::update_gateway_input::Builder {
crate::input::update_gateway_input::Builder::default()
}
}
pub mod update_gateway_group_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) gateway_group_arn: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
}
impl Builder {
pub fn gateway_group_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.gateway_group_arn = Some(input.into());
self
}
pub fn set_gateway_group_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.gateway_group_arn = input;
self
}
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::UpdateGatewayGroupInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::UpdateGatewayGroupInput {
gateway_group_arn: self.gateway_group_arn,
name: self.name,
description: self.description,
})
}
}
}
#[doc(hidden)]
pub type UpdateGatewayGroupInputOperationOutputAlias = crate::operation::UpdateGatewayGroup;
#[doc(hidden)]
pub type UpdateGatewayGroupInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl UpdateGatewayGroupInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateGatewayGroup,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::UpdateGatewayGroupInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateGatewayGroupInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::UpdateGatewayGroupInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.UpdateGatewayGroup",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_update_gateway_group(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateGatewayGroup::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateGatewayGroup",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::update_gateway_group_input::Builder {
crate::input::update_gateway_group_input::Builder::default()
}
}
pub mod update_network_profile_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) network_profile_arn: std::option::Option<std::string::String>,
pub(crate) network_profile_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) current_password: std::option::Option<std::string::String>,
pub(crate) next_password: std::option::Option<std::string::String>,
pub(crate) certificate_authority_arn: std::option::Option<std::string::String>,
pub(crate) trust_anchors: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
pub fn network_profile_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.network_profile_arn = Some(input.into());
self
}
pub fn set_network_profile_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.network_profile_arn = input;
self
}
pub fn network_profile_name(mut self, input: impl Into<std::string::String>) -> Self {
self.network_profile_name = Some(input.into());
self
}
pub fn set_network_profile_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.network_profile_name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn current_password(mut self, input: impl Into<std::string::String>) -> Self {
self.current_password = Some(input.into());
self
}
pub fn set_current_password(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.current_password = input;
self
}
pub fn next_password(mut self, input: impl Into<std::string::String>) -> Self {
self.next_password = Some(input.into());
self
}
pub fn set_next_password(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.next_password = input;
self
}
pub fn certificate_authority_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.certificate_authority_arn = Some(input.into());
self
}
pub fn set_certificate_authority_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.certificate_authority_arn = input;
self
}
pub fn trust_anchors(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.trust_anchors.unwrap_or_default();
v.push(input.into());
self.trust_anchors = Some(v);
self
}
pub fn set_trust_anchors(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.trust_anchors = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::UpdateNetworkProfileInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::UpdateNetworkProfileInput {
network_profile_arn: self.network_profile_arn,
network_profile_name: self.network_profile_name,
description: self.description,
current_password: self.current_password,
next_password: self.next_password,
certificate_authority_arn: self.certificate_authority_arn,
trust_anchors: self.trust_anchors,
})
}
}
}
#[doc(hidden)]
pub type UpdateNetworkProfileInputOperationOutputAlias = crate::operation::UpdateNetworkProfile;
#[doc(hidden)]
pub type UpdateNetworkProfileInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl UpdateNetworkProfileInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateNetworkProfile,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::UpdateNetworkProfileInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateNetworkProfileInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::UpdateNetworkProfileInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.UpdateNetworkProfile",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_update_network_profile(
&self,
)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateNetworkProfile::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateNetworkProfile",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::update_network_profile_input::Builder {
crate::input::update_network_profile_input::Builder::default()
}
}
pub mod update_profile_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) profile_arn: std::option::Option<std::string::String>,
pub(crate) profile_name: std::option::Option<std::string::String>,
pub(crate) is_default: std::option::Option<bool>,
pub(crate) timezone: std::option::Option<std::string::String>,
pub(crate) address: std::option::Option<std::string::String>,
pub(crate) distance_unit: std::option::Option<crate::model::DistanceUnit>,
pub(crate) temperature_unit: std::option::Option<crate::model::TemperatureUnit>,
pub(crate) wake_word: std::option::Option<crate::model::WakeWord>,
pub(crate) locale: std::option::Option<std::string::String>,
pub(crate) setup_mode_disabled: std::option::Option<bool>,
pub(crate) max_volume_limit: std::option::Option<i32>,
pub(crate) pstn_enabled: std::option::Option<bool>,
pub(crate) data_retention_opt_in: std::option::Option<bool>,
pub(crate) meeting_room_configuration:
std::option::Option<crate::model::UpdateMeetingRoomConfiguration>,
}
impl Builder {
pub fn profile_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.profile_arn = Some(input.into());
self
}
pub fn set_profile_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.profile_arn = input;
self
}
pub fn profile_name(mut self, input: impl Into<std::string::String>) -> Self {
self.profile_name = Some(input.into());
self
}
pub fn set_profile_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.profile_name = input;
self
}
pub fn is_default(mut self, input: bool) -> Self {
self.is_default = Some(input);
self
}
pub fn set_is_default(mut self, input: std::option::Option<bool>) -> Self {
self.is_default = input;
self
}
pub fn timezone(mut self, input: impl Into<std::string::String>) -> Self {
self.timezone = Some(input.into());
self
}
pub fn set_timezone(mut self, input: std::option::Option<std::string::String>) -> Self {
self.timezone = input;
self
}
pub fn address(mut self, input: impl Into<std::string::String>) -> Self {
self.address = Some(input.into());
self
}
pub fn set_address(mut self, input: std::option::Option<std::string::String>) -> Self {
self.address = input;
self
}
pub fn distance_unit(mut self, input: crate::model::DistanceUnit) -> Self {
self.distance_unit = Some(input);
self
}
pub fn set_distance_unit(
mut self,
input: std::option::Option<crate::model::DistanceUnit>,
) -> Self {
self.distance_unit = input;
self
}
pub fn temperature_unit(mut self, input: crate::model::TemperatureUnit) -> Self {
self.temperature_unit = Some(input);
self
}
pub fn set_temperature_unit(
mut self,
input: std::option::Option<crate::model::TemperatureUnit>,
) -> Self {
self.temperature_unit = input;
self
}
pub fn wake_word(mut self, input: crate::model::WakeWord) -> Self {
self.wake_word = Some(input);
self
}
pub fn set_wake_word(mut self, input: std::option::Option<crate::model::WakeWord>) -> Self {
self.wake_word = input;
self
}
pub fn locale(mut self, input: impl Into<std::string::String>) -> Self {
self.locale = Some(input.into());
self
}
pub fn set_locale(mut self, input: std::option::Option<std::string::String>) -> Self {
self.locale = input;
self
}
pub fn setup_mode_disabled(mut self, input: bool) -> Self {
self.setup_mode_disabled = Some(input);
self
}
pub fn set_setup_mode_disabled(mut self, input: std::option::Option<bool>) -> Self {
self.setup_mode_disabled = input;
self
}
pub fn max_volume_limit(mut self, input: i32) -> Self {
self.max_volume_limit = Some(input);
self
}
pub fn set_max_volume_limit(mut self, input: std::option::Option<i32>) -> Self {
self.max_volume_limit = input;
self
}
pub fn pstn_enabled(mut self, input: bool) -> Self {
self.pstn_enabled = Some(input);
self
}
pub fn set_pstn_enabled(mut self, input: std::option::Option<bool>) -> Self {
self.pstn_enabled = input;
self
}
pub fn data_retention_opt_in(mut self, input: bool) -> Self {
self.data_retention_opt_in = Some(input);
self
}
pub fn set_data_retention_opt_in(mut self, input: std::option::Option<bool>) -> Self {
self.data_retention_opt_in = input;
self
}
pub fn meeting_room_configuration(
mut self,
input: crate::model::UpdateMeetingRoomConfiguration,
) -> Self {
self.meeting_room_configuration = Some(input);
self
}
pub fn set_meeting_room_configuration(
mut self,
input: std::option::Option<crate::model::UpdateMeetingRoomConfiguration>,
) -> Self {
self.meeting_room_configuration = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::UpdateProfileInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::UpdateProfileInput {
profile_arn: self.profile_arn,
profile_name: self.profile_name,
is_default: self.is_default,
timezone: self.timezone,
address: self.address,
distance_unit: self.distance_unit,
temperature_unit: self.temperature_unit,
wake_word: self.wake_word,
locale: self.locale,
setup_mode_disabled: self.setup_mode_disabled,
max_volume_limit: self.max_volume_limit,
pstn_enabled: self.pstn_enabled,
data_retention_opt_in: self.data_retention_opt_in,
meeting_room_configuration: self.meeting_room_configuration,
})
}
}
}
#[doc(hidden)]
pub type UpdateProfileInputOperationOutputAlias = crate::operation::UpdateProfile;
#[doc(hidden)]
pub type UpdateProfileInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl UpdateProfileInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateProfile,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::UpdateProfileInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateProfileInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::UpdateProfileInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.UpdateProfile",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_update_profile(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateProfile::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateProfile",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::update_profile_input::Builder {
crate::input::update_profile_input::Builder::default()
}
}
pub mod update_room_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) room_arn: std::option::Option<std::string::String>,
pub(crate) room_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) provider_calendar_id: std::option::Option<std::string::String>,
pub(crate) profile_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn room_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.room_arn = Some(input.into());
self
}
pub fn set_room_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_arn = input;
self
}
pub fn room_name(mut self, input: impl Into<std::string::String>) -> Self {
self.room_name = Some(input.into());
self
}
pub fn set_room_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.room_name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn provider_calendar_id(mut self, input: impl Into<std::string::String>) -> Self {
self.provider_calendar_id = Some(input.into());
self
}
pub fn set_provider_calendar_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.provider_calendar_id = input;
self
}
pub fn profile_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.profile_arn = Some(input.into());
self
}
pub fn set_profile_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.profile_arn = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::UpdateRoomInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::UpdateRoomInput {
room_arn: self.room_arn,
room_name: self.room_name,
description: self.description,
provider_calendar_id: self.provider_calendar_id,
profile_arn: self.profile_arn,
})
}
}
}
#[doc(hidden)]
pub type UpdateRoomInputOperationOutputAlias = crate::operation::UpdateRoom;
#[doc(hidden)]
pub type UpdateRoomInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl UpdateRoomInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateRoom,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::UpdateRoomInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateRoomInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::UpdateRoomInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.UpdateRoom",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body = crate::operation_ser::serialize_operation_crate_operation_update_room(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateRoom::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateRoom",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::update_room_input::Builder {
crate::input::update_room_input::Builder::default()
}
}
pub mod update_skill_group_input {
#[non_exhaustive]
#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Builder {
pub(crate) skill_group_arn: std::option::Option<std::string::String>,
pub(crate) skill_group_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
}
impl Builder {
pub fn skill_group_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_group_arn = Some(input.into());
self
}
pub fn set_skill_group_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.skill_group_arn = input;
self
}
pub fn skill_group_name(mut self, input: impl Into<std::string::String>) -> Self {
self.skill_group_name = Some(input.into());
self
}
pub fn set_skill_group_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.skill_group_name = input;
self
}
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
pub fn build(
self,
) -> std::result::Result<
crate::input::UpdateSkillGroupInput,
aws_smithy_http::operation::BuildError,
> {
Ok(crate::input::UpdateSkillGroupInput {
skill_group_arn: self.skill_group_arn,
skill_group_name: self.skill_group_name,
description: self.description,
})
}
}
}
#[doc(hidden)]
pub type UpdateSkillGroupInputOperationOutputAlias = crate::operation::UpdateSkillGroup;
#[doc(hidden)]
pub type UpdateSkillGroupInputOperationRetryAlias = aws_http::AwsErrorRetryPolicy;
impl UpdateSkillGroupInput {
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateSkillGroup,
aws_http::AwsErrorRetryPolicy,
>,
aws_smithy_http::operation::BuildError,
> {
fn uri_base(
_input: &crate::input::UpdateSkillGroupInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateSkillGroupInput,
builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
#[allow(clippy::unnecessary_wraps)]
fn request_builder_base(
input: &crate::input::UpdateSkillGroupInput,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
{
#[allow(unused_mut)]
let mut builder = update_http_builder(input, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("content-type"),
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AlexaForBusiness.UpdateSkillGroup",
);
Ok(builder)
}
let properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
let request = request_builder_base(&self)?;
let body =
crate::operation_ser::serialize_operation_crate_operation_update_skill_group(&self)?;
let request = Self::assemble(request, body);
#[allow(unused_mut)]
let mut request = aws_smithy_http::operation::Request::from_parts(
request.map(aws_smithy_http::body::SdkBody::from),
properties,
);
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
#[allow(unused_mut)]
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
aws_endpoint::set_endpoint_resolver(
&mut request.properties_mut(),
_config.endpoint_resolver.clone(),
);
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_provider(
&mut request.properties_mut(),
_config.credentials_provider.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateSkillGroup::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateSkillGroup",
"alexaforbusiness",
));
let op = op.with_retry_policy(aws_http::AwsErrorRetryPolicy::new());
Ok(op)
}
fn assemble(
builder: http::request::Builder,
body: aws_smithy_http::body::SdkBody,
) -> http::request::Request<aws_smithy_http::body::SdkBody> {
let mut builder = builder;
if let Some(content_length) = body.content_length() {
builder = aws_smithy_http::header::set_header_if_absent(
builder,
http::header::CONTENT_LENGTH,
content_length,
);
}
builder.body(body).expect("should be valid request")
}
pub fn builder() -> crate::input::update_skill_group_input::Builder {
crate::input::update_skill_group_input::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateSkillGroupInput {
pub skill_group_arn: std::option::Option<std::string::String>,
pub skill_group_name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
}
impl UpdateSkillGroupInput {
pub fn skill_group_arn(&self) -> std::option::Option<&str> {
self.skill_group_arn.as_deref()
}
pub fn skill_group_name(&self) -> std::option::Option<&str> {
self.skill_group_name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
}
impl std::fmt::Debug for UpdateSkillGroupInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UpdateSkillGroupInput");
formatter.field("skill_group_arn", &self.skill_group_arn);
formatter.field("skill_group_name", &self.skill_group_name);
formatter.field("description", &self.description);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateRoomInput {
pub room_arn: std::option::Option<std::string::String>,
pub room_name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
pub provider_calendar_id: std::option::Option<std::string::String>,
pub profile_arn: std::option::Option<std::string::String>,
}
impl UpdateRoomInput {
pub fn room_arn(&self) -> std::option::Option<&str> {
self.room_arn.as_deref()
}
pub fn room_name(&self) -> std::option::Option<&str> {
self.room_name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
pub fn provider_calendar_id(&self) -> std::option::Option<&str> {
self.provider_calendar_id.as_deref()
}
pub fn profile_arn(&self) -> std::option::Option<&str> {
self.profile_arn.as_deref()
}
}
impl std::fmt::Debug for UpdateRoomInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UpdateRoomInput");
formatter.field("room_arn", &self.room_arn);
formatter.field("room_name", &self.room_name);
formatter.field("description", &self.description);
formatter.field("provider_calendar_id", &self.provider_calendar_id);
formatter.field("profile_arn", &self.profile_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateProfileInput {
pub profile_arn: std::option::Option<std::string::String>,
pub profile_name: std::option::Option<std::string::String>,
pub is_default: std::option::Option<bool>,
pub timezone: std::option::Option<std::string::String>,
pub address: std::option::Option<std::string::String>,
pub distance_unit: std::option::Option<crate::model::DistanceUnit>,
pub temperature_unit: std::option::Option<crate::model::TemperatureUnit>,
pub wake_word: std::option::Option<crate::model::WakeWord>,
pub locale: std::option::Option<std::string::String>,
pub setup_mode_disabled: std::option::Option<bool>,
pub max_volume_limit: std::option::Option<i32>,
pub pstn_enabled: std::option::Option<bool>,
pub data_retention_opt_in: std::option::Option<bool>,
pub meeting_room_configuration:
std::option::Option<crate::model::UpdateMeetingRoomConfiguration>,
}
impl UpdateProfileInput {
pub fn profile_arn(&self) -> std::option::Option<&str> {
self.profile_arn.as_deref()
}
pub fn profile_name(&self) -> std::option::Option<&str> {
self.profile_name.as_deref()
}
pub fn is_default(&self) -> std::option::Option<bool> {
self.is_default
}
pub fn timezone(&self) -> std::option::Option<&str> {
self.timezone.as_deref()
}
pub fn address(&self) -> std::option::Option<&str> {
self.address.as_deref()
}
pub fn distance_unit(&self) -> std::option::Option<&crate::model::DistanceUnit> {
self.distance_unit.as_ref()
}
pub fn temperature_unit(&self) -> std::option::Option<&crate::model::TemperatureUnit> {
self.temperature_unit.as_ref()
}
pub fn wake_word(&self) -> std::option::Option<&crate::model::WakeWord> {
self.wake_word.as_ref()
}
pub fn locale(&self) -> std::option::Option<&str> {
self.locale.as_deref()
}
pub fn setup_mode_disabled(&self) -> std::option::Option<bool> {
self.setup_mode_disabled
}
pub fn max_volume_limit(&self) -> std::option::Option<i32> {
self.max_volume_limit
}
pub fn pstn_enabled(&self) -> std::option::Option<bool> {
self.pstn_enabled
}
pub fn data_retention_opt_in(&self) -> std::option::Option<bool> {
self.data_retention_opt_in
}
pub fn meeting_room_configuration(
&self,
) -> std::option::Option<&crate::model::UpdateMeetingRoomConfiguration> {
self.meeting_room_configuration.as_ref()
}
}
impl std::fmt::Debug for UpdateProfileInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UpdateProfileInput");
formatter.field("profile_arn", &self.profile_arn);
formatter.field("profile_name", &self.profile_name);
formatter.field("is_default", &self.is_default);
formatter.field("timezone", &self.timezone);
formatter.field("address", &self.address);
formatter.field("distance_unit", &self.distance_unit);
formatter.field("temperature_unit", &self.temperature_unit);
formatter.field("wake_word", &self.wake_word);
formatter.field("locale", &self.locale);
formatter.field("setup_mode_disabled", &self.setup_mode_disabled);
formatter.field("max_volume_limit", &self.max_volume_limit);
formatter.field("pstn_enabled", &self.pstn_enabled);
formatter.field("data_retention_opt_in", &self.data_retention_opt_in);
formatter.field(
"meeting_room_configuration",
&self.meeting_room_configuration,
);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateNetworkProfileInput {
pub network_profile_arn: std::option::Option<std::string::String>,
pub network_profile_name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
pub current_password: std::option::Option<std::string::String>,
pub next_password: std::option::Option<std::string::String>,
pub certificate_authority_arn: std::option::Option<std::string::String>,
pub trust_anchors: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl UpdateNetworkProfileInput {
pub fn network_profile_arn(&self) -> std::option::Option<&str> {
self.network_profile_arn.as_deref()
}
pub fn network_profile_name(&self) -> std::option::Option<&str> {
self.network_profile_name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
pub fn current_password(&self) -> std::option::Option<&str> {
self.current_password.as_deref()
}
pub fn next_password(&self) -> std::option::Option<&str> {
self.next_password.as_deref()
}
pub fn certificate_authority_arn(&self) -> std::option::Option<&str> {
self.certificate_authority_arn.as_deref()
}
pub fn trust_anchors(&self) -> std::option::Option<&[std::string::String]> {
self.trust_anchors.as_deref()
}
}
impl std::fmt::Debug for UpdateNetworkProfileInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UpdateNetworkProfileInput");
formatter.field("network_profile_arn", &self.network_profile_arn);
formatter.field("network_profile_name", &self.network_profile_name);
formatter.field("description", &self.description);
formatter.field("current_password", &"*** Sensitive Data Redacted ***");
formatter.field("next_password", &"*** Sensitive Data Redacted ***");
formatter.field("certificate_authority_arn", &self.certificate_authority_arn);
formatter.field("trust_anchors", &self.trust_anchors);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateGatewayGroupInput {
pub gateway_group_arn: std::option::Option<std::string::String>,
pub name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
}
impl UpdateGatewayGroupInput {
pub fn gateway_group_arn(&self) -> std::option::Option<&str> {
self.gateway_group_arn.as_deref()
}
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
}
impl std::fmt::Debug for UpdateGatewayGroupInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UpdateGatewayGroupInput");
formatter.field("gateway_group_arn", &self.gateway_group_arn);
formatter.field("name", &self.name);
formatter.field("description", &self.description);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateGatewayInput {
pub gateway_arn: std::option::Option<std::string::String>,
pub name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
pub software_version: std::option::Option<std::string::String>,
}
impl UpdateGatewayInput {
pub fn gateway_arn(&self) -> std::option::Option<&str> {
self.gateway_arn.as_deref()
}
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
pub fn software_version(&self) -> std::option::Option<&str> {
self.software_version.as_deref()
}
}
impl std::fmt::Debug for UpdateGatewayInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UpdateGatewayInput");
formatter.field("gateway_arn", &self.gateway_arn);
formatter.field("name", &self.name);
formatter.field("description", &self.description);
formatter.field("software_version", &self.software_version);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateDeviceInput {
pub device_arn: std::option::Option<std::string::String>,
pub device_name: std::option::Option<std::string::String>,
}
impl UpdateDeviceInput {
pub fn device_arn(&self) -> std::option::Option<&str> {
self.device_arn.as_deref()
}
pub fn device_name(&self) -> std::option::Option<&str> {
self.device_name.as_deref()
}
}
impl std::fmt::Debug for UpdateDeviceInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UpdateDeviceInput");
formatter.field("device_arn", &self.device_arn);
formatter.field("device_name", &self.device_name);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateContactInput {
pub contact_arn: std::option::Option<std::string::String>,
pub display_name: std::option::Option<std::string::String>,
pub first_name: std::option::Option<std::string::String>,
pub last_name: std::option::Option<std::string::String>,
pub phone_number: std::option::Option<std::string::String>,
pub phone_numbers: std::option::Option<std::vec::Vec<crate::model::PhoneNumber>>,
pub sip_addresses: std::option::Option<std::vec::Vec<crate::model::SipAddress>>,
}
impl UpdateContactInput {
pub fn contact_arn(&self) -> std::option::Option<&str> {
self.contact_arn.as_deref()
}
pub fn display_name(&self) -> std::option::Option<&str> {
self.display_name.as_deref()
}
pub fn first_name(&self) -> std::option::Option<&str> {
self.first_name.as_deref()
}
pub fn last_name(&self) -> std::option::Option<&str> {
self.last_name.as_deref()
}
pub fn phone_number(&self) -> std::option::Option<&str> {
self.phone_number.as_deref()
}
pub fn phone_numbers(&self) -> std::option::Option<&[crate::model::PhoneNumber]> {
self.phone_numbers.as_deref()
}
pub fn sip_addresses(&self) -> std::option::Option<&[crate::model::SipAddress]> {
self.sip_addresses.as_deref()
}
}
impl std::fmt::Debug for UpdateContactInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UpdateContactInput");
formatter.field("contact_arn", &self.contact_arn);
formatter.field("display_name", &self.display_name);
formatter.field("first_name", &self.first_name);
formatter.field("last_name", &self.last_name);
formatter.field("phone_number", &"*** Sensitive Data Redacted ***");
formatter.field("phone_numbers", &self.phone_numbers);
formatter.field("sip_addresses", &self.sip_addresses);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateConferenceProviderInput {
pub conference_provider_arn: std::option::Option<std::string::String>,
pub conference_provider_type: std::option::Option<crate::model::ConferenceProviderType>,
pub ip_dial_in: std::option::Option<crate::model::IpDialIn>,
pub pstn_dial_in: std::option::Option<crate::model::PstnDialIn>,
pub meeting_setting: std::option::Option<crate::model::MeetingSetting>,
}
impl UpdateConferenceProviderInput {
pub fn conference_provider_arn(&self) -> std::option::Option<&str> {
self.conference_provider_arn.as_deref()
}
pub fn conference_provider_type(
&self,
) -> std::option::Option<&crate::model::ConferenceProviderType> {
self.conference_provider_type.as_ref()
}
pub fn ip_dial_in(&self) -> std::option::Option<&crate::model::IpDialIn> {
self.ip_dial_in.as_ref()
}
pub fn pstn_dial_in(&self) -> std::option::Option<&crate::model::PstnDialIn> {
self.pstn_dial_in.as_ref()
}
pub fn meeting_setting(&self) -> std::option::Option<&crate::model::MeetingSetting> {
self.meeting_setting.as_ref()
}
}
impl std::fmt::Debug for UpdateConferenceProviderInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UpdateConferenceProviderInput");
formatter.field("conference_provider_arn", &self.conference_provider_arn);
formatter.field("conference_provider_type", &self.conference_provider_type);
formatter.field("ip_dial_in", &self.ip_dial_in);
formatter.field("pstn_dial_in", &self.pstn_dial_in);
formatter.field("meeting_setting", &self.meeting_setting);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateBusinessReportScheduleInput {
pub schedule_arn: std::option::Option<std::string::String>,
pub s3_bucket_name: std::option::Option<std::string::String>,
pub s3_key_prefix: std::option::Option<std::string::String>,
pub format: std::option::Option<crate::model::BusinessReportFormat>,
pub schedule_name: std::option::Option<std::string::String>,
pub recurrence: std::option::Option<crate::model::BusinessReportRecurrence>,
}
impl UpdateBusinessReportScheduleInput {
pub fn schedule_arn(&self) -> std::option::Option<&str> {
self.schedule_arn.as_deref()
}
pub fn s3_bucket_name(&self) -> std::option::Option<&str> {
self.s3_bucket_name.as_deref()
}
pub fn s3_key_prefix(&self) -> std::option::Option<&str> {
self.s3_key_prefix.as_deref()
}
pub fn format(&self) -> std::option::Option<&crate::model::BusinessReportFormat> {
self.format.as_ref()
}
pub fn schedule_name(&self) -> std::option::Option<&str> {
self.schedule_name.as_deref()
}
pub fn recurrence(&self) -> std::option::Option<&crate::model::BusinessReportRecurrence> {
self.recurrence.as_ref()
}
}
impl std::fmt::Debug for UpdateBusinessReportScheduleInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UpdateBusinessReportScheduleInput");
formatter.field("schedule_arn", &self.schedule_arn);
formatter.field("s3_bucket_name", &self.s3_bucket_name);
formatter.field("s3_key_prefix", &self.s3_key_prefix);
formatter.field("format", &self.format);
formatter.field("schedule_name", &self.schedule_name);
formatter.field("recurrence", &self.recurrence);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateAddressBookInput {
pub address_book_arn: std::option::Option<std::string::String>,
pub name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
}
impl UpdateAddressBookInput {
pub fn address_book_arn(&self) -> std::option::Option<&str> {
self.address_book_arn.as_deref()
}
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
}
impl std::fmt::Debug for UpdateAddressBookInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UpdateAddressBookInput");
formatter.field("address_book_arn", &self.address_book_arn);
formatter.field("name", &self.name);
formatter.field("description", &self.description);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UntagResourceInput {
pub arn: std::option::Option<std::string::String>,
pub tag_keys: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl UntagResourceInput {
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
pub fn tag_keys(&self) -> std::option::Option<&[std::string::String]> {
self.tag_keys.as_deref()
}
}
impl std::fmt::Debug for UntagResourceInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UntagResourceInput");
formatter.field("arn", &self.arn);
formatter.field("tag_keys", &self.tag_keys);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct TagResourceInput {
pub arn: std::option::Option<std::string::String>,
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl TagResourceInput {
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
impl std::fmt::Debug for TagResourceInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("TagResourceInput");
formatter.field("arn", &self.arn);
formatter.field("tags", &self.tags);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct StartSmartHomeApplianceDiscoveryInput {
pub room_arn: std::option::Option<std::string::String>,
}
impl StartSmartHomeApplianceDiscoveryInput {
pub fn room_arn(&self) -> std::option::Option<&str> {
self.room_arn.as_deref()
}
}
impl std::fmt::Debug for StartSmartHomeApplianceDiscoveryInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("StartSmartHomeApplianceDiscoveryInput");
formatter.field("room_arn", &self.room_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct StartDeviceSyncInput {
pub room_arn: std::option::Option<std::string::String>,
pub device_arn: std::option::Option<std::string::String>,
pub features: std::option::Option<std::vec::Vec<crate::model::Feature>>,
}
impl StartDeviceSyncInput {
pub fn room_arn(&self) -> std::option::Option<&str> {
self.room_arn.as_deref()
}
pub fn device_arn(&self) -> std::option::Option<&str> {
self.device_arn.as_deref()
}
pub fn features(&self) -> std::option::Option<&[crate::model::Feature]> {
self.features.as_deref()
}
}
impl std::fmt::Debug for StartDeviceSyncInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("StartDeviceSyncInput");
formatter.field("room_arn", &self.room_arn);
formatter.field("device_arn", &self.device_arn);
formatter.field("features", &self.features);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SendInvitationInput {
pub user_arn: std::option::Option<std::string::String>,
}
impl SendInvitationInput {
pub fn user_arn(&self) -> std::option::Option<&str> {
self.user_arn.as_deref()
}
}
impl std::fmt::Debug for SendInvitationInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SendInvitationInput");
formatter.field("user_arn", &self.user_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SendAnnouncementInput {
pub room_filters: std::option::Option<std::vec::Vec<crate::model::Filter>>,
pub content: std::option::Option<crate::model::Content>,
pub time_to_live_in_seconds: std::option::Option<i32>,
pub client_request_token: std::option::Option<std::string::String>,
}
impl SendAnnouncementInput {
pub fn room_filters(&self) -> std::option::Option<&[crate::model::Filter]> {
self.room_filters.as_deref()
}
pub fn content(&self) -> std::option::Option<&crate::model::Content> {
self.content.as_ref()
}
pub fn time_to_live_in_seconds(&self) -> std::option::Option<i32> {
self.time_to_live_in_seconds
}
pub fn client_request_token(&self) -> std::option::Option<&str> {
self.client_request_token.as_deref()
}
}
impl std::fmt::Debug for SendAnnouncementInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SendAnnouncementInput");
formatter.field("room_filters", &self.room_filters);
formatter.field("content", &self.content);
formatter.field("time_to_live_in_seconds", &self.time_to_live_in_seconds);
formatter.field("client_request_token", &self.client_request_token);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SearchUsersInput {
pub next_token: std::option::Option<std::string::String>,
pub max_results: std::option::Option<i32>,
pub filters: std::option::Option<std::vec::Vec<crate::model::Filter>>,
pub sort_criteria: std::option::Option<std::vec::Vec<crate::model::Sort>>,
}
impl SearchUsersInput {
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
pub fn filters(&self) -> std::option::Option<&[crate::model::Filter]> {
self.filters.as_deref()
}
pub fn sort_criteria(&self) -> std::option::Option<&[crate::model::Sort]> {
self.sort_criteria.as_deref()
}
}
impl std::fmt::Debug for SearchUsersInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SearchUsersInput");
formatter.field("next_token", &self.next_token);
formatter.field("max_results", &self.max_results);
formatter.field("filters", &self.filters);
formatter.field("sort_criteria", &self.sort_criteria);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SearchSkillGroupsInput {
pub next_token: std::option::Option<std::string::String>,
pub max_results: std::option::Option<i32>,
pub filters: std::option::Option<std::vec::Vec<crate::model::Filter>>,
pub sort_criteria: std::option::Option<std::vec::Vec<crate::model::Sort>>,
}
impl SearchSkillGroupsInput {
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
pub fn filters(&self) -> std::option::Option<&[crate::model::Filter]> {
self.filters.as_deref()
}
pub fn sort_criteria(&self) -> std::option::Option<&[crate::model::Sort]> {
self.sort_criteria.as_deref()
}
}
impl std::fmt::Debug for SearchSkillGroupsInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SearchSkillGroupsInput");
formatter.field("next_token", &self.next_token);
formatter.field("max_results", &self.max_results);
formatter.field("filters", &self.filters);
formatter.field("sort_criteria", &self.sort_criteria);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SearchRoomsInput {
pub next_token: std::option::Option<std::string::String>,
pub max_results: std::option::Option<i32>,
pub filters: std::option::Option<std::vec::Vec<crate::model::Filter>>,
pub sort_criteria: std::option::Option<std::vec::Vec<crate::model::Sort>>,
}
impl SearchRoomsInput {
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
pub fn filters(&self) -> std::option::Option<&[crate::model::Filter]> {
self.filters.as_deref()
}
pub fn sort_criteria(&self) -> std::option::Option<&[crate::model::Sort]> {
self.sort_criteria.as_deref()
}
}
impl std::fmt::Debug for SearchRoomsInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SearchRoomsInput");
formatter.field("next_token", &self.next_token);
formatter.field("max_results", &self.max_results);
formatter.field("filters", &self.filters);
formatter.field("sort_criteria", &self.sort_criteria);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SearchProfilesInput {
pub next_token: std::option::Option<std::string::String>,
pub max_results: std::option::Option<i32>,
pub filters: std::option::Option<std::vec::Vec<crate::model::Filter>>,
pub sort_criteria: std::option::Option<std::vec::Vec<crate::model::Sort>>,
}
impl SearchProfilesInput {
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
pub fn filters(&self) -> std::option::Option<&[crate::model::Filter]> {
self.filters.as_deref()
}
pub fn sort_criteria(&self) -> std::option::Option<&[crate::model::Sort]> {
self.sort_criteria.as_deref()
}
}
impl std::fmt::Debug for SearchProfilesInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SearchProfilesInput");
formatter.field("next_token", &self.next_token);
formatter.field("max_results", &self.max_results);
formatter.field("filters", &self.filters);
formatter.field("sort_criteria", &self.sort_criteria);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SearchNetworkProfilesInput {
pub next_token: std::option::Option<std::string::String>,
pub max_results: std::option::Option<i32>,
pub filters: std::option::Option<std::vec::Vec<crate::model::Filter>>,
pub sort_criteria: std::option::Option<std::vec::Vec<crate::model::Sort>>,
}
impl SearchNetworkProfilesInput {
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
pub fn filters(&self) -> std::option::Option<&[crate::model::Filter]> {
self.filters.as_deref()
}
pub fn sort_criteria(&self) -> std::option::Option<&[crate::model::Sort]> {
self.sort_criteria.as_deref()
}
}
impl std::fmt::Debug for SearchNetworkProfilesInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SearchNetworkProfilesInput");
formatter.field("next_token", &self.next_token);
formatter.field("max_results", &self.max_results);
formatter.field("filters", &self.filters);
formatter.field("sort_criteria", &self.sort_criteria);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SearchDevicesInput {
pub next_token: std::option::Option<std::string::String>,
pub max_results: std::option::Option<i32>,
pub filters: std::option::Option<std::vec::Vec<crate::model::Filter>>,
pub sort_criteria: std::option::Option<std::vec::Vec<crate::model::Sort>>,
}
impl SearchDevicesInput {
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
pub fn filters(&self) -> std::option::Option<&[crate::model::Filter]> {
self.filters.as_deref()
}
pub fn sort_criteria(&self) -> std::option::Option<&[crate::model::Sort]> {
self.sort_criteria.as_deref()
}
}
impl std::fmt::Debug for SearchDevicesInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SearchDevicesInput");
formatter.field("next_token", &self.next_token);
formatter.field("max_results", &self.max_results);
formatter.field("filters", &self.filters);
formatter.field("sort_criteria", &self.sort_criteria);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SearchContactsInput {
pub filters: std::option::Option<std::vec::Vec<crate::model::Filter>>,
pub sort_criteria: std::option::Option<std::vec::Vec<crate::model::Sort>>,
pub next_token: std::option::Option<std::string::String>,
pub max_results: std::option::Option<i32>,
}
impl SearchContactsInput {
pub fn filters(&self) -> std::option::Option<&[crate::model::Filter]> {
self.filters.as_deref()
}
pub fn sort_criteria(&self) -> std::option::Option<&[crate::model::Sort]> {
self.sort_criteria.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
impl std::fmt::Debug for SearchContactsInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SearchContactsInput");
formatter.field("filters", &self.filters);
formatter.field("sort_criteria", &self.sort_criteria);
formatter.field("next_token", &self.next_token);
formatter.field("max_results", &self.max_results);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SearchAddressBooksInput {
pub filters: std::option::Option<std::vec::Vec<crate::model::Filter>>,
pub sort_criteria: std::option::Option<std::vec::Vec<crate::model::Sort>>,
pub next_token: std::option::Option<std::string::String>,
pub max_results: std::option::Option<i32>,
}
impl SearchAddressBooksInput {
pub fn filters(&self) -> std::option::Option<&[crate::model::Filter]> {
self.filters.as_deref()
}
pub fn sort_criteria(&self) -> std::option::Option<&[crate::model::Sort]> {
self.sort_criteria.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
impl std::fmt::Debug for SearchAddressBooksInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("SearchAddressBooksInput");
formatter.field("filters", &self.filters);
formatter.field("sort_criteria", &self.sort_criteria);
formatter.field("next_token", &self.next_token);
formatter.field("max_results", &self.max_results);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct RevokeInvitationInput {
pub user_arn: std::option::Option<std::string::String>,
pub enrollment_id: std::option::Option<std::string::String>,
}
impl RevokeInvitationInput {
pub fn user_arn(&self) -> std::option::Option<&str> {
self.user_arn.as_deref()
}
pub fn enrollment_id(&self) -> std::option::Option<&str> {
self.enrollment_id.as_deref()
}
}
impl std::fmt::Debug for RevokeInvitationInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("RevokeInvitationInput");
formatter.field("user_arn", &self.user_arn);
formatter.field("enrollment_id", &self.enrollment_id);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ResolveRoomInput {
pub user_id: std::option::Option<std::string::String>,
pub skill_id: std::option::Option<std::string::String>,
}
impl ResolveRoomInput {
pub fn user_id(&self) -> std::option::Option<&str> {
self.user_id.as_deref()
}
pub fn skill_id(&self) -> std::option::Option<&str> {
self.skill_id.as_deref()
}
}
impl std::fmt::Debug for ResolveRoomInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ResolveRoomInput");
formatter.field("user_id", &self.user_id);
formatter.field("skill_id", &self.skill_id);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct RejectSkillInput {
pub skill_id: std::option::Option<std::string::String>,
}
impl RejectSkillInput {
pub fn skill_id(&self) -> std::option::Option<&str> {
self.skill_id.as_deref()
}
}
impl std::fmt::Debug for RejectSkillInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("RejectSkillInput");
formatter.field("skill_id", &self.skill_id);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct RegisterAvsDeviceInput {
pub client_id: std::option::Option<std::string::String>,
pub user_code: std::option::Option<std::string::String>,
pub product_id: std::option::Option<std::string::String>,
pub device_serial_number: std::option::Option<std::string::String>,
pub amazon_id: std::option::Option<std::string::String>,
pub room_arn: std::option::Option<std::string::String>,
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl RegisterAvsDeviceInput {
pub fn client_id(&self) -> std::option::Option<&str> {
self.client_id.as_deref()
}
pub fn user_code(&self) -> std::option::Option<&str> {
self.user_code.as_deref()
}
pub fn product_id(&self) -> std::option::Option<&str> {
self.product_id.as_deref()
}
pub fn device_serial_number(&self) -> std::option::Option<&str> {
self.device_serial_number.as_deref()
}
pub fn amazon_id(&self) -> std::option::Option<&str> {
self.amazon_id.as_deref()
}
pub fn room_arn(&self) -> std::option::Option<&str> {
self.room_arn.as_deref()
}
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
impl std::fmt::Debug for RegisterAvsDeviceInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("RegisterAvsDeviceInput");
formatter.field("client_id", &self.client_id);
formatter.field("user_code", &self.user_code);
formatter.field("product_id", &self.product_id);
formatter.field("device_serial_number", &self.device_serial_number);
formatter.field("amazon_id", &self.amazon_id);
formatter.field("room_arn", &self.room_arn);
formatter.field("tags", &self.tags);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutSkillAuthorizationInput {
pub authorization_result:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
pub skill_id: std::option::Option<std::string::String>,
pub room_arn: std::option::Option<std::string::String>,
}
impl PutSkillAuthorizationInput {
pub fn authorization_result(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.authorization_result.as_ref()
}
pub fn skill_id(&self) -> std::option::Option<&str> {
self.skill_id.as_deref()
}
pub fn room_arn(&self) -> std::option::Option<&str> {
self.room_arn.as_deref()
}
}
impl std::fmt::Debug for PutSkillAuthorizationInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("PutSkillAuthorizationInput");
formatter.field("authorization_result", &"*** Sensitive Data Redacted ***");
formatter.field("skill_id", &self.skill_id);
formatter.field("room_arn", &self.room_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutRoomSkillParameterInput {
pub room_arn: std::option::Option<std::string::String>,
pub skill_id: std::option::Option<std::string::String>,
pub room_skill_parameter: std::option::Option<crate::model::RoomSkillParameter>,
}
impl PutRoomSkillParameterInput {
pub fn room_arn(&self) -> std::option::Option<&str> {
self.room_arn.as_deref()
}
pub fn skill_id(&self) -> std::option::Option<&str> {
self.skill_id.as_deref()
}
pub fn room_skill_parameter(&self) -> std::option::Option<&crate::model::RoomSkillParameter> {
self.room_skill_parameter.as_ref()
}
}
impl std::fmt::Debug for PutRoomSkillParameterInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("PutRoomSkillParameterInput");
formatter.field("room_arn", &self.room_arn);
formatter.field("skill_id", &self.skill_id);
formatter.field("room_skill_parameter", &self.room_skill_parameter);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutInvitationConfigurationInput {
pub organization_name: std::option::Option<std::string::String>,
pub contact_email: std::option::Option<std::string::String>,
pub private_skill_ids: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl PutInvitationConfigurationInput {
pub fn organization_name(&self) -> std::option::Option<&str> {
self.organization_name.as_deref()
}
pub fn contact_email(&self) -> std::option::Option<&str> {
self.contact_email.as_deref()
}
pub fn private_skill_ids(&self) -> std::option::Option<&[std::string::String]> {
self.private_skill_ids.as_deref()
}
}
impl std::fmt::Debug for PutInvitationConfigurationInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("PutInvitationConfigurationInput");
formatter.field("organization_name", &self.organization_name);
formatter.field("contact_email", &self.contact_email);
formatter.field("private_skill_ids", &self.private_skill_ids);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutConferencePreferenceInput {
pub conference_preference: std::option::Option<crate::model::ConferencePreference>,
}
impl PutConferencePreferenceInput {
pub fn conference_preference(
&self,
) -> std::option::Option<&crate::model::ConferencePreference> {
self.conference_preference.as_ref()
}
}
impl std::fmt::Debug for PutConferencePreferenceInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("PutConferencePreferenceInput");
formatter.field("conference_preference", &self.conference_preference);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTagsInput {
pub arn: std::option::Option<std::string::String>,
pub next_token: std::option::Option<std::string::String>,
pub max_results: std::option::Option<i32>,
}
impl ListTagsInput {
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
impl std::fmt::Debug for ListTagsInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ListTagsInput");
formatter.field("arn", &self.arn);
formatter.field("next_token", &self.next_token);
formatter.field("max_results", &self.max_results);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListSmartHomeAppliancesInput {
pub room_arn: std::option::Option<std::string::String>,
pub max_results: std::option::Option<i32>,
pub next_token: std::option::Option<std::string::String>,
}
impl ListSmartHomeAppliancesInput {
pub fn room_arn(&self) -> std::option::Option<&str> {
self.room_arn.as_deref()
}
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
impl std::fmt::Debug for ListSmartHomeAppliancesInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ListSmartHomeAppliancesInput");
formatter.field("room_arn", &self.room_arn);
formatter.field("max_results", &self.max_results);
formatter.field("next_token", &self.next_token);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListSkillsStoreSkillsByCategoryInput {
pub category_id: std::option::Option<i64>,
pub next_token: std::option::Option<std::string::String>,
pub max_results: std::option::Option<i32>,
}
impl ListSkillsStoreSkillsByCategoryInput {
pub fn category_id(&self) -> std::option::Option<i64> {
self.category_id
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
impl std::fmt::Debug for ListSkillsStoreSkillsByCategoryInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ListSkillsStoreSkillsByCategoryInput");
formatter.field("category_id", &self.category_id);
formatter.field("next_token", &self.next_token);
formatter.field("max_results", &self.max_results);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListSkillsStoreCategoriesInput {
pub next_token: std::option::Option<std::string::String>,
pub max_results: std::option::Option<i32>,
}
impl ListSkillsStoreCategoriesInput {
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
impl std::fmt::Debug for ListSkillsStoreCategoriesInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ListSkillsStoreCategoriesInput");
formatter.field("next_token", &self.next_token);
formatter.field("max_results", &self.max_results);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListSkillsInput {
pub skill_group_arn: std::option::Option<std::string::String>,
pub enablement_type: std::option::Option<crate::model::EnablementTypeFilter>,
pub skill_type: std::option::Option<crate::model::SkillTypeFilter>,
pub next_token: std::option::Option<std::string::String>,
pub max_results: std::option::Option<i32>,
}
impl ListSkillsInput {
pub fn skill_group_arn(&self) -> std::option::Option<&str> {
self.skill_group_arn.as_deref()
}
pub fn enablement_type(&self) -> std::option::Option<&crate::model::EnablementTypeFilter> {
self.enablement_type.as_ref()
}
pub fn skill_type(&self) -> std::option::Option<&crate::model::SkillTypeFilter> {
self.skill_type.as_ref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
impl std::fmt::Debug for ListSkillsInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ListSkillsInput");
formatter.field("skill_group_arn", &self.skill_group_arn);
formatter.field("enablement_type", &self.enablement_type);
formatter.field("skill_type", &self.skill_type);
formatter.field("next_token", &self.next_token);
formatter.field("max_results", &self.max_results);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListGatewaysInput {
pub gateway_group_arn: std::option::Option<std::string::String>,
pub next_token: std::option::Option<std::string::String>,
pub max_results: std::option::Option<i32>,
}
impl ListGatewaysInput {
pub fn gateway_group_arn(&self) -> std::option::Option<&str> {
self.gateway_group_arn.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
impl std::fmt::Debug for ListGatewaysInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ListGatewaysInput");
formatter.field("gateway_group_arn", &self.gateway_group_arn);
formatter.field("next_token", &self.next_token);
formatter.field("max_results", &self.max_results);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListGatewayGroupsInput {
pub next_token: std::option::Option<std::string::String>,
pub max_results: std::option::Option<i32>,
}
impl ListGatewayGroupsInput {
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
impl std::fmt::Debug for ListGatewayGroupsInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ListGatewayGroupsInput");
formatter.field("next_token", &self.next_token);
formatter.field("max_results", &self.max_results);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListDeviceEventsInput {
pub device_arn: std::option::Option<std::string::String>,
pub event_type: std::option::Option<crate::model::DeviceEventType>,
pub next_token: std::option::Option<std::string::String>,
pub max_results: std::option::Option<i32>,
}
impl ListDeviceEventsInput {
pub fn device_arn(&self) -> std::option::Option<&str> {
self.device_arn.as_deref()
}
pub fn event_type(&self) -> std::option::Option<&crate::model::DeviceEventType> {
self.event_type.as_ref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
impl std::fmt::Debug for ListDeviceEventsInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ListDeviceEventsInput");
formatter.field("device_arn", &self.device_arn);
formatter.field("event_type", &self.event_type);
formatter.field("next_token", &self.next_token);
formatter.field("max_results", &self.max_results);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListConferenceProvidersInput {
pub next_token: std::option::Option<std::string::String>,
pub max_results: std::option::Option<i32>,
}
impl ListConferenceProvidersInput {
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
impl std::fmt::Debug for ListConferenceProvidersInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ListConferenceProvidersInput");
formatter.field("next_token", &self.next_token);
formatter.field("max_results", &self.max_results);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListBusinessReportSchedulesInput {
pub next_token: std::option::Option<std::string::String>,
pub max_results: std::option::Option<i32>,
}
impl ListBusinessReportSchedulesInput {
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
impl std::fmt::Debug for ListBusinessReportSchedulesInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ListBusinessReportSchedulesInput");
formatter.field("next_token", &self.next_token);
formatter.field("max_results", &self.max_results);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetSkillGroupInput {
pub skill_group_arn: std::option::Option<std::string::String>,
}
impl GetSkillGroupInput {
pub fn skill_group_arn(&self) -> std::option::Option<&str> {
self.skill_group_arn.as_deref()
}
}
impl std::fmt::Debug for GetSkillGroupInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("GetSkillGroupInput");
formatter.field("skill_group_arn", &self.skill_group_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetRoomSkillParameterInput {
pub room_arn: std::option::Option<std::string::String>,
pub skill_id: std::option::Option<std::string::String>,
pub parameter_key: std::option::Option<std::string::String>,
}
impl GetRoomSkillParameterInput {
pub fn room_arn(&self) -> std::option::Option<&str> {
self.room_arn.as_deref()
}
pub fn skill_id(&self) -> std::option::Option<&str> {
self.skill_id.as_deref()
}
pub fn parameter_key(&self) -> std::option::Option<&str> {
self.parameter_key.as_deref()
}
}
impl std::fmt::Debug for GetRoomSkillParameterInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("GetRoomSkillParameterInput");
formatter.field("room_arn", &self.room_arn);
formatter.field("skill_id", &self.skill_id);
formatter.field("parameter_key", &self.parameter_key);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetRoomInput {
pub room_arn: std::option::Option<std::string::String>,
}
impl GetRoomInput {
pub fn room_arn(&self) -> std::option::Option<&str> {
self.room_arn.as_deref()
}
}
impl std::fmt::Debug for GetRoomInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("GetRoomInput");
formatter.field("room_arn", &self.room_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetProfileInput {
pub profile_arn: std::option::Option<std::string::String>,
}
impl GetProfileInput {
pub fn profile_arn(&self) -> std::option::Option<&str> {
self.profile_arn.as_deref()
}
}
impl std::fmt::Debug for GetProfileInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("GetProfileInput");
formatter.field("profile_arn", &self.profile_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetNetworkProfileInput {
pub network_profile_arn: std::option::Option<std::string::String>,
}
impl GetNetworkProfileInput {
pub fn network_profile_arn(&self) -> std::option::Option<&str> {
self.network_profile_arn.as_deref()
}
}
impl std::fmt::Debug for GetNetworkProfileInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("GetNetworkProfileInput");
formatter.field("network_profile_arn", &self.network_profile_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetInvitationConfigurationInput {}
impl std::fmt::Debug for GetInvitationConfigurationInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("GetInvitationConfigurationInput");
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetGatewayGroupInput {
pub gateway_group_arn: std::option::Option<std::string::String>,
}
impl GetGatewayGroupInput {
pub fn gateway_group_arn(&self) -> std::option::Option<&str> {
self.gateway_group_arn.as_deref()
}
}
impl std::fmt::Debug for GetGatewayGroupInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("GetGatewayGroupInput");
formatter.field("gateway_group_arn", &self.gateway_group_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetGatewayInput {
pub gateway_arn: std::option::Option<std::string::String>,
}
impl GetGatewayInput {
pub fn gateway_arn(&self) -> std::option::Option<&str> {
self.gateway_arn.as_deref()
}
}
impl std::fmt::Debug for GetGatewayInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("GetGatewayInput");
formatter.field("gateway_arn", &self.gateway_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetDeviceInput {
pub device_arn: std::option::Option<std::string::String>,
}
impl GetDeviceInput {
pub fn device_arn(&self) -> std::option::Option<&str> {
self.device_arn.as_deref()
}
}
impl std::fmt::Debug for GetDeviceInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("GetDeviceInput");
formatter.field("device_arn", &self.device_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetContactInput {
pub contact_arn: std::option::Option<std::string::String>,
}
impl GetContactInput {
pub fn contact_arn(&self) -> std::option::Option<&str> {
self.contact_arn.as_deref()
}
}
impl std::fmt::Debug for GetContactInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("GetContactInput");
formatter.field("contact_arn", &self.contact_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetConferenceProviderInput {
pub conference_provider_arn: std::option::Option<std::string::String>,
}
impl GetConferenceProviderInput {
pub fn conference_provider_arn(&self) -> std::option::Option<&str> {
self.conference_provider_arn.as_deref()
}
}
impl std::fmt::Debug for GetConferenceProviderInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("GetConferenceProviderInput");
formatter.field("conference_provider_arn", &self.conference_provider_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetConferencePreferenceInput {}
impl std::fmt::Debug for GetConferencePreferenceInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("GetConferencePreferenceInput");
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetAddressBookInput {
pub address_book_arn: std::option::Option<std::string::String>,
}
impl GetAddressBookInput {
pub fn address_book_arn(&self) -> std::option::Option<&str> {
self.address_book_arn.as_deref()
}
}
impl std::fmt::Debug for GetAddressBookInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("GetAddressBookInput");
formatter.field("address_book_arn", &self.address_book_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ForgetSmartHomeAppliancesInput {
pub room_arn: std::option::Option<std::string::String>,
}
impl ForgetSmartHomeAppliancesInput {
pub fn room_arn(&self) -> std::option::Option<&str> {
self.room_arn.as_deref()
}
}
impl std::fmt::Debug for ForgetSmartHomeAppliancesInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ForgetSmartHomeAppliancesInput");
formatter.field("room_arn", &self.room_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DisassociateSkillGroupFromRoomInput {
pub skill_group_arn: std::option::Option<std::string::String>,
pub room_arn: std::option::Option<std::string::String>,
}
impl DisassociateSkillGroupFromRoomInput {
pub fn skill_group_arn(&self) -> std::option::Option<&str> {
self.skill_group_arn.as_deref()
}
pub fn room_arn(&self) -> std::option::Option<&str> {
self.room_arn.as_deref()
}
}
impl std::fmt::Debug for DisassociateSkillGroupFromRoomInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DisassociateSkillGroupFromRoomInput");
formatter.field("skill_group_arn", &self.skill_group_arn);
formatter.field("room_arn", &self.room_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DisassociateSkillFromUsersInput {
pub skill_id: std::option::Option<std::string::String>,
}
impl DisassociateSkillFromUsersInput {
pub fn skill_id(&self) -> std::option::Option<&str> {
self.skill_id.as_deref()
}
}
impl std::fmt::Debug for DisassociateSkillFromUsersInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DisassociateSkillFromUsersInput");
formatter.field("skill_id", &self.skill_id);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DisassociateSkillFromSkillGroupInput {
pub skill_group_arn: std::option::Option<std::string::String>,
pub skill_id: std::option::Option<std::string::String>,
}
impl DisassociateSkillFromSkillGroupInput {
pub fn skill_group_arn(&self) -> std::option::Option<&str> {
self.skill_group_arn.as_deref()
}
pub fn skill_id(&self) -> std::option::Option<&str> {
self.skill_id.as_deref()
}
}
impl std::fmt::Debug for DisassociateSkillFromSkillGroupInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DisassociateSkillFromSkillGroupInput");
formatter.field("skill_group_arn", &self.skill_group_arn);
formatter.field("skill_id", &self.skill_id);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DisassociateDeviceFromRoomInput {
pub device_arn: std::option::Option<std::string::String>,
}
impl DisassociateDeviceFromRoomInput {
pub fn device_arn(&self) -> std::option::Option<&str> {
self.device_arn.as_deref()
}
}
impl std::fmt::Debug for DisassociateDeviceFromRoomInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DisassociateDeviceFromRoomInput");
formatter.field("device_arn", &self.device_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DisassociateContactFromAddressBookInput {
pub contact_arn: std::option::Option<std::string::String>,
pub address_book_arn: std::option::Option<std::string::String>,
}
impl DisassociateContactFromAddressBookInput {
pub fn contact_arn(&self) -> std::option::Option<&str> {
self.contact_arn.as_deref()
}
pub fn address_book_arn(&self) -> std::option::Option<&str> {
self.address_book_arn.as_deref()
}
}
impl std::fmt::Debug for DisassociateContactFromAddressBookInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DisassociateContactFromAddressBookInput");
formatter.field("contact_arn", &self.contact_arn);
formatter.field("address_book_arn", &self.address_book_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteUserInput {
pub user_arn: std::option::Option<std::string::String>,
pub enrollment_id: std::option::Option<std::string::String>,
}
impl DeleteUserInput {
pub fn user_arn(&self) -> std::option::Option<&str> {
self.user_arn.as_deref()
}
pub fn enrollment_id(&self) -> std::option::Option<&str> {
self.enrollment_id.as_deref()
}
}
impl std::fmt::Debug for DeleteUserInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeleteUserInput");
formatter.field("user_arn", &self.user_arn);
formatter.field("enrollment_id", &self.enrollment_id);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteSkillGroupInput {
pub skill_group_arn: std::option::Option<std::string::String>,
}
impl DeleteSkillGroupInput {
pub fn skill_group_arn(&self) -> std::option::Option<&str> {
self.skill_group_arn.as_deref()
}
}
impl std::fmt::Debug for DeleteSkillGroupInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeleteSkillGroupInput");
formatter.field("skill_group_arn", &self.skill_group_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteSkillAuthorizationInput {
pub skill_id: std::option::Option<std::string::String>,
pub room_arn: std::option::Option<std::string::String>,
}
impl DeleteSkillAuthorizationInput {
pub fn skill_id(&self) -> std::option::Option<&str> {
self.skill_id.as_deref()
}
pub fn room_arn(&self) -> std::option::Option<&str> {
self.room_arn.as_deref()
}
}
impl std::fmt::Debug for DeleteSkillAuthorizationInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeleteSkillAuthorizationInput");
formatter.field("skill_id", &self.skill_id);
formatter.field("room_arn", &self.room_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteRoomSkillParameterInput {
pub room_arn: std::option::Option<std::string::String>,
pub skill_id: std::option::Option<std::string::String>,
pub parameter_key: std::option::Option<std::string::String>,
}
impl DeleteRoomSkillParameterInput {
pub fn room_arn(&self) -> std::option::Option<&str> {
self.room_arn.as_deref()
}
pub fn skill_id(&self) -> std::option::Option<&str> {
self.skill_id.as_deref()
}
pub fn parameter_key(&self) -> std::option::Option<&str> {
self.parameter_key.as_deref()
}
}
impl std::fmt::Debug for DeleteRoomSkillParameterInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeleteRoomSkillParameterInput");
formatter.field("room_arn", &self.room_arn);
formatter.field("skill_id", &self.skill_id);
formatter.field("parameter_key", &self.parameter_key);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteRoomInput {
pub room_arn: std::option::Option<std::string::String>,
}
impl DeleteRoomInput {
pub fn room_arn(&self) -> std::option::Option<&str> {
self.room_arn.as_deref()
}
}
impl std::fmt::Debug for DeleteRoomInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeleteRoomInput");
formatter.field("room_arn", &self.room_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteProfileInput {
pub profile_arn: std::option::Option<std::string::String>,
}
impl DeleteProfileInput {
pub fn profile_arn(&self) -> std::option::Option<&str> {
self.profile_arn.as_deref()
}
}
impl std::fmt::Debug for DeleteProfileInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeleteProfileInput");
formatter.field("profile_arn", &self.profile_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteNetworkProfileInput {
pub network_profile_arn: std::option::Option<std::string::String>,
}
impl DeleteNetworkProfileInput {
pub fn network_profile_arn(&self) -> std::option::Option<&str> {
self.network_profile_arn.as_deref()
}
}
impl std::fmt::Debug for DeleteNetworkProfileInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeleteNetworkProfileInput");
formatter.field("network_profile_arn", &self.network_profile_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteGatewayGroupInput {
pub gateway_group_arn: std::option::Option<std::string::String>,
}
impl DeleteGatewayGroupInput {
pub fn gateway_group_arn(&self) -> std::option::Option<&str> {
self.gateway_group_arn.as_deref()
}
}
impl std::fmt::Debug for DeleteGatewayGroupInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeleteGatewayGroupInput");
formatter.field("gateway_group_arn", &self.gateway_group_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteDeviceUsageDataInput {
pub device_arn: std::option::Option<std::string::String>,
pub device_usage_type: std::option::Option<crate::model::DeviceUsageType>,
}
impl DeleteDeviceUsageDataInput {
pub fn device_arn(&self) -> std::option::Option<&str> {
self.device_arn.as_deref()
}
pub fn device_usage_type(&self) -> std::option::Option<&crate::model::DeviceUsageType> {
self.device_usage_type.as_ref()
}
}
impl std::fmt::Debug for DeleteDeviceUsageDataInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeleteDeviceUsageDataInput");
formatter.field("device_arn", &self.device_arn);
formatter.field("device_usage_type", &self.device_usage_type);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteDeviceInput {
pub device_arn: std::option::Option<std::string::String>,
}
impl DeleteDeviceInput {
pub fn device_arn(&self) -> std::option::Option<&str> {
self.device_arn.as_deref()
}
}
impl std::fmt::Debug for DeleteDeviceInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeleteDeviceInput");
formatter.field("device_arn", &self.device_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteContactInput {
pub contact_arn: std::option::Option<std::string::String>,
}
impl DeleteContactInput {
pub fn contact_arn(&self) -> std::option::Option<&str> {
self.contact_arn.as_deref()
}
}
impl std::fmt::Debug for DeleteContactInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeleteContactInput");
formatter.field("contact_arn", &self.contact_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteConferenceProviderInput {
pub conference_provider_arn: std::option::Option<std::string::String>,
}
impl DeleteConferenceProviderInput {
pub fn conference_provider_arn(&self) -> std::option::Option<&str> {
self.conference_provider_arn.as_deref()
}
}
impl std::fmt::Debug for DeleteConferenceProviderInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeleteConferenceProviderInput");
formatter.field("conference_provider_arn", &self.conference_provider_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteBusinessReportScheduleInput {
pub schedule_arn: std::option::Option<std::string::String>,
}
impl DeleteBusinessReportScheduleInput {
pub fn schedule_arn(&self) -> std::option::Option<&str> {
self.schedule_arn.as_deref()
}
}
impl std::fmt::Debug for DeleteBusinessReportScheduleInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeleteBusinessReportScheduleInput");
formatter.field("schedule_arn", &self.schedule_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteAddressBookInput {
pub address_book_arn: std::option::Option<std::string::String>,
}
impl DeleteAddressBookInput {
pub fn address_book_arn(&self) -> std::option::Option<&str> {
self.address_book_arn.as_deref()
}
}
impl std::fmt::Debug for DeleteAddressBookInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DeleteAddressBookInput");
formatter.field("address_book_arn", &self.address_book_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateUserInput {
pub user_id: std::option::Option<std::string::String>,
pub first_name: std::option::Option<std::string::String>,
pub last_name: std::option::Option<std::string::String>,
pub email: std::option::Option<std::string::String>,
pub client_request_token: std::option::Option<std::string::String>,
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl CreateUserInput {
pub fn user_id(&self) -> std::option::Option<&str> {
self.user_id.as_deref()
}
pub fn first_name(&self) -> std::option::Option<&str> {
self.first_name.as_deref()
}
pub fn last_name(&self) -> std::option::Option<&str> {
self.last_name.as_deref()
}
pub fn email(&self) -> std::option::Option<&str> {
self.email.as_deref()
}
pub fn client_request_token(&self) -> std::option::Option<&str> {
self.client_request_token.as_deref()
}
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
impl std::fmt::Debug for CreateUserInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("CreateUserInput");
formatter.field("user_id", &self.user_id);
formatter.field("first_name", &self.first_name);
formatter.field("last_name", &self.last_name);
formatter.field("email", &self.email);
formatter.field("client_request_token", &self.client_request_token);
formatter.field("tags", &self.tags);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateSkillGroupInput {
pub skill_group_name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
pub client_request_token: std::option::Option<std::string::String>,
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl CreateSkillGroupInput {
pub fn skill_group_name(&self) -> std::option::Option<&str> {
self.skill_group_name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
pub fn client_request_token(&self) -> std::option::Option<&str> {
self.client_request_token.as_deref()
}
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
impl std::fmt::Debug for CreateSkillGroupInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("CreateSkillGroupInput");
formatter.field("skill_group_name", &self.skill_group_name);
formatter.field("description", &self.description);
formatter.field("client_request_token", &self.client_request_token);
formatter.field("tags", &self.tags);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateRoomInput {
pub room_name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
pub profile_arn: std::option::Option<std::string::String>,
pub provider_calendar_id: std::option::Option<std::string::String>,
pub client_request_token: std::option::Option<std::string::String>,
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl CreateRoomInput {
pub fn room_name(&self) -> std::option::Option<&str> {
self.room_name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
pub fn profile_arn(&self) -> std::option::Option<&str> {
self.profile_arn.as_deref()
}
pub fn provider_calendar_id(&self) -> std::option::Option<&str> {
self.provider_calendar_id.as_deref()
}
pub fn client_request_token(&self) -> std::option::Option<&str> {
self.client_request_token.as_deref()
}
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
impl std::fmt::Debug for CreateRoomInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("CreateRoomInput");
formatter.field("room_name", &self.room_name);
formatter.field("description", &self.description);
formatter.field("profile_arn", &self.profile_arn);
formatter.field("provider_calendar_id", &self.provider_calendar_id);
formatter.field("client_request_token", &self.client_request_token);
formatter.field("tags", &self.tags);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateProfileInput {
pub profile_name: std::option::Option<std::string::String>,
pub timezone: std::option::Option<std::string::String>,
pub address: std::option::Option<std::string::String>,
pub distance_unit: std::option::Option<crate::model::DistanceUnit>,
pub temperature_unit: std::option::Option<crate::model::TemperatureUnit>,
pub wake_word: std::option::Option<crate::model::WakeWord>,
pub locale: std::option::Option<std::string::String>,
pub client_request_token: std::option::Option<std::string::String>,
pub setup_mode_disabled: std::option::Option<bool>,
pub max_volume_limit: std::option::Option<i32>,
pub pstn_enabled: std::option::Option<bool>,
pub data_retention_opt_in: std::option::Option<bool>,
pub meeting_room_configuration:
std::option::Option<crate::model::CreateMeetingRoomConfiguration>,
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl CreateProfileInput {
pub fn profile_name(&self) -> std::option::Option<&str> {
self.profile_name.as_deref()
}
pub fn timezone(&self) -> std::option::Option<&str> {
self.timezone.as_deref()
}
pub fn address(&self) -> std::option::Option<&str> {
self.address.as_deref()
}
pub fn distance_unit(&self) -> std::option::Option<&crate::model::DistanceUnit> {
self.distance_unit.as_ref()
}
pub fn temperature_unit(&self) -> std::option::Option<&crate::model::TemperatureUnit> {
self.temperature_unit.as_ref()
}
pub fn wake_word(&self) -> std::option::Option<&crate::model::WakeWord> {
self.wake_word.as_ref()
}
pub fn locale(&self) -> std::option::Option<&str> {
self.locale.as_deref()
}
pub fn client_request_token(&self) -> std::option::Option<&str> {
self.client_request_token.as_deref()
}
pub fn setup_mode_disabled(&self) -> std::option::Option<bool> {
self.setup_mode_disabled
}
pub fn max_volume_limit(&self) -> std::option::Option<i32> {
self.max_volume_limit
}
pub fn pstn_enabled(&self) -> std::option::Option<bool> {
self.pstn_enabled
}
pub fn data_retention_opt_in(&self) -> std::option::Option<bool> {
self.data_retention_opt_in
}
pub fn meeting_room_configuration(
&self,
) -> std::option::Option<&crate::model::CreateMeetingRoomConfiguration> {
self.meeting_room_configuration.as_ref()
}
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
impl std::fmt::Debug for CreateProfileInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("CreateProfileInput");
formatter.field("profile_name", &self.profile_name);
formatter.field("timezone", &self.timezone);
formatter.field("address", &self.address);
formatter.field("distance_unit", &self.distance_unit);
formatter.field("temperature_unit", &self.temperature_unit);
formatter.field("wake_word", &self.wake_word);
formatter.field("locale", &self.locale);
formatter.field("client_request_token", &self.client_request_token);
formatter.field("setup_mode_disabled", &self.setup_mode_disabled);
formatter.field("max_volume_limit", &self.max_volume_limit);
formatter.field("pstn_enabled", &self.pstn_enabled);
formatter.field("data_retention_opt_in", &self.data_retention_opt_in);
formatter.field(
"meeting_room_configuration",
&self.meeting_room_configuration,
);
formatter.field("tags", &self.tags);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateNetworkProfileInput {
pub network_profile_name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
pub ssid: std::option::Option<std::string::String>,
pub security_type: std::option::Option<crate::model::NetworkSecurityType>,
pub eap_method: std::option::Option<crate::model::NetworkEapMethod>,
pub current_password: std::option::Option<std::string::String>,
pub next_password: std::option::Option<std::string::String>,
pub certificate_authority_arn: std::option::Option<std::string::String>,
pub trust_anchors: std::option::Option<std::vec::Vec<std::string::String>>,
pub client_request_token: std::option::Option<std::string::String>,
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl CreateNetworkProfileInput {
pub fn network_profile_name(&self) -> std::option::Option<&str> {
self.network_profile_name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
pub fn ssid(&self) -> std::option::Option<&str> {
self.ssid.as_deref()
}
pub fn security_type(&self) -> std::option::Option<&crate::model::NetworkSecurityType> {
self.security_type.as_ref()
}
pub fn eap_method(&self) -> std::option::Option<&crate::model::NetworkEapMethod> {
self.eap_method.as_ref()
}
pub fn current_password(&self) -> std::option::Option<&str> {
self.current_password.as_deref()
}
pub fn next_password(&self) -> std::option::Option<&str> {
self.next_password.as_deref()
}
pub fn certificate_authority_arn(&self) -> std::option::Option<&str> {
self.certificate_authority_arn.as_deref()
}
pub fn trust_anchors(&self) -> std::option::Option<&[std::string::String]> {
self.trust_anchors.as_deref()
}
pub fn client_request_token(&self) -> std::option::Option<&str> {
self.client_request_token.as_deref()
}
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
impl std::fmt::Debug for CreateNetworkProfileInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("CreateNetworkProfileInput");
formatter.field("network_profile_name", &self.network_profile_name);
formatter.field("description", &self.description);
formatter.field("ssid", &self.ssid);
formatter.field("security_type", &self.security_type);
formatter.field("eap_method", &self.eap_method);
formatter.field("current_password", &"*** Sensitive Data Redacted ***");
formatter.field("next_password", &"*** Sensitive Data Redacted ***");
formatter.field("certificate_authority_arn", &self.certificate_authority_arn);
formatter.field("trust_anchors", &self.trust_anchors);
formatter.field("client_request_token", &self.client_request_token);
formatter.field("tags", &self.tags);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateGatewayGroupInput {
pub name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
pub client_request_token: std::option::Option<std::string::String>,
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl CreateGatewayGroupInput {
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
pub fn client_request_token(&self) -> std::option::Option<&str> {
self.client_request_token.as_deref()
}
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
impl std::fmt::Debug for CreateGatewayGroupInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("CreateGatewayGroupInput");
formatter.field("name", &self.name);
formatter.field("description", &self.description);
formatter.field("client_request_token", &self.client_request_token);
formatter.field("tags", &self.tags);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateContactInput {
pub display_name: std::option::Option<std::string::String>,
pub first_name: std::option::Option<std::string::String>,
pub last_name: std::option::Option<std::string::String>,
pub phone_number: std::option::Option<std::string::String>,
pub phone_numbers: std::option::Option<std::vec::Vec<crate::model::PhoneNumber>>,
pub sip_addresses: std::option::Option<std::vec::Vec<crate::model::SipAddress>>,
pub client_request_token: std::option::Option<std::string::String>,
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl CreateContactInput {
pub fn display_name(&self) -> std::option::Option<&str> {
self.display_name.as_deref()
}
pub fn first_name(&self) -> std::option::Option<&str> {
self.first_name.as_deref()
}
pub fn last_name(&self) -> std::option::Option<&str> {
self.last_name.as_deref()
}
pub fn phone_number(&self) -> std::option::Option<&str> {
self.phone_number.as_deref()
}
pub fn phone_numbers(&self) -> std::option::Option<&[crate::model::PhoneNumber]> {
self.phone_numbers.as_deref()
}
pub fn sip_addresses(&self) -> std::option::Option<&[crate::model::SipAddress]> {
self.sip_addresses.as_deref()
}
pub fn client_request_token(&self) -> std::option::Option<&str> {
self.client_request_token.as_deref()
}
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
impl std::fmt::Debug for CreateContactInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("CreateContactInput");
formatter.field("display_name", &self.display_name);
formatter.field("first_name", &self.first_name);
formatter.field("last_name", &self.last_name);
formatter.field("phone_number", &"*** Sensitive Data Redacted ***");
formatter.field("phone_numbers", &self.phone_numbers);
formatter.field("sip_addresses", &self.sip_addresses);
formatter.field("client_request_token", &self.client_request_token);
formatter.field("tags", &self.tags);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateConferenceProviderInput {
pub conference_provider_name: std::option::Option<std::string::String>,
pub conference_provider_type: std::option::Option<crate::model::ConferenceProviderType>,
pub ip_dial_in: std::option::Option<crate::model::IpDialIn>,
pub pstn_dial_in: std::option::Option<crate::model::PstnDialIn>,
pub meeting_setting: std::option::Option<crate::model::MeetingSetting>,
pub client_request_token: std::option::Option<std::string::String>,
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl CreateConferenceProviderInput {
pub fn conference_provider_name(&self) -> std::option::Option<&str> {
self.conference_provider_name.as_deref()
}
pub fn conference_provider_type(
&self,
) -> std::option::Option<&crate::model::ConferenceProviderType> {
self.conference_provider_type.as_ref()
}
pub fn ip_dial_in(&self) -> std::option::Option<&crate::model::IpDialIn> {
self.ip_dial_in.as_ref()
}
pub fn pstn_dial_in(&self) -> std::option::Option<&crate::model::PstnDialIn> {
self.pstn_dial_in.as_ref()
}
pub fn meeting_setting(&self) -> std::option::Option<&crate::model::MeetingSetting> {
self.meeting_setting.as_ref()
}
pub fn client_request_token(&self) -> std::option::Option<&str> {
self.client_request_token.as_deref()
}
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
impl std::fmt::Debug for CreateConferenceProviderInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("CreateConferenceProviderInput");
formatter.field("conference_provider_name", &self.conference_provider_name);
formatter.field("conference_provider_type", &self.conference_provider_type);
formatter.field("ip_dial_in", &self.ip_dial_in);
formatter.field("pstn_dial_in", &self.pstn_dial_in);
formatter.field("meeting_setting", &self.meeting_setting);
formatter.field("client_request_token", &self.client_request_token);
formatter.field("tags", &self.tags);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateBusinessReportScheduleInput {
pub schedule_name: std::option::Option<std::string::String>,
pub s3_bucket_name: std::option::Option<std::string::String>,
pub s3_key_prefix: std::option::Option<std::string::String>,
pub format: std::option::Option<crate::model::BusinessReportFormat>,
pub content_range: std::option::Option<crate::model::BusinessReportContentRange>,
pub recurrence: std::option::Option<crate::model::BusinessReportRecurrence>,
pub client_request_token: std::option::Option<std::string::String>,
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl CreateBusinessReportScheduleInput {
pub fn schedule_name(&self) -> std::option::Option<&str> {
self.schedule_name.as_deref()
}
pub fn s3_bucket_name(&self) -> std::option::Option<&str> {
self.s3_bucket_name.as_deref()
}
pub fn s3_key_prefix(&self) -> std::option::Option<&str> {
self.s3_key_prefix.as_deref()
}
pub fn format(&self) -> std::option::Option<&crate::model::BusinessReportFormat> {
self.format.as_ref()
}
pub fn content_range(&self) -> std::option::Option<&crate::model::BusinessReportContentRange> {
self.content_range.as_ref()
}
pub fn recurrence(&self) -> std::option::Option<&crate::model::BusinessReportRecurrence> {
self.recurrence.as_ref()
}
pub fn client_request_token(&self) -> std::option::Option<&str> {
self.client_request_token.as_deref()
}
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
impl std::fmt::Debug for CreateBusinessReportScheduleInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("CreateBusinessReportScheduleInput");
formatter.field("schedule_name", &self.schedule_name);
formatter.field("s3_bucket_name", &self.s3_bucket_name);
formatter.field("s3_key_prefix", &self.s3_key_prefix);
formatter.field("format", &self.format);
formatter.field("content_range", &self.content_range);
formatter.field("recurrence", &self.recurrence);
formatter.field("client_request_token", &self.client_request_token);
formatter.field("tags", &self.tags);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateAddressBookInput {
pub name: std::option::Option<std::string::String>,
pub description: std::option::Option<std::string::String>,
pub client_request_token: std::option::Option<std::string::String>,
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl CreateAddressBookInput {
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
pub fn client_request_token(&self) -> std::option::Option<&str> {
self.client_request_token.as_deref()
}
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
impl std::fmt::Debug for CreateAddressBookInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("CreateAddressBookInput");
formatter.field("name", &self.name);
formatter.field("description", &self.description);
formatter.field("client_request_token", &self.client_request_token);
formatter.field("tags", &self.tags);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct AssociateSkillWithUsersInput {
pub skill_id: std::option::Option<std::string::String>,
}
impl AssociateSkillWithUsersInput {
pub fn skill_id(&self) -> std::option::Option<&str> {
self.skill_id.as_deref()
}
}
impl std::fmt::Debug for AssociateSkillWithUsersInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("AssociateSkillWithUsersInput");
formatter.field("skill_id", &self.skill_id);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct AssociateSkillWithSkillGroupInput {
pub skill_group_arn: std::option::Option<std::string::String>,
pub skill_id: std::option::Option<std::string::String>,
}
impl AssociateSkillWithSkillGroupInput {
pub fn skill_group_arn(&self) -> std::option::Option<&str> {
self.skill_group_arn.as_deref()
}
pub fn skill_id(&self) -> std::option::Option<&str> {
self.skill_id.as_deref()
}
}
impl std::fmt::Debug for AssociateSkillWithSkillGroupInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("AssociateSkillWithSkillGroupInput");
formatter.field("skill_group_arn", &self.skill_group_arn);
formatter.field("skill_id", &self.skill_id);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct AssociateSkillGroupWithRoomInput {
pub skill_group_arn: std::option::Option<std::string::String>,
pub room_arn: std::option::Option<std::string::String>,
}
impl AssociateSkillGroupWithRoomInput {
pub fn skill_group_arn(&self) -> std::option::Option<&str> {
self.skill_group_arn.as_deref()
}
pub fn room_arn(&self) -> std::option::Option<&str> {
self.room_arn.as_deref()
}
}
impl std::fmt::Debug for AssociateSkillGroupWithRoomInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("AssociateSkillGroupWithRoomInput");
formatter.field("skill_group_arn", &self.skill_group_arn);
formatter.field("room_arn", &self.room_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct AssociateDeviceWithRoomInput {
pub device_arn: std::option::Option<std::string::String>,
pub room_arn: std::option::Option<std::string::String>,
}
impl AssociateDeviceWithRoomInput {
pub fn device_arn(&self) -> std::option::Option<&str> {
self.device_arn.as_deref()
}
pub fn room_arn(&self) -> std::option::Option<&str> {
self.room_arn.as_deref()
}
}
impl std::fmt::Debug for AssociateDeviceWithRoomInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("AssociateDeviceWithRoomInput");
formatter.field("device_arn", &self.device_arn);
formatter.field("room_arn", &self.room_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct AssociateDeviceWithNetworkProfileInput {
pub device_arn: std::option::Option<std::string::String>,
pub network_profile_arn: std::option::Option<std::string::String>,
}
impl AssociateDeviceWithNetworkProfileInput {
pub fn device_arn(&self) -> std::option::Option<&str> {
self.device_arn.as_deref()
}
pub fn network_profile_arn(&self) -> std::option::Option<&str> {
self.network_profile_arn.as_deref()
}
}
impl std::fmt::Debug for AssociateDeviceWithNetworkProfileInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("AssociateDeviceWithNetworkProfileInput");
formatter.field("device_arn", &self.device_arn);
formatter.field("network_profile_arn", &self.network_profile_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct AssociateContactWithAddressBookInput {
pub contact_arn: std::option::Option<std::string::String>,
pub address_book_arn: std::option::Option<std::string::String>,
}
impl AssociateContactWithAddressBookInput {
pub fn contact_arn(&self) -> std::option::Option<&str> {
self.contact_arn.as_deref()
}
pub fn address_book_arn(&self) -> std::option::Option<&str> {
self.address_book_arn.as_deref()
}
}
impl std::fmt::Debug for AssociateContactWithAddressBookInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("AssociateContactWithAddressBookInput");
formatter.field("contact_arn", &self.contact_arn);
formatter.field("address_book_arn", &self.address_book_arn);
formatter.finish()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ApproveSkillInput {
pub skill_id: std::option::Option<std::string::String>,
}
impl ApproveSkillInput {
pub fn skill_id(&self) -> std::option::Option<&str> {
self.skill_id.as_deref()
}
}
impl std::fmt::Debug for ApproveSkillInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ApproveSkillInput");
formatter.field("skill_id", &self.skill_id);
formatter.finish()
}
}